> ## 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

A plataforma oferece suporte ao acesso aos modelos Gemini usando o protocolo OpenAI chat/completions e o protocolo nativo do Gemini.

Todos os exemplos abaixo usam o modo não Stream. Se precisar do modo Stream, basta alterar o Path para /gemini/v1/models/{model}:**streamGenerateContent**.

## Início rápido

<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>

## Controle de raciocínio no protocolo OpenAI

A plataforma converterá o parâmetro reasoning\_effort das solicitações OpenAI chat/completions para parâmetros thinking do Gemini.

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

⚠️ Os valores não padrão da OpenAI disable/none podem ser usados para desativar o processo de raciocínio

### Configurações padrão de cada modelo

| Modelo         | Configuração padrão (quando reasoning\_effort não é definido)   |
| -------------- | --------------------------------------------------------------- |
| 2.5 Pro        | Raciocínio dinâmico: o modelo decide quando e quanto raciocinar |
| 2.5 Flash      | Raciocínio dinâmico: o modelo decide quando e quanto raciocinar |
| 2.5 Flash Lite | Raciocínio desativado                                           |

⚠️ Não é possível desativar o raciocínio para o Gemini 2.5 Pro; reasoning\_effort: none será convertido para o thinkingBudget mínimo de 128
⚠️ thinkingBudget é compatível apenas com Gemini 2.5 Flash, 2.5 Pro e 2.5 Flash-Lite. Dependendo do prompt, o modelo pode exceder ou ficar abaixo do orçamento de tokens.

## Uso de ferramentas do lado do servidor

### Google Search

Com o Google Search, é possível associar modelos Gemini a conteúdo da web em tempo real, com suporte a todos os idiomas disponíveis. Assim, o Gemini pode fornecer respostas mais precisas e citar fontes verificáveis posteriores à data de corte de conhecimento.

<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 as notícias em destaque na China hoje"
      }
    ],
    "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 as notícias em destaque na China hoje"}]
      }
    ],
    "tools": [
      {
        "googleSearch": {}
      }
    ]
  }
  EOF
  ```
</CodeGroup>

Um exemplo de resultado é mostrado abaixo. No protocolo OpenAI, as informações de Grounding podem ser obtidas pelo campo não padrão 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

O Gemini oferece uma ferramenta de execução de código que permite ao modelo gerar e executar código Python. Em seguida, o modelo pode iterar com base nos resultados da execução do código até obter a saída final.

<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>

Um exemplo de resultado é mostrado abaixo. Para o protocolo OpenAI, o código e o resultado da execução do código aparecerão em content. Para o protocolo Gemini, o código fica no campo executableCode, o resultado da execução fica no campo codeExecutionResult, e o resumo fica no campo 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

Com a ferramenta URL context, você pode fornecer mais contexto ao modelo na forma de URLs.
Ao adicionar URLs à solicitação, o modelo acessará o conteúdo dessas páginas da web, usando-o para fundamentar a resposta e melhorar sua qualidade.

<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": "Para que tipo de pessoa esta receita é adequada? 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": "Para que tipo de pessoa esta receita é adequada? https://www.foodnetwork.com/recipes/ina-garten/perfect-roast-chicken-recipe-1940592"}]
      }
    ],
    "tools": [
      {
        "urlContext": {}
      }
    ]
  }
  EOF
  ```
</CodeGroup>

Exemplo de resposta:

