Source: https://ailoot.ai/docs/de/connect/google-genai/
Canonical: https://ailoot.ai/docs/de/connect/google-genai/
Language: de

[Anbindung](https://ailoot.ai/docs/de/) 

# Google GenAI SDK

[Markdown](https://ailoot.ai/docs/de/connect/google-genai/index.md)

Das native Gemini-Format: Google GenAI SDK für Python und JavaScript sowie direkte REST-Anfragen.

## [](https://ailoot.ai/docs/de/connect/google-genai/#install)Installation

```bash
pip install google-genai
```

```bash
npm install @google/genai
```

## [](https://ailoot.ai/docs/de/connect/google-genai/#client)Anbindung

Die Adresse lautet `https://api.ailoot.ai` ohne `/v1beta`: Das SDK setzt den Pfad `/v1beta/models/<Modell>:generateContent` selbst zusammen. In Python wird die Adresse über `HttpOptions(base_url=…)`, in JavaScript über `httpOptions.baseUrl` angegeben. Den Schlüssel sendet das SDK im Header `x-goog-api-key`.

```python
from google import genai
from google.genai import types
import os

client = genai.Client(
    api_key=os.environ["AILOOT_API_KEY"],
    http_options=types.HttpOptions(base_url="https://api.ailoot.ai"),  # ohne /v1beta
)

resp = client.models.generate_content(
    model="gemini-3.8-flash",
    contents="Schlage drei Namen für ein Café vor.",
)
print(resp.text)
```

```js
import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({
  apiKey: process.env.AILOOT_API_KEY,
  httpOptions: { baseUrl: "https://api.ailoot.ai" }, // ohne /v1beta
});

const resp = await ai.models.generateContent({
  model: "gemini-3.8-flash",
  contents: "Schlage drei Namen für ein Café vor.",
});
console.log(resp.text);
```

```bash
curl "https://api.ailoot.ai/v1beta/models/gemini-3.8-flash:generateContent" \
  -H "x-goog-api-key: $AILOOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [
      {"role": "user", "parts": [{"text": "Schlage drei Namen für ein Café vor."}]}
    ]
  }' 
```

## [](https://ailoot.ai/docs/de/connect/google-genai/#body)Was übergeben werden kann

- Felder auf oberster Ebene: `contents`, `systemInstruction`, `generationConfig`, `safetySettings`, `tools` und `toolConfig`.
- `generationConfig` akzeptiert `temperature`, `topP`, `topK`, `maxOutputTokens`, `thinkingConfig`, `responseMimeType` (`text/plain` oder `application/json`), `responseSchema` oder `responseJsonSchema` (JSON-Objekt), `stopSequences` (Array von Zeichenfolgen), `candidateCount: 1`, ganzzahliges `seed`, numerische `presencePenalty` und `frequencyPenalty`. Zulässige Wertebereiche und Funktionen hängen vom genauen Modell ab; wählen Sie für eine JSON-Antwort eine unterstützte Schemaform und `application/json`. Bei Textmodellen ist `responseModalities` — ausschließlich `["TEXT"]`.
- `safetySettings` — Array von Objekten mit `category`, `threshold` und dem optionalen `method`; wählen Sie die Werte anhand der Dokumentation des genauen Modells.
- Für Gemini-Modelle mit Unterstützung für die jeweilige Eingabe gilt: `parts[].inlineData` enthält `mimeType` und nicht leere base64-Daten; eine PDF-Datei muss eine echte PDF-Datei sein. `fileData` enthält eine öffentliche `https`-Adresse in `fileUri` und den MIME-Typ der Datei. Für YouTube kann der MIME-Typ weggelassen werden. `http`, private Adressen, `gs://` und Objekte der Google Files API werden nicht unterstützt; auch Uploads über die Google Files API sind nicht möglich. Bei Video können Sie `videoMetadata`: `startOffset`/`endOffset` als Zeichenfolge in Sekunden angeben (zum Beispiel `1.5s`) und `fps` mit einem Wert größer als 0 und höchstens 24 angeben. Größe des Anfrageinhalts, Kontext, zulässige Eingabe und Antwortlimit werden anhand von Modell und Format geprüft.
- Clientseitige `functionDeclarations` werden von Ihrer Anwendung ausgeführt. Textmodelle akzeptieren außerdem `{"googleSearch": {}}` und `{"urlContext": {}}`: einzeln oder gemeinsam im Array `tools`. Weder Google Search noch URL context dürfen zusammen mit `functionDeclarations` in einer Anfrage verwendet werden. Für Bilder in der Ausgabe stehen ausschließlich clientseitige Funktionen zur Verfügung. Weitere integrierte Tools und explicit cache werden nicht unterstützt. Search/URL context können eine Reservierung anhand des vollständigen Eingabelimits erfordern; die tatsächlich angefallenen `toolUsePromptTokenCount` werden als Eingabetokens gezählt.
- Wenn das Modell ein Feld, einen Anhang oder eine Tool-Kombination nicht unterstützt, wird die Anfrage vor der Reservierung abgelehnt; es wird nichts abgebucht. Sie erhalten HTTP `400` mit `status` `INVALID_ARGUMENT` und der Klasse `invalid_request` (in `ErrorInfo.reason` — `INVALID_REQUEST`). Ungültiges JSON, Fehler in Pfadparametern und anderen Prüfungen liefern ebenfalls `400`; lesen Sie den Fehlertext und die Request ID. Die Funktionen hängen vom Modell ab: Prüfen Sie dessen Formate und Eingaben im Katalog.

| Eingabe | Unterstützte MIME-Typen |
| --- | --- |
| Inline-Bilder | image/png, image/jpeg, image/webp |
| Dokumente | application/pdf; text/plain, text/html, text/css, text/csv, text/xml, text/rtf, text/markdown, text/javascript, application/x-javascript, text/x-python, application/x-python |
| Audio | audio/wav, audio/mp3, audio/mpeg, audio/aiff, audio/aac, audio/ogg, audio/flac |
| Video | video/mp4, video/mpeg, video/mov, video/quicktime, video/avi, video/x-flv, video/mpg, video/webm, video/wmv, video/3gpp |

```python
import json, os, urllib.request

def generate(model, payload):
    req = urllib.request.Request(
        "https://api.ailoot.ai/v1beta/models/" + model + ":generateContent",
        data=json.dumps(payload).encode(),
        headers={"x-goog-api-key": os.environ["AILOOT_API_KEY"],
                 "Content-Type": "application/json"},
    )
    # Nur einmal senden. Prüfen Sie nach einem Timeout die Request ID in Ihrem Nutzungsverlauf, bevor Sie es erneut versuchen.
    with urllib.request.urlopen(req, timeout=300) as response:
        print("Request ID:", response.headers.get("X-Request-ID"))
        return json.load(response)

import base64, pathlib, sys

# Geben Sie eine echte lokale PDF-, Audio- oder Videodatei und den unterstützten MIME-Typ an.
path, mime = pathlib.Path(sys.argv[1]), sys.argv[2]
payload = {"contents": [{"role": "user", "parts": [
    {"text": "Beschreibe kurz den Inhalt der Datei."},
    {"inlineData": {"mimeType": mime,
                    "data": base64.b64encode(path.read_bytes()).decode()}},
]}]}
print(generate("gemini-3.8-flash", payload))
# Alternativer Anhang: {"fileData": {"mimeType": mime, "fileUri": public_https_url}}
# Für eine echte YouTube-URL: {"fileData": {"fileUri": youtube_url}}
```

## [](https://ailoot.ai/docs/de/connect/google-genai/#function-loop)Vollständiger Funktionszyklus

Übermitteln Sie die Deklaration, erhalten Sie functionCall, führen Sie Ihre Funktion aus, geben Sie functionResponse zurück und fordern Sie die nächste Antwort an. Behalten Sie den gesamten content des Modells einschließlich thoughtSignature bei; erzeugen Sie die Signatur nicht selbst.

```python
import json, os, urllib.request

def generate(model, payload):
    req = urllib.request.Request(
        "https://api.ailoot.ai/v1beta/models/" + model + ":generateContent",
        data=json.dumps(payload).encode(),
        headers={"x-goog-api-key": os.environ["AILOOT_API_KEY"],
                 "Content-Type": "application/json"},
    )
    # Nur einmal senden. Prüfen Sie nach einem Timeout die Request ID in Ihrem Nutzungsverlauf, bevor Sie es erneut versuchen.
    with urllib.request.urlopen(req, timeout=300) as response:
        print("Request ID:", response.headers.get("X-Request-ID"))
        return json.load(response)

tools = [{"functionDeclarations": [{
    "name": "multiply", "description": "Zwei Zahlen multiplizieren",
    "parameters": {"type": "object", "properties": {
        "a": {"type": "number"}, "b": {"type": "number"}},
        "required": ["a", "b"]},
}]}]
contents = [{"role": "user", "parts": [{"text": "Multipliziere 7 mit 8 mithilfe der Funktion"}]}]
for turn in range(4):  # Begrenzen Sie die Tool-Schleife; senden Sie eine Anfrage mit unklarem Ergebnis nicht erneut.
    reply = generate("gemini-3.8-flash", {"contents": contents, "tools": tools})
    content = reply["candidates"][0]["content"]
    contents.append(content)  # Behalten Sie ALLE ursprünglichen parts und thoughtSignature unverändert bei.
    results = []
    for part in content.get("parts", []):
        call = part.get("functionCall")
        if not call:
            continue
        if call["name"] != "multiply":
            raise ValueError("Unexpected function")
        args = call["args"]
        result = {"name": call["name"], "response": {"value": args["a"] * args["b"]}}
        if "id" in call:
            result["id"] = call["id"]
        results.append({"functionResponse": result})
    if not results:
        print(content)
        break
    contents.append({"role": "user", "parts": results})
else:
    raise RuntimeError("Tool loop limit reached")
```

## [](https://ailoot.ai/docs/de/connect/google-genai/#stream)Streaming-Antwort

```python
for chunk in client.models.generate_content_stream(
    model="gemini-3.8-flash",
    contents="Beschreibe einen Sonnenuntergang über dem Meer",
):
    print(chunk.text, end="", flush=True)
```

```bash
curl -N "https://api.ailoot.ai/v1beta/models/gemini-3.8-flash:streamGenerateContent?alt=sse" \
  -H "x-goog-api-key: $AILOOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"contents": [{"role": "user", "parts": [{"text": "Beschreibe einen Sonnenuntergang über dem Meer"}]}]}' 
```

Die kostenpflichtige Gemini-Antwort liefert Ailoot nach der Kostenberechnung. Der Streaming-Text kommt vollständig nach Abschluss des Modells, nicht Wort für Wort. Im Gemini-Stream gibt es keine Steuerzeilen; planen Sie für lange Antworten daher genügend Spielraum beim Client-Timeout ein.

## [](https://ailoot.ai/docs/de/connect/google-genai/#models)Verfügbare Modelle

Im Gemini-Format stehen 27 Kennungen zur Verfügung: `gemini-3.8-flash`, `gemini-3.1-pro`, `gemini-pro-agent`, `gemini-3.8-flash-tiered`, `gemini-3.8-flash-medium`, `gemini-3.8-flash-low`, `gemini-3.8-flash-high`, `gemini-3.7-flash`, `gemini-3.7-flash-tiered`, `gemini-3.7-flash-medium`, `gemini-3.7-flash-low`, `gemini-3.7-flash-high`, `gemini-3.6-flash`, `gemini-3.6-flash-tiered`, `gemini-3.6-flash-medium`, `gemini-3.6-flash-low`, `gemini-3.6-flash-high`, `gemini-3.5-flash-lite`, `gemini-3.1-pro-preview`, `gemini-3.1-pro-low`, `gemini-3.1-pro-high`, `gemini-3.1-flash-lite`, `gemini-3-flash`, `gemini-2.5-pro`, `gemini-2.5-flash`, `gemini-2.5-flash-thinking`, `gemini-2.5-flash-lite`.

Gemini-Modelle sind auch im Format Anthropic Messages verfügbar, was für Clients praktisch ist, die nur dieses Format unterstützen: [Anthropic SDK](https://ailoot.ai/docs/de/connect/anthropic-sdk/).

Noch Fragen? Senden Sie uns die Request ID und eine Beschreibung, damit wir Ihnen weiterhelfen können.[Support kontaktieren](mailto:support@ailoot.ai)

## Ailoot · Das Unternehmen und sein Projektportfolio





Ailoot baut auf bewährte Betriebserfahrung, einen großen Kundenstamm, stabilen Service und kontinuierliche KPI-Kontrolle.





Das Unternehmen und sein Projektportfolio: Millionen von Kunden; monatliche Umsätze in Milliardenhöhe.





Ailoot nutzt diese Betriebserfahrung für den API-Zugang zu KI-Funktionen in Kundenprodukten, Agenten, Anwendungen und Automatisierungen.
