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

[Verbindung einrichten](https://ailoot.ai/docs/de-ch/) 

# Google GenAI SDK

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

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

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

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

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

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

Adresse: `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` festgelegt. 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="Denke dir drei Namen für ein Café aus.",
)
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: "Denke dir drei Namen für ein Café aus.",
});
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": "Denke dir drei Namen für ein Café aus."}]}
    ]
  }' 
```

## [](https://ailoot.ai/docs/de-ch/connect/google-genai/#body)Mögliche Eingaben

- 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`. Gültige 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 unterstützt `responseModalities` nur `["TEXT"]`.
- `safetySettings` — Array von Objekten mit `category`, `threshold` und optionalem `method`; wählen Sie die Werte anhand der Dokumentation des genauen Modells.
- Bei Gemini-Modellen mit Unterstützung der jeweiligen Eingabe enthält `parts[].inlineData` das Feld `mimeType` und nicht leere base64-Daten; eine PDF-Datei muss tatsächlich im PDF-Format vorliegen. `fileData` enthält eine öffentliche `https`-Adresse in `fileUri` und den MIME-Typ der Datei. Bei YouTube kann der MIME-Typ weggelassen werden. `http`, private Adressen, `gs://` und Google-Files-API-Objekte werden nicht unterstützt, ebenso wenig Uploads über die Google Files API. Bei Videos können Sie `videoMetadata`: `startOffset`/`endOffset` als Zeichenfolge in Sekunden (zum Beispiel `1.5s`) und `fps` grösser als 0 und höchstens 24 hinzufügen. Die Grösse des Anfragekörpers, der Kontext, die zulässige Eingabe und das Antwortlimit werden anhand von Modell und Format geprüft.
- Clientseitige `functionDeclarations` werden von Ihrer Anwendung ausgeführt. Bei Textmodellen werden ausserdem `{"googleSearch": {}}` und `{"urlContext": {}}` akzeptiert: einzeln oder zusammen im Array `tools`. Weder Google Search noch URL context dürfen mit `functionDeclarations` in derselben Anfrage kombiniert werden. Bei Bildausgaben sind nur clientseitige Funktionen verfügbar. Andere integrierte Werkzeuge und explicit cache werden nicht unterstützt. Search/URL context können eine Reservierung für das gesamte Eingabelimit erfordern; die tatsächlichen `toolUsePromptTokenCount` werden als Eingabetokens berücksichtigt.
- Unterstützt das Modell ein Feld, einen Anhang oder eine Werkzeugkombination nicht, wird die Anfrage vor der Reservierung abgelehnt — es wird nichts abgebucht. Die Antwort ist HTTP `400` mit `status` `INVALID_ARGUMENT` und der Klasse `invalid_request` (in `ErrorInfo.reason` — `INVALID_REQUEST`). Ungültiges JSON sowie Fehler bei Pfadparametern und anderen Prüfungen führen ebenfalls zu `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"},
    )
    # Einmal senden. Nach einem Timeout vor einem erneuten Versuch die Request ID im Nutzungsverlauf prüfen.
    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

# Eine echte lokale PDF-, Audio- oder Videodatei und ihren unterstützten MIME-Typ angeben.
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-ch/connect/google-genai/#function-loop)Vollständiger Funktionsablauf

Übermitteln Sie die Funktionsdeklaration, empfangen Sie functionCall, führen Sie Ihre Funktion aus, senden Sie functionResponse zurück und fordern Sie die nächste Antwort an. Behalten Sie den gesamten content des Modells einschliesslich thoughtSignature bei; erstellen 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"},
    )
    # Einmal senden. Nach einem Timeout vor einem erneuten Versuch die Request ID im Nutzungsverlauf prüfen.
    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):  # Die Tool-Schleife begrenzen; keine Anfrage erneut senden, deren Ergebnis unklar ist.
    reply = generate("gemini-3.8-flash", {"contents": contents, "tools": tools})
    content = reply["candidates"][0]["content"]
    contents.append(content)  # Alle ursprünglichen parts (ALL) und thoughtSignature unverändert beibehalten.
    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-ch/connect/google-genai/#stream)Streaming-Antwort

```python
for chunk in client.models.generate_content_stream(
    model="gemini-3.8-flash",
    contents="Beschreibe den 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 den Sonnenuntergang über dem Meer"}]}]}' 
```

Eine kostenpflichtige Gemini-Antwort liefert Ailoot nach der Kostenberechnung: Der Text des Streams kommt nach Abschluss des Modells vollständig, nicht Wort für Wort. Im Gemini-Stream gibt es keine Statuszeilen; stellen Sie den Client-Timeout bei langen Antworten daher ausreichend hoch ein.

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

Im Gemini-Format sind 27 IDs verfügbar: `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 Anthropic-Messages-Format verfügbar — praktisch für Clients, die nur dieses Format unterstützen: [Anthropic SDK](https://ailoot.ai/docs/de-ch/connect/anthropic-sdk/).

Noch Fragen? Schicken Sie uns die Request ID und eine Beschreibung — wir helfen Ihnen weiter.[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.