> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tokenlab.sh/llms.txt
> Use this file to discover all available pages before exploring further.

# Générer du contenu

> Génère du contenu en utilisant le format de l'API Google Gemini

TokenLab prend en charge le format natif de l'API Google Gemini pour les modèles Gemini. Cela permet une compatibilité directe avec les SDK Google AI.

## Paramètres de chemin

<ParamField path="model" type="string" required>
  Nom du modèle (par ex., `gemini-2.5-pro`, `gemini-3.5-flash`).

  Pour les intégrations en production, privilégiez les parties média `fileData` / `file_data` basées sur une URL avec une URL publique `https`.
  TokenLab utilise le chemin Gemini natif lorsqu’il est disponible et bascule vers un chemin public compatible lorsque le traitement natif n’est pas disponible pour cette requête multimodale.
</ParamField>

## Paramètres de requête

<ParamField query="key" type="string">
  Clé API (alternative à l'authentification par en-tête).
</ParamField>

## Authentification

Les points de terminaison Gemini prennent en charge plusieurs méthodes d'authentification :

* Paramètre de requête `?key=YOUR_API_KEY`
* En-tête `x-goog-api-key: YOUR_API_KEY`
* En-tête `Authorization: Bearer YOUR_API_KEY`

## Corps de la requête

<ParamField body="contents" type="array" required>
  Contenu de la conversation.

  Chaque objet de contenu contient :

  * `role` (string) : `user` ou `model`
  * `parts` (array) : parties du contenu. TokenLab prend actuellement en charge :
    * les parties texte : `{ "text": "..." }`
    * les parties média inline : `inlineData` / `inline_data`
    * les parties fichier basées sur URL : `fileData` / `file_data`

  Pour les parties média, TokenLab accepte actuellement les types MIME image, audio et vidéo, puis les transmet via le détails du modèle compatible Gemini.

  Les rôles `user` et `model` sont normalisés sans tenir compte de la casse. `inlineData` / `inline_data` avec `application/octet-stream` n’est accepté que si TokenLab peut identifier des octets image ou vidéo pris en charge ; sinon, la requête échoue avant le routage. Pour les requêtes natives avec sortie image, seule la famille d’outils Google search/maps est acceptée, et les combinaisons non prises en charge échouent avant les nouvelles tentatives upstream.
</ParamField>

<ParamField body="systemInstruction" type="object">
  Instruction système pour le modèle.
</ParamField>

<ParamField body="generationConfig" type="object">
  Configuration de génération :

  * `temperature` (number) : Température d'échantillonnage
  * `topP` (number) : Probabilité d'échantillonnage nucleus
  * `topK` (integer) : Échantillonnage Top-K
  * `maxOutputTokens` (integer) : Nombre maximum de tokens de sortie
  * `stopSequences` (array) : Séquences d'arrêt
  * `candidateCount` (integer) : Nombre de candidats pour la génération non streamée. Les requêtes en streaming doivent l'omettre ou le garder à `1`.
  * `responseModalities` (array) : Modalités de sortie demandées pour les routes natives compatibles.
  * `responseMimeType` (string) : Type MIME de sortie, par exemple `text/plain` ou `application/json`.
  * `responseSchema` (object) : JSON schema pour la sortie structurée lorsque `responseMimeType` demande du JSON.
  * `thinkingConfig` / `thinking_config` (object) : Options de budget de réflexion pour les modèles compatibles.
</ParamField>

<ParamField body="safetySettings" type="array">
  Paramètres des filtres de sécurité.
</ParamField>

## Réponse

<ResponseField name="candidates" type="array">
  Candidats de contenu générés.
</ResponseField>

<ResponseField name="usageMetadata" type="object">
  Informations sur l'utilisation des tokens.
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST "https://api.tokenlab.sh/v1beta/models/gemini-2.5-pro:generateContent?key=sk-your-api-key" \
    -H "Content-Type: application/json" \
    -d '{
      "contents": [
        {
          "parts": [{"text": "Hello, Gemini!"}]
        }
      ],
      "generationConfig": {
        "temperature": 0.7,
        "maxOutputTokens": 1024
      }
    }'
  ```

  ```python Python theme={null}
  import google.generativeai as genai

  genai.configure(
      api_key="sk-your-api-key",
      transport="rest",
      client_options={"api_endpoint": "api.tokenlab.sh"}
  )

  model = genai.GenerativeModel("gemini-2.5-pro")
  response = model.generate_content("Hello, Gemini!")

  print(response.text)
  ```

  ```javascript JavaScript theme={null}
  import { GoogleGenerativeAI } from "@google/generative-ai";

  const genAI = new GoogleGenerativeAI("sk-your-api-key", {
    baseUrl: "https://api.tokenlab.sh"
  });

  const model = genAI.getGenerativeModel({ model: "gemini-2.5-pro" });
  const result = await model.generateContent("Hello, Gemini!");

  console.log(result.response.text());
  ```

  ```go Go theme={null}
  package main

  import (
      "bytes"
      "encoding/json"
      "fmt"
      "io"
      "net/http"
  )

  func main() {
      payload := map[string]interface{}{
          "contents": []map[string]interface{}{
              {
                  "parts": []map[string]string{
                      {"text": "Hello, Gemini!"},
                  },
              },
          },
          "generationConfig": map[string]interface{}{
              "temperature":    0.7,
              "maxOutputTokens": 1024,
          },
      }

      jsonData, _ := json.Marshal(payload)
      req, _ := http.NewRequest("POST",
          "https://api.tokenlab.sh/v1beta/models/gemini-2.5-pro:generateContent?key=sk-your-api-key",
          bytes.NewBuffer(jsonData))
      req.Header.Set("Content-Type", "application/json")

      client := &http.Client{}
      resp, _ := client.Do(req)
      defer resp.Body.Close()

      body, _ := io.ReadAll(resp.Body)
      fmt.Println(string(body))
  }
  ```

  ```php PHP theme={null}
  <?php
  $payload = [
      'contents' => [
          [
              'parts' => [
                  ['text' => 'Hello, Gemini!']
              ]
          ]
      ],
      'generationConfig' => [
          'temperature' => 0.7,
          'maxOutputTokens' => 1024
      ]
  ];

  $ch = curl_init('https://api.tokenlab.sh/v1beta/models/gemini-2.5-pro:generateContent?key=sk-your-api-key');

  curl_setopt_array($ch, [
      CURLOPT_RETURNTRANSFER => true,
      CURLOPT_POST => true,
      CURLOPT_HTTPHEADER => [
          'Content-Type: application/json'
      ],
      CURLOPT_POSTFIELDS => json_encode($payload)
  ]);

  $response = curl_exec($ch);
  curl_close($ch);

  $data = json_decode($response, true);
  echo $data['candidates'][0]['content']['parts'][0]['text'];
  ```
</RequestExample>

## Exemples d'entrée multimodale

Pour les requêtes multimodales Gemini, placez les médias dans `contents[].parts[]` en utilisant soit des octets inline, soit des références de fichier basées sur une URL.

Catégories de médias actuellement prises en charge dans le détails du modèle Gemini :

* image
* audio
* vidéo

Pour les médias inline, utilisez `inlineData` ou `inline_data` et transmettez les octets du fichier encodés en Base64.

Pour les médias via URL, utilisez `fileData` ou `file_data` et transmettez une URL publique en `https`.

### Exemple d'entrée image

```json theme={null}
{
  "contents": [
    {
      "role": "user",
      "parts": [
        { "text": "Veuillez décrire cette image." },
        {
          "inlineData": {
            "mimeType": "image/jpeg",
            "data": "/9j/4AAQSkZJRgABAQ..."
          }
        }
      ]
    }
  ]
}
```

### Exemple d'entrée audio

```json theme={null}
{
  "contents": [
    {
      "role": "user",
      "parts": [
        { "text": "Veuillez transcrire et résumer cet audio." },
        {
          "file_data": {
            "mime_type": "audio/mpeg",
            "file_uri": "https://example.com/sample.mp3"
          }
        }
      ]
    }
  ]
}
```

### Exemple d'entrée vidéo

```json theme={null}
{
  "contents": [
    {
      "role": "user",
      "parts": [
        { "text": "Veuillez décrire brièvement cette vidéo." },
        {
          "fileData": {
            "mimeType": "video/mp4",
            "fileUri": "https://example.com/sample.mp4"
          }
        }
      ]
    }
  ]
}
```

<ResponseExample>
  ```json Response theme={null}
  {
    "candidates": [
      {
        "content": {
          "role": "model",
          "parts": [
            {"text": "Hello! How can I assist you today?"}
          ]
        },
        "finishReason": "STOP",
        "safetyRatings": [
          {"category": "HARM_CATEGORY_HARASSMENT", "probability": "NEGLIGIBLE"}
        ]
      }
    ],
    "usageMetadata": {
      "promptTokenCount": 5,
      "candidatesTokenCount": 10,
      "totalTokenCount": 15
    }
  }
  ```
</ResponseExample>

## Exemple d'entrée vidéo

```json theme={null}
{
  "contents": [
    {
      "role": "user",
      "parts": [
        { "text": "Please describe this video." },
        {
          "fileData": {
            "mimeType": "video/mp4",
            "fileUri": "https://example.com/demo.mp4"
          }
        }
      ]
    }
  ]
}
```

## Exemple d'entrée audio

```json theme={null}
{
  "contents": [
    {
      "role": "user",
      "parts": [
        { "text": "Please describe this audio." },
        {
          "fileData": {
            "mimeType": "audio/mpeg",
            "fileUri": "https://example.com/demo.mp3"
          }
        }
      ]
    }
  ]
}
```