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

# Gemini

La plateforme prend en charge l’accès aux modèles Gemini via le protocole OpenAI chat/completions et le protocole natif Gemini.

Les exemples ci-dessous utilisent tous le mode non Stream. Si vous avez besoin du mode Stream, remplacez simplement le Path par /gemini/v1/models/{model}:**streamGenerateContent**.

## Démarrage rapide

<CodeGroup>
  ```bash OpenAI theme={null}
  curl https://api.highwayapi.ai/openai/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <YOUR-API-KEY>" \
  -d '{
      "model": "gemini-2.5-flash",
      "messages": [{
          "role": "user", "content": "What is the capital of France?"
      }],
      "reasoning_effort": "low"
    }'
  ```

  ```bash Gemini theme={null}
  curl https://api.highwayapi.ai/gemini/v1/models/gemini-2.5-flash:generateContent \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <YOUR-API-KEY>" \
  -d '{
      "contents": [{
          "role": "user",
          "parts": [{"text": "What is the capital of France?"}]
      }],
      "generationConfig": {
          "thinkingConfig": {
              "thinkingBudget": 1024
          }
      }
    }'
  ```
</CodeGroup>

## Contrôle du raisonnement avec le protocole OpenAI

La plateforme convertit le paramètre reasoning\_effort des requêtes OpenAI chat/completions en paramètres thinking de Gemini.

| reasoning\_effort | thinking               |
| ----------------- | ---------------------- |
| "disable", "none" | "budget\_tokens": 0    |
| "low"             | "budget\_tokens": 1024 |
| "medium"          | "budget\_tokens": 2048 |
| "high"            | "budget\_tokens": 4096 |

⚠️ Les valeurs non standard OpenAI disable/none peuvent être utilisées pour désactiver le processus de raisonnement

### Paramètres par défaut selon le modèle

| Modèle         | Paramètre par défaut (si reasoning\_effort n’est pas défini)                    |
| -------------- | ------------------------------------------------------------------------------- |
| 2.5 Pro        | Raisonnement dynamique : le modèle décide quand raisonner et dans quelle mesure |
| 2.5 Flash      | Raisonnement dynamique : le modèle décide quand raisonner et dans quelle mesure |
| 2.5 Flash Lite | Raisonnement désactivé                                                          |

⚠️ Il n’est pas possible de désactiver le raisonnement pour Gemini 2.5 Pro ; reasoning\_effort: none sera converti en thinkingBudget minimal de 128
⚠️ thinkingBudget est uniquement pris en charge dans Gemini 2.5 Flash, 2.5 Pro et 2.5 Flash-Lite. Selon le prompt, le modèle peut dépasser ou rester en dessous du budget de tokens.

## Utilisation des outils côté serveur

### Google Search

Grâce à Google Search, vous pouvez relier les modèles Gemini à du contenu Web en temps réel, avec prise en charge de toutes les langues disponibles. Gemini peut ainsi fournir des réponses plus précises et citer des sources vérifiables postérieures à la date limite de ses connaissances.

<CodeGroup>
  ```bash OpenAI theme={null}
  curl https://api.highwayapi.ai/openai/chat/completions \
  -H "Authorization: Bearer <YOUR-API-KEY>" \
  -H "Content-Type: application/json" -d @- <<EOF
  {
    "model": "gemini-2.5-flash-lite",
    "messages": [
      {
        "role": "user",
        "content": "Liste les actualités les plus populaires en Chine aujourd’hui"
      }
    ],
    "tools": [
      {
        "function": {"name": "google_search"}
      }
    ]
  }
  EOF
  ```

  ```bash Gemini theme={null}
  curl https://api.highwayapi.ai/gemini/v1/models/gemini-2.5-flash-lite:generateContent \
  -H "Authorization: Bearer <YOUR-API-KEY>" \
  -H "Content-Type: application/json" -d @- <<EOF
  {
    "contents": [
      {
        "role": "user",
        "parts": [{"text": "Liste les actualités les plus populaires en Chine aujourd’hui"}]
      }
    ],
    "tools": [
      {
        "googleSearch": {}
      }
    ]
  }
  EOF
  ```
</CodeGroup>

Un exemple de résultat est présenté ci-dessous. Avec le protocole OpenAI, les informations de Grounding sont disponibles dans le champ non standard gemini\_grounding\_metadata.

