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

[Einrichtung](https://ailoot.ai/docs/de-at/) 

# Google GenAI SDK

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

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

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

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

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

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

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` gesetzt. 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="Denk dir drei Namen für ein Kaffeehaus 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: "Denk dir drei Namen für ein Kaffeehaus 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": "Denk dir drei Namen für ein Kaffeehaus aus."}]}
    ]
  }' 
```

## [](https://ailoot.ai/docs/de-at/connect/google-genai/#body)Welche Eingaben möglich sind

- 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 aus Strings), `candidateCount: 1`, ganzzahliges `seed`, numerische Werte für `presencePenalty` und `frequencyPenalty`. Zulässige Wertebereiche und Funktionen hängen vom konkreten Modell ab; wählen Sie für JSON-Antworten eine unterstützte Schemaform und `application/json`. Bei Textmodellen ist `responseModalities` — ausschließlich `["TEXT"]`.
- `safetySettings` — ein Array aus Objekten mit `category`, `threshold` und optionalem `method`; wählen Sie die Werte anhand der Dokumentation des konkreten Modells.
- Bei Gemini-Modellen mit Unterstützung der jeweiligen Eingabeart gilt: `parts[].inlineData` enthält `mimeType` und nicht leere base64-Daten; ein PDF muss eine echte PDF-Datei sein. `fileData` enthält eine öffentliche `https`-Adresse in `fileUri` und den MIME-Typ der Datei. Bei YouTube kann der MIME-Typ entfallen. `http`, private Adressen, `gs://` und Objekte der Google Files API werden nicht unterstützt, ebenso wenig Uploads über die Google Files API. Bei Videos können Sie außerdem Folgendes ergänzen: `videoMetadata`: `startOffset`/`endOffset` als String in Sekunden (zum Beispiel `1.5s`) und `fps` größer als 0 und höchstens 24. Größe des Request-Bodys, Kontext, zulässige Eingabe und Antwortlimit werden anhand von Modell und Format geprüft.
- Clientseitige `functionDeclarations` führt Ihre Anwendung aus. Textmodelle akzeptieren außerdem `{"googleSearch": {}}` und `{"urlContext": {}}`: einzeln oder gemeinsam im Array `tools`. Weder Google Search noch URL context darf gemeinsam mit `functionDeclarations` in einem Request verwendet werden. Für die Bildausgabe sind nur clientseitige Funktionen verfügbar. Andere integrierte Werkzeuge und explicit cache werden nicht unterstützt. Search/URL context kann eine Reservierung für das volle Eingabelimit erfordern; die tatsächlichen `toolUsePromptTokenCount` werden als Eingabetokens berücksichtigt.
- Unterstützt das Modell ein Feld, einen Anhang oder eine Werkzeugkombination nicht, wird der Request 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 bei 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 Eingabearten 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 einer Zeitüberschreitung zuerst 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 tatsächlich vorhandene lokale PDF-, Audio- oder Videodatei und ihren 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-at/connect/google-genai/#function-loop)Vollständiger Funktionszyklus

Übergeben Sie die Deklaration, empfangen Sie functionCall, führen Sie Ihre Funktion aus, geben Sie functionResponse zurück und fordern Sie die nächste Antwort an. Bewahren Sie den gesamten content des Modells einschließlich thoughtSignature; 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 einer Zeitüberschreitung zuerst 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)  # Lassen Sie ALLE (ALL) ursprünglichen parts und thoughtSignature unverändert.
    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-at/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"}]}]}' 
```

Eine kostenpflichtige Gemini-Antwort liefert Ailoot nach der Kostenberechnung: Der Text des Streams kommt vollständig, sobald das Modell fertig ist, nicht Wort für Wort. Der Gemini-Stream enthält keine Statuszeilen; planen Sie daher bei langen Antworten ausreichend Spielraum beim Client-Timeout ein.

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

Noch Fragen? Senden 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.