Zum Hauptinhalt springen
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."
        }
      ]
    }
  ]
}
'
{
  "candidates": [
    {
      "content": {},
      "finishReason": "<string>"
    }
  ],
  "usageMetadata": {}
}

Documentation Index

Fetch the complete documentation index at: https://docs.langdock.com/llms.txt

Use this file to discover all available pages before exploring further.

⚠️ Du nutzt unsere API in einem Dedicated Deployment? Ersetze einfach api.langdock.com durch die Base URL deines Deployments: <deployment-url>/api/public

​
Google Completion Endpoint (v1beta)

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.
• Regionswahl (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
x-api-key Header Beispiel: 
curl -H "x-api-key: $LD_API_KEY" \
     https://api.langdock.com/google/eu/v1beta/models
x-goog-api-key Header Beispiel: 
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

​
models
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 offiziellen GenerateContentRequest 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?"
      }
    ]
  }
]
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-Parameter
  • candidateCount (number): Anzahl der zu generierenden Antwort-Kandidaten
  • maxOutputTokens (number): Maximale Anzahl zu generierender Token
  • stopSequences (string[]): Sequenzen, die die Generierung stoppen
  • responseMimeType (string): MIME-Typ der Antwort
  • responseSchema (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): Funktionsname
  • description (string): Funktionsbeschreibung
  • parameters (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 action streamGenerateContent 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..." }]
      }
    }
  ]
}
Python SDK Beispiel mit Function Calling: 
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)
Python SDK Streaming Beispiel: 
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

​
Authorization
string
header
erforderlich

API key as Bearer token. Format "Bearer YOUR_API_KEY"

Pfadparameter

​
region
enum<string>
erforderlich

The region of the API to use.

Verfügbare Optionen:
eu,
us
​
model
string
erforderlich

The model ID (e.g., gemini-2.5-pro, gemini-2.5-flash).

Body

application/json
​
contents
object[]
erforderlich

The content to generate a response for.

Antwort

Successful Response

​
candidates
object[]
​
usageMetadata
object