<CodeGroup>
  ```json OpenAI theme={null}
  {
    "id": "dcc7eab10b5adeb9e8648d134e815409",
    "object": "chat.completion",
    "choices": [
      {
        "index": 0,
        "message": {
          "role": "assistant",
          "content": "Here are some of today's top news in China: ..."
        },
        "finish_reason": "stop"
      }
    ],
    "gemini_grounding_metadata": {  # 👈 GEMINI GROUNDING
      "webSearchQueries": [
        "中国今日热点新闻"
      ],
      ...
      "groundingChunks": [
        ...
      ]
    }
  }
  ```

  ```json Gemini theme={null}
  {
    "candidates": [
      {
        "content": {
          "role": "model",
          "parts": [
            {
              "text": "根据您提供的搜索结果，以下是今日中国的一些热点新闻：..."
            }
          ]
        },
        "finishReason": "STOP",
        "index": 0,
        "groundingMetadata": {
          "webSearchQueries": [
            "今日中国热点新闻",
            "中国最新新闻头条"
          ],
          "searchEntryPoint": {...},
          "groundingChunks": [...],
          "groundingSupports": [...]
        }
      }
    ]
  }
  ```
</CodeGroup>

### Code Execution

Gemini fournit un outil d’exécution de code qui permet au modèle de générer et d’exécuter du code Python. Le modèle peut ensuite apprendre de manière itérative à partir des résultats d’exécution du code jusqu’à obtenir la sortie finale.

<CodeGroup>
  ```bash OpenAI theme={null}
  curl https://api.highwayapi.ai/openai/chat/completions \
  -H "Authorization: Bearer <YOUR-API-KEY>" \
  -H "Content-Type: application/json" -d @- <<EOF
  {
    "model": "gemini-2.5-flash",
    "messages": [
      {
        "role": "user",
        "content": "What is the sum of the first 50 prime numbers? Generate and run code for the calculation, and make sure you get all 50."
      }
    ],
    "tools": [
        {
             "function":  {"name": "code_execution"}
        }
    ],
    "reasoning_effort": "low"
  }
  EOF
  ```

  ```bash Gemini theme={null}
  curl https://api.highwayapi.ai/gemini/v1/models/gemini-2.5-flash:generateContent \
  -H "Authorization: Bearer <YOUR-API-KEY>" \
  -H "Content-Type: application/json" -d @- <<EOF
  {
    "contents": [
      {
        "role": "user",
        "parts": [{"text": "What is the sum of the first 50 prime numbers? Generate and run code for the calculation, and make sure you get all 50."}]
      }
    ],
    "tools": [
      {
        "codeExecution": {}
      }
    ],
    "generationConfig": {
      "thinkingConfig": {
        "thinkingBudget": 1024
      }
    }
  }
  EOF
  ```
</CodeGroup>

Un exemple de résultat est présenté ci-dessous. Pour le protocole OpenAI, le code et les résultats d’exécution du code apparaîtront dans content. Pour le protocole Gemini, le code se trouve dans le champ executableCode, le résultat d’exécution dans le champ codeExecutionResult, et le résumé dans le champ text.

<CodeGroup>
  ````markdown OpenAI theme={null}
  Okay, I can help you with that. I will write a Python script to find the
  first 50 prime numbers and then calculate their sum.

  Here's the plan:

  1.  Create a function to check if a number is prime.
  2.  Create a function to generate the first `n` prime numbers.
  3.  Call the generation function for the first 50 primes.
  4.  Sum the resulting list of primes.

  Here is the code to perform this calculation:

  ```PYTHON
  def is_prime(num):
      """Checks if a number is prime."""
      if num <= 1:
          return False
      if num <= 3:
          return True
      if num % 2 == 0 or num % 3 == 0:
          return False
      i = 5
      while i * i <= num:
          if num % i == 0 or num % (i + 2) == 0:
              return False
          i += 6
      return True

  def get_first_n_primes(n):
      """Generates a list of the first n prime numbers."""
      primes = []
      num = 2
      while len(primes) < n:
          if is_prime(num):
              primes.append(num)
          num += 1
      return primes

  # Get the first 50 prime numbers
  first_50_primes = get_first_n_primes(50)


  # Calculate the sum of these prime numbers

  sum_of_primes = sum(first_50_primes)


  print(f"The first 50 prime numbers are: {first_50_primes}")

  print(f"The sum of the first 50 prime numbers is: {sum_of_primes}")
  ```

  The first 50 prime numbers are: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31,
  37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107,
  109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191,
  193, 197, 199, 211, 223, 227, 229]

  The sum of the first 50 prime numbers is: 5117
  ````

  ```markdown Gemini theme={null}
  - executableCode:
      language: PYTHON
      code: |
        import sympy

        def is_prime(n):
            if n <= 1:
                return False
            if n <= 3:
                return True
            if n % 2 == 0 or n % 3 == 0:
                return False
            i = 5
            while i * i <= n:
                if n % i == 0 or n % (i + 2) == 0:
                    return False
                i += 6
            return True

        prime_numbers = []
        num = 2
        while len(prime_numbers) < 50:
            if is_prime(num):
                prime_numbers.append(num)
            num += 1

        sum_of_primes = sum(prime_numbers)

        print(f"The first 50 prime numbers are: {prime_numbers}")
        print(f"The sum of the first 50 prime numbers is: {sum_of_primes}")
  - codeExecutionResult:
      outcome: OUTCOME_OK
      output: >
        The first 50 prime numbers are: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
        31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103,
        107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179,
        181, 191, 193, 197, 199, 211, 223, 227, 229]

        The sum of the first 50 prime numbers is: 5117
  - text: The sum of the first 50 prime numbers is 5117.
  ```
