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

[Verbinding maken](https://ailoot.ai/docs/nl-be/) 

# Google GenAI SDK

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

Het native Gemini-formaat: Google GenAI SDK voor Python en JavaScript, en directe REST-verzoeken.

## [](https://ailoot.ai/docs/nl-be/connect/google-genai/#install)Installatie

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

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

## [](https://ailoot.ai/docs/nl-be/connect/google-genai/#client)Verbinding maken

Het adres is `https://api.ailoot.ai` zonder `/v1beta`: de SDK stelt zelf het pad `/v1beta/models/<model>:generateContent` samen. In Python stel je het adres in via `HttpOptions(base_url=…)`, in JavaScript via `httpOptions.baseUrl`. De SDK stuurt de sleutel mee in de 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"),  # zonder /v1beta
)

resp = client.models.generate_content(
    model="gemini-3.8-flash",
    contents="Bedenk drie namen voor een koffiebar.",
)
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" }, // zonder /v1beta
});

const resp = await ai.models.generateContent({
  model: "gemini-3.8-flash",
  contents: "Bedenk drie namen voor een koffiebar.",
});
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": "Bedenk drie namen voor een koffiebar."}]}
    ]
  }' 
```

## [](https://ailoot.ai/docs/nl-be/connect/google-genai/#body)Wat je kunt meegeven

- Velden op het hoogste niveau: `contents`, `systemInstruction`, `generationConfig`, `safetySettings`, `tools` en `toolConfig`.
- `generationConfig` accepteert `temperature`, `topP`, `topK`, `maxOutputTokens`, `thinkingConfig`, `responseMimeType` (`text/plain` of `application/json`), `responseSchema` of `responseJsonSchema` (JSON-object), `stopSequences` (array van strings), `candidateCount: 1`, een geheel getal voor `seed`, numerieke waarden voor `presencePenalty` en `frequencyPenalty`. Toegestane bereiken en mogelijkheden hangen af van het specifieke model; kies voor een JSON-antwoord één ondersteunde schemavorm en `application/json`. Bij tekstmodellen is `responseModalities` uitsluitend `["TEXT"]`.
- `safetySettings` — een array van objecten met `category`, `threshold` en optionele `method`; kies de waarden volgens de documentatie van het specifieke model.
- Voor Gemini-modellen die dit invoertype ondersteunen, geldt: `parts[].inlineData` bevat `mimeType` en niet-lege base64-data; een PDF moet een echt PDF-bestand zijn. `fileData` bevat een openbaar `https`-adres in `fileUri` en het MIME-type van het bestand. Voor YouTube mag je het MIME-type weglaten. `http`, niet-openbare adressen, `gs://` en Google Files API-objecten worden niet ondersteund; uploaden via Google Files API ook niet. Bij video kun je `videoMetadata`: `startOffset`/`endOffset` toevoegen als string in seconden (bijvoorbeeld `1.5s`) en `fps` moet groter dan 0 en maximaal 24 zijn. De bodygrootte, context, toegestane invoer en antwoordlimiet worden per model en formaat gecontroleerd.
- Clientfuncties in `functionDeclarations` worden uitgevoerd door je applicatie. Bij tekstmodellen worden ook `{"googleSearch": {}}` en `{"urlContext": {}}` geaccepteerd: afzonderlijk of samen in de array `tools`. Noch Google Search noch URL context kan worden gecombineerd met `functionDeclarations` in hetzelfde verzoek. Voor afbeeldingen als output zijn alleen clientfuncties beschikbaar. Andere ingebouwde tools en explicit cache worden niet ondersteund. Search/URL context kunnen een reservering vereisen op basis van de volledige invoerlimiet; de daadwerkelijke `toolUsePromptTokenCount` worden als invoertokens geteld.
- Als het model een veld, bijlage of combinatie van tools niet ondersteunt, wordt het verzoek vóór de reservering afgewezen — er wordt niets afgeschreven. Je ontvangt HTTP `400` met `status` `INVALID_ARGUMENT` en de klasse `invalid_request` (in `ErrorInfo.reason` — `INVALID_REQUEST`). Ongeldige JSON, fouten in padparameters en andere controles geven ook `400` terug; lees de foutmelding en de Request ID. De mogelijkheden hangen af van het model: controleer de formaten en invoertypen in de catalogus.