<CodeGroup>
  ```json OpenAI theme={null}
  {
    "id": "82f10046aebe6697ed9d33a9fa398de4",
    "object": "chat.completion",
    "choices": [
      {
        "index": 0,
        "message": {
          "role": "assistant",
          "content": "Esta receita é sobre como preparar o frango assado perfeito da Ina Garten.\n\n**Informações principais:**\n* **Origem da receita:** Ina Garten, adaptada de 《Barefoot Contessa Cookbook》.\n* **Tempo de preparo:** 20 minutos\n* **Tempo de assar:** 1 hora e 30 minutos\n* **Tempo total:** 2 horas e 10 minutos\n* **Rendimento:** 8 porções\n* **Dificuldade:** Média\n\n**Ingredientes:**\n* Um frango para assar de 5 a 6 libras\n* Sal kosher\n* Pimenta-do-reino moída na hora\n* Um maço grande de tomilho fresco, mais 20 raminhos\n* Um limão, cortado ao meio\n* Uma cabeça de alho, cortada ao meio transversalmente\n* 2 colheres de sopa (1/4 de tablete) de manteiga derretida\n* 1 cebola amarela grande, cortada em fatias grossas\n* 4 cenouras, cortadas em pedaços de 2 polegadas\n* 1 bulbo de erva-doce, com a parte superior removida, cortado em gomos\n* Azeite de oliva\n\n**Modo de preparo:**\n1. Preaqueça o forno a 425 graus Fahrenheit (cerca de 220 graus Celsius).\n2. Limpe as vísceras do frango, lave o frango por dentro e por fora. Remova o excesso de gordura e as penas restantes, e seque a parte externa do frango com papel-toalha.\n3. Tempere generosamente o interior do frango com sal e pimenta. Coloque um maço de tomilho, meio limão e todo o alho na cavidade do frango.\n4. Pincele a parte externa do frango com manteiga derretida e tempere novamente com sal e pimenta.\n5. Amarre as pernas do frango com barbante culinário e dobre as pontas das asas para baixo do corpo do frango.\n6. Coloque a cebola, as cenouras e a erva-doce em uma assadeira. Misture com sal, pimenta, 20 raminhos de tomilho e azeite de oliva. Espalhe os legumes no fundo da assadeira e coloque o frango por cima.\n7. Asse o frango por 1,5 hora, ou até que, ao cortar entre a perna e a coxa com uma faca, os sucos saiam claros.\n8. Transfira o frango assado e os legumes para uma travessa, cubra com papel-alumínio e deixe descansar por cerca de 20 minutos.\n9. Corte o frango em fatias e sirva com os legumes.\n\n**Dicas culinárias e feedback de usuários:**\n* A receita menciona que, se os legumes começarem a dourar no fundo, é possível adicionar uma xícara de caldo de galinha para ajudar a manter a umidade.\n* Alguns usuários sugeriram usar uma assadeira menor para evitar que os legumes queimem.\n* Alguns usuários substituíram a erva-doce por batatas.\n* Muitos usuários relataram que o frango fica muito macio e suculento, cheio de sabor, e que o processo de preparo é simples."
        },
        "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": "\nEsta receita é adequada para pessoas que gostam de frango assado clássico, especialmente cozinheiros domésticos que desejam preparar um prato delicioso e relativamente fácil. A dificuldade da receita é classificada como “média”, e ela leva no total 2 horas e 10 minutos (incluindo 20 minutos de preparo, 20 minutos de tempo ocioso e 1 hora e 30 minutos de cozimento).\n\nAlém disso, ela também é adequada para quem deseja preparar um prato principal impressionante para reuniões ou ocasiões especiais, pois frango assado costuma ser o destaque em mesas festivas.\n\nA receita também menciona que é possível ajustar os ingredientes de acordo com o gosto pessoal; por exemplo, há comentários mencionando que é possível omitir a erva-doce ou adicionar caldo de galinha para ajudar no Basting, o que indica que ela também pode ser adequada para quem gosta de experimentar e fazer ajustes ao cozinhar."
            }
          ]
        },
        "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": "A dificuldade da receita é classificada como “média”, e ela leva no total 2 horas e 10 minutos (incluindo 20 minutos de preparo, 20 minutos de tempo ocioso e 1 hora e 30 minutos de cozimento)."
              },
              "groundingChunkIndices": [
                0
              ]
            },
            {
              "segment": {
                "startIndex": 319,
                "endIndex": 475,
                "text": "Além disso, ela também é adequada para quem deseja preparar um prato principal impressionante para reuniões ou ocasiões especiais, pois frango assado costuma ser o destaque em mesas festivas."
              },
              "groundingChunkIndices": [
                0
              ]
            },
            {
              "segment": {
                "startIndex": 477,
                "endIndex": 695,
                "text": "A receita também menciona que é possível ajustar os ingredientes de acordo com o gosto pessoal; por exemplo, há comentários mencionando que é possível omitir a erva-doce ou adicionar caldo de galinha para ajudar no Basting, o que indica que ela também pode ser adequada para quem gosta de experimentar e fazer ajustes ao cozinhar."
              },
              "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>