</CodeGroup>

### URL context

À l’aide de l’outil URL context, vous pouvez fournir davantage de contexte au modèle sous forme d’URL.
En ajoutant des URL à la requête, le modèle consultera le contenu de ces pages Web afin d’éclairer sa réponse et d’en améliorer la qualité.

<CodeGroup>
  ```bash OpenAI theme={null}
  curl https://api.highwayapi.ai/openai/chat/completions \
  -H "Authorization: Bearer <YOUR-API-KEY>" \
  -H "Content-Type: application/json" -d @- <<EOF
  {
    "model": "gemini-2.5-flash-lite",
    "messages": [
      {
        "role": "user",
        "content": "À quel public cette recette convient-elle ? https://www.foodnetwork.com/recipes/ina-garten/perfect-roast-chicken-recipe-1940592"
      }
    ],
    "tools": [
      {
        "function": {"name": "url_context"}
      }
    ]
  }
  EOF
  ```

  ```bash Gemini theme={null}
  curl https://api.highwayapi.ai/gemini/v1/models/gemini-2.5-flash-lite:generateContent \
  -H "Authorization: Bearer <YOUR-API-KEY>" \
  -H "Content-Type: application/json" -d @- <<EOF
  {
    "contents": [
      {
        "role": "user",
        "parts": [{"text": "À quel public cette recette convient-elle ? https://www.foodnetwork.com/recipes/ina-garten/perfect-roast-chicken-recipe-1940592"}]
      }
    ],
    "tools": [
      {
        "urlContext": {}
      }
    ]
  }
  EOF
  ```
</CodeGroup>

Exemple de réponse :

