Generate Content
curl --request POST \
--url https://api.langdock.com/google/{region}/v1beta/models/{model}:generateContent \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '
{
"contents": [
{
"role": "user",
"parts": [
{
"text": "Write a short haiku about the ocean."
}
]
}
]
}
'import requests
url = "https://api.langdock.com/google/{region}/v1beta/models/{model}:generateContent"
payload = { "contents": [
{
"role": "user",
"parts": [{ "text": "Write a short haiku about the ocean." }]
}
] }
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.text)const options = {
method: 'POST',
headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
body: JSON.stringify({
contents: [{role: 'user', parts: [{text: 'Write a short haiku about the ocean.'}]}]
})
};
fetch('https://api.langdock.com/google/{region}/v1beta/models/{model}:generateContent', options)
.then(res => res.json())
.then(res => console.log(res))
.catch(err => console.error(err));<?php
$curl = curl_init();
curl_setopt_array($curl, [
CURLOPT_URL => "https://api.langdock.com/google/{region}/v1beta/models/{model}:generateContent",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'contents' => [
[
'role' => 'user',
'parts' => [
[
'text' => 'Write a short haiku about the ocean.'
]
]
]
]
]),
CURLOPT_HTTPHEADER => [
"Authorization: Bearer <token>",
"Content-Type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "https://api.langdock.com/google/{region}/v1beta/models/{model}:generateContent"
payload := strings.NewReader("{\n \"contents\": [\n {\n \"role\": \"user\",\n \"parts\": [\n {\n \"text\": \"Write a short haiku about the ocean.\"\n }\n ]\n }\n ]\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("Authorization", "Bearer <token>")
req.Header.Add("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(string(body))
}HttpResponse<String> response = Unirest.post("https://api.langdock.com/google/{region}/v1beta/models/{model}:generateContent")
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.body("{\n \"contents\": [\n {\n \"role\": \"user\",\n \"parts\": [\n {\n \"text\": \"Write a short haiku about the ocean.\"\n }\n ]\n }\n ]\n}")
.asString();require 'uri'
require 'net/http'
url = URI("https://api.langdock.com/google/{region}/v1beta/models/{model}:generateContent")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n \"contents\": [\n {\n \"role\": \"user\",\n \"parts\": [\n {\n \"text\": \"Write a short haiku about the ocean.\"\n }\n ]\n }\n ]\n}"
response = http.request(request)
puts response.read_body{
"candidates": [
{
"content": {},
"finishReason": "<string>"
}
],
"usageMetadata": {}
}{
"type": "error",
"error": {
"type": "invalid_request_error",
"message": "Invalid request"
}
}Completion API
Google Completion API
Generiere Text mit Google Gemini-Modellen über Langdocks öffentliche API. Unterstützt normale und Streaming-Completions und ist vollständig kompatibel mit den offiziellen Vertex AI SDKs (Python / Node).
POST
/
google
/
{region}
/
v1beta
/
models
/
{model}
:generateContent
Generate Content
curl --request POST \
--url https://api.langdock.com/google/{region}/v1beta/models/{model}:generateContent \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '
{
"contents": [
{
"role": "user",
"parts": [
{
"text": "Write a short haiku about the ocean."
}
]
}
]
}
'import requests
url = "https://api.langdock.com/google/{region}/v1beta/models/{model}:generateContent"
payload = { "contents": [
{
"role": "user",
"parts": [{ "text": "Write a short haiku about the ocean." }]
}
] }
headers = {
"Authorization": "Bearer <token>",
"Content-Type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.text)const options = {
method: 'POST',
headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
body: JSON.stringify({
contents: [{role: 'user', parts: [{text: 'Write a short haiku about the ocean.'}]}]
})
};
fetch('https://api.langdock.com/google/{region}/v1beta/models/{model}:generateContent', options)
.then(res => res.json())
.then(res => console.log(res))
.catch(err => console.error(err));<?php
$curl = curl_init();
curl_setopt_array($curl, [
CURLOPT_URL => "https://api.langdock.com/google/{region}/v1beta/models/{model}:generateContent",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'contents' => [
[
'role' => 'user',
'parts' => [
[
'text' => 'Write a short haiku about the ocean.'
]
]
]
]
]),
CURLOPT_HTTPHEADER => [
"Authorization: Bearer <token>",
"Content-Type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "https://api.langdock.com/google/{region}/v1beta/models/{model}:generateContent"
payload := strings.NewReader("{\n \"contents\": [\n {\n \"role\": \"user\",\n \"parts\": [\n {\n \"text\": \"Write a short haiku about the ocean.\"\n }\n ]\n }\n ]\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("Authorization", "Bearer <token>")
req.Header.Add("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(string(body))
}HttpResponse<String> response = Unirest.post("https://api.langdock.com/google/{region}/v1beta/models/{model}:generateContent")
.header("Authorization", "Bearer <token>")
.header("Content-Type", "application/json")
.body("{\n \"contents\": [\n {\n \"role\": \"user\",\n \"parts\": [\n {\n \"text\": \"Write a short haiku about the ocean.\"\n }\n ]\n }\n ]\n}")
.asString();require 'uri'
require 'net/http'
url = URI("https://api.langdock.com/google/{region}/v1beta/models/{model}:generateContent")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n \"contents\": [\n {\n \"role\": \"user\",\n \"parts\": [\n {\n \"text\": \"Write a short haiku about the ocean.\"\n }\n ]\n }\n ]\n}"
response = http.request(request)
puts response.read_body{
"candidates": [
{
"content": {},
"finishReason": "<string>"
}
],
"usageMetadata": {}
}{
"type": "error",
"error": {
"type": "invalid_request_error",
"message": "Invalid request"
}
}Google Completion Endpoint (v1beta)
Bevor du startest
- API-Key: Um die API zu nutzen, erstellst du einen persönlichen API-Key oder fragst deinen Workspace-Admin nach einem Workspace-API-Key mit dem Scope Completion API.
Basis-URL
https://api.langdock.com/google/{region}/v1beta/models/{model}:generateContent
Dedicated DeploymentsErsetze
api.langdock.com durch <your-deployment-url>/api/public in allen Anfragen.So funktioniert es
Dieser Endpoint stellt Google Gemini-Modelle zur Verfügung, die in Google Vertex AI gehostet werden. Er spiegelt die Struktur der offiziellen Vertex generateContent API wider. Um ihn zu verwenden, musst du:1
Verfügbare Modelle abrufen
Rufe
GET //v1beta/models/ auf, um die Liste der Gemini-Modelle abzurufen.2
Modell & Aktion auswählen
Wähle eine Modell-ID und entscheide zwischen
generateContent oder streamGenerateContent.3
Anfrage senden
POST an
//v1beta/models/: mit deinem Prompt in contents.4
Antwort verarbeiten
Parse die JSON-Antwort für normale Aufrufe oder konsumiere die SSE-Events für Streaming.
eu oder us)• Optionales Server-Sent Event (SSE) Streaming mit denselben Event-Labels wie im Google Python SDK (
message_start, message_delta, message_stop)• Ein models Discovery-Endpoint
Authentifizierung
Sende einen der folgenden Header mit deinem Langdock API Key: Alle Header werden identisch behandelt. Fehlende oder ungültige Schlüssel geben 401 Unauthorized zurück. Authorization Header Beispiel:curl -H "Authorization: Bearer $LD_API_KEY" \
https://api.langdock.com/google/eu/v1beta/models
curl -H "x-api-key: $LD_API_KEY" \
https://api.langdock.com/google/eu/v1beta/models
curl -H "x-goog-api-key: $LD_API_KEY" \
https://api.langdock.com/google/eu/v1beta/models
1. Verfügbare Modelle auflisten
GET /{region}/v1beta/models
region muss eu oder us sein.
Erfolgreiche Antwort
array
Liste von Objekten mit der folgenden Struktur:
- name – Vollständig qualifizierter Modellname (z.B.
models/gemini-2.5-flash). - supportedGenerationMethods – Immer
["generateContent", "streamGenerateContent"].
curl -H "Authorization: Bearer $LD_API_KEY" \
https://api.langdock.com/google/eu/v1beta/models
2. Content generieren
POST /{region}/v1beta/models/{model}:{action}
• model – Die Modell-ID wie vom models Endpoint zurückgegeben (ohne das models/ Präfix).• action –
generateContent oder streamGenerateContent je nachdem, ob du Streaming verwenden möchtest oder nicht.
Beispiel-Pfad: google/eu/v1beta/models/gemini-2.5-flash:streamGenerateContent
Request Body
Der Request Body folgt der offiziellenGenerateContentRequest Struktur.
Pflichtfelder
contents (Content[], erforderlich)Gesprächsverlauf. Jedes Objekt hat eine role (string) und parts Array mit Objekten, die text (string) enthalten.
"contents": [
{
"role": "user",
"parts": [
{
"text": "Wie ist das Wetter?"
}
]
}
]
functionCall- und functionResponse-Objekte für Function Calling sein. Bei Gemini-3-Modellen musst du die thoughtSignature (und die Function-Call-id) aus dem functionCall-Part des Modells unverändert in der nächsten Anfrage zurücksenden. Die offiziellen SDKs machen das automatisch; bei manuell gebauten Requests kopierst du die Felder unverändert.
model (string, erforderlich)Das Modell für die Generierung (z.B. “gemini-2.5-pro”, “gemini-2.5-flash”).
Optionale Felder
generationConfig (object, optional)Konfiguration für die Textgenerierung. Unterstützte Felder:
temperature(number): Steuert Zufälligkeit (0.0-2.0)topP(number): Nucleus-Sampling-Parameter (0.0-1.0)topK(number): Top-k-Sampling-ParametercandidateCount(number): Anzahl der zu generierenden Antwort-KandidatenmaxOutputTokens(number): Maximale Anzahl zu generierender TokenstopSequences(string[]): Sequenzen, die die Generierung stoppenresponseMimeType(string): MIME-Typ der AntwortresponseSchema(object): Schema für strukturierte Ausgabe
"generationConfig": {
"temperature": 0.7,
"topP": 0.9,
"topK": 40,
"maxOutputTokens": 1000,
"stopSequences": ["END", "STOP"]
}
safetySettings (SafetySetting[], optional)Array von Safety-Setting-Objekten. Jedes Objekt enthält:
category(string): Die Harm-Kategorie (z.B. “HARM_CATEGORY_HARASSMENT”)threshold(string): Der Blocking-Schwellwert (z.B. “BLOCK_MEDIUM_AND_ABOVE”)
"safetySettings": [
{
"category": "HARM_CATEGORY_HARASSMENT",
"threshold": "BLOCK_MEDIUM_AND_ABOVE"
}
]
tools (Tool[], optional)Array von Tool-Objekten für Function Calling. Jedes Tool enthält ein
functionDeclarations Array mit:
name(string): Funktionsnamedescription(string): Funktionsbeschreibungparameters(object): JSON-Schema, das Funktionsparameter definiert
"tools": [
{
"functionDeclarations": [
{
"name": "get_weather",
"description": "Aktuelle Wetterinformationen abrufen",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "Stadtname"
}
}
}
}
]
}
]
toolConfig (object, optional)Konfiguration für Function Calling. Enthält
functionCallingConfig mit:
mode(string): Function-Calling-Modus (“ANY”, “AUTO”, “NONE”)allowedFunctionNames(string[]): Array erlaubter Funktionsnamen
"toolConfig": {
"functionCallingConfig": {
"mode": "ANY",
"allowedFunctionNames": ["get_weather"]
}
}
systemInstruction (string | Content, optional)Systemanweisung zur Steuerung des Modellverhaltens. Kann ein String oder Content-Objekt mit Rolle und Teilen sein.
"systemInstruction": {
"role": "system",
"parts": [
{
"text": "Du bist ein Wetter-Agent. Verwende das Wetter-Tool, wenn nach dem Wetter gefragt wird."
}
]
}
Wenn
toolConfig.functionCallingConfig.allowedFunctionNames bereitgestellt wird, muss mode ANY sein.Minimales Beispiel
curl -X POST \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $LD_API_KEY" \
https://api.langdock.com/google/us/v1beta/models/gemini-2.5-pro:generateContent \
-d '{
"contents": [{
"role": "user",
"parts": [{"text": "Schreibe ein kurzes Gedicht über das Meer."}]
}]
}'
Streaming
Wenn actionstreamGenerateContent ist, gibt der Endpoint einen
text/event-stream mit kompatiblen Events zurück:
• message_start – erster Chunk, der Content enthält•
message_delta – nachfolgende Chunks•
message_stop – letzter Chunk (enthält finishReason und Nutzungs-Metadaten)
Beispiel message_delta Event:
event: message_delta
data: {
"candidates": [
{
"index": 0,
"content": {
"role": "model",
"parts": [{ "text": "Das Meer flüstert..." }]
}
}
]
}
import google.generativeai as genai
def get_current_weather(location):
"""Das aktuelle Wetter an einem gegebenen Ort abrufen"""
return f"Das aktuelle Wetter in {location} ist sonnig mit einer Temperatur von 21 Grad und einer Windgeschwindigkeit von 8 km/h."
genai.configure(
api_key="<YOUR_LANGDOCK_API_KEY>",
transport="rest",
client_options={"api_endpoint": "https://api.langdock.com/google/<REGION>/"},
)
model = genai.GenerativeModel("gemini-2.5-flash", tools=[get_current_weather])
response = model.generate_content(
"Bitte sag mir das Wetter in San Francisco, dann erzähl mir eine Geschichte über die Geschichte der Stadt"
)
print(response)
model = genai.GenerativeModel("gemini-2.5-flash")
response = model.generate_content(
"Erzähl mir eine ausführliche Geschichte über die Geschichte der Stadt San Francisco",
stream=True,
)
for chunk in response:
if chunk.text:
print(chunk.text)
Google-kompatible Bibliotheken verwenden
Der Endpoint ist vollständig kompatibel mit offiziellen Google SDKs, einschließlich der Vertex AI Node SDK (@google-cloud/vertexai), der Google Generative AI Python Bibliothek (google-generative-ai) und der Vercel AI SDK für Edge Streaming.
Langdock blockiert bewusst Browser-basierte Anfragen, um deinen API-Schlüssel zu schützen und die Sicherheit deiner Anwendungen zu gewährleisten. Weitere Informationen findest du in unserem Guide zu Best Practices für API-Schlüssel.
Autorisierungen
API key as Bearer token. Format "Bearer YOUR_API_KEY"
Pfadparameter
The region of the API to use.
Verfügbare Optionen:
eu, us The model ID (e.g., gemini-2.5-pro, gemini-2.5-flash).
Body
application/json
Conversation history. Parts may be text, functionCall, or functionResponse.
Show child attributes
Show child attributes
War diese Seite hilfreich?