| Invoer | Ondersteunde MIME-typen |
| --- | --- |
| Inline-afbeeldingen | image/png, image/jpeg, image/webp |
| Documenten | 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"},
    )
    # Eén keer versturen. Controleer na een time-out de Request ID in je gebruiksgeschiedenis voordat je opnieuw probeert.
    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

# Geef een echt lokaal PDF-, audio- of videobestand op, met het ondersteunde MIME-type.
path, mime = pathlib.Path(sys.argv[1]), sys.argv[2]
payload = {"contents": [{"role": "user", "parts": [
    {"text": "Beschrijf kort de inhoud van het bestand."},
    {"inlineData": {"mimeType": mime,
                    "data": base64.b64encode(path.read_bytes()).decode()}},
]}]}
print(generate("gemini-3.8-flash", payload))
# Alternatieve bijlage: {"fileData": {"mimeType": mime, "fileUri": public_https_url}}
# Voor een echte YouTube-URL: {"fileData": {"fileUri": youtube_url}}
```

## [](https://ailoot.ai/docs/nl-be/connect/google-genai/#function-loop)De volledige functiecyclus

Geef de declaratie door, ontvang functionCall, voer je eigen functie uit, geef functionResponse terug en vraag het volgende antwoord op. Bewaar de volledige content van het model, inclusief thoughtSignature; maak de handtekening niet zelf aan.

```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"},
    )
    # Eén keer versturen. Controleer na een time-out de Request ID in je gebruiksgeschiedenis voordat je opnieuw probeert.
    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": "Twee getallen vermenigvuldigen",
    "parameters": {"type": "object", "properties": {
        "a": {"type": "number"}, "b": {"type": "number"}},
        "required": ["a", "b"]},
}]}]
contents = [{"role": "user", "parts": [{"text": "Vermenigvuldig 7 met 8 met behulp van de functie"}]}]
for turn in range(4):  # Beperk de toollus; verstuur een verzoek met een onduidelijk resultaat niet opnieuw.
    reply = generate("gemini-3.8-flash", {"contents": contents, "tools": tools})
    content = reply["candidates"][0]["content"]
    contents.append(content)  # Bewaar ALLE (ALL) oorspronkelijke onderdelen (parts) en thoughtSignature ongewijzigd.
    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/nl-be/connect/google-genai/#stream)Gestreamd antwoord

```python
for chunk in client.models.generate_content_stream(
    model="gemini-3.8-flash",
    contents="Beschrijf een zonsondergang boven zee",
):
    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": "Beschrijf een zonsondergang boven zee"}]}]}' 
```

Ailoot levert het betaalde Gemini-antwoord na de kostenberekening: de streamtekst komt volledig binnen wanneer het model klaar is, niet woord voor woord. De Gemini-stream bevat geen statusregels, dus houd bij antwoorden die lang op zich laten wachten voldoende marge in de clienttimeout.

## [](https://ailoot.ai/docs/nl-be/connect/google-genai/#models)Beschikbare modellen

Het Gemini-formaat bevat 27 beschikbare identificatoren: `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-modellen zijn ook beschikbaar in het Anthropic Messages-formaat — handig voor clients die alleen dat ondersteunen: [Anthropic SDK](https://ailoot.ai/docs/nl-be/connect/anthropic-sdk/).

Nog vragen? Stuur de Request ID en een beschrijving — we helpen je verder.[Contact opnemen met support](mailto:support@ailoot.ai)

## Ailoot · Het bedrijf en zijn projectenportefeuille





Ailoot bouwt op opgebouwde operationele ervaring, een groot klantenbestand, een stabiele dienst en doorlopende KPI-controle.





Het bedrijf en zijn projectenportefeuille: miljoenen klanten; maandelijkse verkopen in de miljarden.





Ailoot gebruikt die operationele ervaring voor API-toegang tot AI-functies in klantproducten, agents, applicaties en automatiseringen.