<CodeGroup>
  ```json OpenAI theme={null}
  {
    "id": "82f10046aebe6697ed9d33a9fa398de4",
    "object": "chat.completion",
    "choices": [
      {
        "index": 0,
        "message": {
          "role": "assistant",
          "content": "Cette recette explique comment préparer le poulet rôti parfait d’Ina Garten.\n\n**Informations clés :**\n* **Source de la recette :** Ina Garten, adaptée du « Barefoot Contessa Cookbook ».\n* **Temps de préparation :** 20 minutes\n* **Temps de cuisson :** 1 heure 30 minutes\n* **Temps total :** 2 heures 10 minutes\n* **Portions :** 8 personnes\n* **Difficulté :** moyenne\n\n**Ingrédients :**\n* Un poulet à rôtir de 5 à 6 livres\n* Sel casher\n* Poivre noir fraîchement moulu\n* Une grosse botte de thym frais, plus 20 brins\n* Un citron, coupé en deux\n* Une tête d’ail, coupée en deux dans le sens de la largeur\n* 2 cuillères à soupe (1/4 de bâton) de beurre fondu\n* 1 gros oignon jaune, coupé en tranches épaisses\n* 4 carottes, coupées en morceaux de 2 pouces\n* 1 bulbe de fenouil, fanes retirées, coupé en quartiers\n* Huile d’olive\n\n**Étapes de préparation :**\n1. Préchauffer le four à 425 °F (environ 220 °C).\n2. Retirer les abats du poulet, puis rincer l’intérieur et l’extérieur du poulet. Retirer l’excès de gras et les éventuelles plumes restantes, puis sécher l’extérieur du poulet en le tamponnant.\n3. Saler et poivrer généreusement l’intérieur du poulet. Placer une botte de thym, un demi-citron et tout l’ail dans la cavité du poulet.\n4. Badigeonner l’extérieur du poulet de beurre fondu, puis saler et poivrer à nouveau.\n5. Ficeler les cuisses avec de la ficelle de cuisine et replier les extrémités des ailes sous le poulet.\n6. Placer l’oignon, les carottes et le fenouil dans un plat à rôtir. Mélanger avec du sel, du poivre, 20 brins de thym et de l’huile d’olive. Étaler les légumes au fond du plat, puis déposer le poulet dessus.\n7. Faire rôtir le poulet pendant 1,5 heure, ou jusqu’à ce que le jus soit clair lorsqu’on coupe entre la cuisse et le thigh avec un couteau.\n8. Transférer le poulet rôti et les légumes dans un plat, couvrir de papier aluminium et laisser reposer environ 20 minutes.\n9. Découper le poulet et le servir avec les légumes.\n\n**Conseils de cuisson et retours des utilisateurs :**\n* La recette indique que si le dessous des légumes commence à brunir, il est possible d’ajouter une tasse de bouillon de poulet pour aider à conserver l’humidité.\n* Certains utilisateurs suggèrent d’utiliser un plat à rôtir plus petit afin d’éviter que les légumes ne brûlent.\n* Certains utilisateurs remplacent le fenouil par des pommes de terre.\n* De nombreux utilisateurs indiquent que le poulet est très tendre, juteux, savoureux, et que la préparation est simple."
        },
        "finish_reason": "stop"
      }
    ],
    "gemini_grounding_metadata": {
      "groundingChunks": [
        {
          "web": {
            "uri": "https://www.foodnetwork.com/recipes/ina-garten/perfect-roast-chicken-recipe-1940592",
            "title": "Perfect Roast Chicken Recipe | Ina Garten | Food Network"
          }
        }
      ],
      "groundingSupports": [....]
    }
  }
  ```

  ```json Gemini theme={null}
  {
    "candidates": [
      {
        "content": {
          "role": "model",
          "parts": [
            {
              "text": "\nCette recette convient aux personnes qui aiment le poulet rôti classique, en particulier aux cuisiniers amateurs qui souhaitent préparer un plat délicieux et relativement facile. La difficulté de la recette est indiquée comme « moyenne », et elle nécessite au total 2 heures 10 minutes (dont 20 minutes de préparation, 20 minutes de temps de repos et 1 heure 30 minutes de cuisson).\n\nElle convient également aux personnes qui souhaitent préparer un plat principal impressionnant pour une réception ou une occasion spéciale, car le poulet rôti est souvent une pièce maîtresse des repas de fête.\n\nLa recette mentionne aussi que les ingrédients peuvent être ajustés selon les goûts personnels ; par exemple, certains commentaires indiquent que l’on peut omettre le fenouil ou ajouter du bouillon de poulet pour faciliter le Basting, ce qui montre qu’elle peut aussi convenir à ceux qui aiment expérimenter et adapter leurs préparations en cuisine."
            }
          ]
        },
        "finishReason": "STOP",
        "index": 0,
        "safetyRatings": null,
        "groundingMetadata": {
          "groundingChunks": [
            {
              "web": {
                "uri": "https://www.foodnetwork.com/recipes/ina-garten/perfect-roast-chicken-recipe-1940592",
                "title": "Perfect Roast Chicken Recipe | Ina Garten | Food Network"
              }
            }
          ],
          "groundingSupports": [
            {
              "segment": {
                "startIndex": 148,
                "endIndex": 317,
                "text": "La difficulté de la recette est indiquée comme « moyenne », et elle nécessite au total 2 heures 10 minutes (dont 20 minutes de préparation, 20 minutes de temps de repos et 1 heure 30 minutes de cuisson)."
              },
              "groundingChunkIndices": [
                0
              ]
            },
            {
              "segment": {
                "startIndex": 319,
                "endIndex": 475,
                "text": "Elle convient également aux personnes qui souhaitent préparer un plat principal impressionnant pour une réception ou une occasion spéciale, car le poulet rôti est souvent une pièce maîtresse des repas de fête."
              },
              "groundingChunkIndices": [
                0
              ]
            },
            {
              "segment": {
                "startIndex": 477,
                "endIndex": 695,
                "text": "La recette mentionne aussi que les ingrédients peuvent être ajustés selon les goûts personnels ; par exemple, certains commentaires indiquent que l’on peut omettre le fenouil ou ajouter du bouillon de poulet pour faciliter le Basting, ce qui montre qu’elle peut aussi convenir à ceux qui aiment expérimenter et adapter leurs préparations en cuisine."
              },
              "groundingChunkIndices": [
                0
              ]
            }
          ]
        }
      }
    ],
    "promptFeedback": {
      "safetyRatings": null
    },
    "usageMetadata": {
      "promptTokenCount": 37,
      "candidatesTokenCount": 159,
      "totalTokenCount": 3270,
      "trafficType": "ON_DEMAND",
      "promptTokensDetails": [
        {
          "modality": "TEXT",
          "tokenCount": 37
        }
      ],
      "candidatesTokensDetails": [
        {
          "modality": "TEXT",
          "tokenCount": 159
        }
      ],
      "toolUsePromptTokensDetails": [
        {
          "modality": "TEXT",
          "tokenCount": 3074
        }
      ],
      "toolUsePromptTokenCount": 3074
    },
    "responseId": "0472efecb0da2db5f78d047e70e54db6",
    "modelVersion": "gemini-2.5-flash-lite"
  }
  ```
</CodeGroup>