> ## 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 plataforma permite acceder a los modelos Gemini mediante el protocolo OpenAI chat/completions y el protocolo nativo de Gemini.

Todos los ejemplos siguientes usan el modo no Stream. Si necesita el modo Stream, simplemente cambie el Path a /gemini/v1/models/{model}:**streamGenerateContent**.

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

## Control del razonamiento con el protocolo OpenAI

La plataforma convertirá el parámetro reasoning\_effort de las solicitudes OpenAI chat/completions en parámetros thinking de Gemini.

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

⚠️ Los valores no estándar de OpenAI disable/none pueden usarse para desactivar el proceso de razonamiento.

### Configuración predeterminada de cada modelo

| Modelo         | Configuración predeterminada (cuando no se establece reasoning\_effort) |
| -------------- | ----------------------------------------------------------------------- |
| 2.5 Pro        | Razonamiento dinámico: el modelo decide cuándo razonar y cuánto         |
| 2.5 Flash      | Razonamiento dinámico: el modelo decide cuándo razonar y cuánto         |
| 2.5 Flash Lite | Razonamiento desactivado                                                |

⚠️ No es posible desactivar el razonamiento para Gemini 2.5 Pro; reasoning\_effort: none se convertirá al thinkingBudget mínimo de 128.
⚠️ thinkingBudget solo es compatible con Gemini 2.5 Flash, 2.5 Pro y 2.5 Flash-Lite. Según el prompt, el modelo puede superar o quedar por debajo del presupuesto de tokens.

## Uso de herramientas del lado del servidor

### Google Search

Con Google Search, los modelos Gemini pueden conectarse con contenido web en tiempo real y admiten todos los idiomas disponibles. De este modo, Gemini puede ofrecer respuestas más precisas y citar fuentes verificables posteriores a la fecha de corte de conocimiento.

<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": "Enumera las noticias destacadas de hoy en China"
      }
    ],
    "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": "Enumera las noticias destacadas de hoy en China"}]
      }
    ],
    "tools": [
      {
        "googleSearch": {}
      }
    ]
  }
  EOF
  ```
</CodeGroup>

A continuación se muestra un ejemplo de resultado. Con el protocolo OpenAI, la información de Grounding puede obtenerse desde el campo no estándar 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": [
        "noticias destacadas de hoy en China"
      ],
      ...
      "groundingChunks": [
        ...
      ]
    }
  }
  ```

  ```json Gemini theme={null}
  {
    "candidates": [
      {
        "content": {
          "role": "model",
          "parts": [
            {
              "text": "Según los resultados de búsqueda proporcionados, estas son algunas de las noticias destacadas de hoy en China:..."
            }
          ]
        },
        "finishReason": "STOP",
        "index": 0,
        "groundingMetadata": {
          "webSearchQueries": [
            "noticias destacadas de hoy en China",
            "últimos titulares de noticias de China"
          ],
          "searchEntryPoint": {...},
          "groundingChunks": [...],
          "groundingSupports": [...]
        }
      }
    ]
  }
  ```
</CodeGroup>

### Code Execution

Gemini proporciona una herramienta de ejecución de código que permite al modelo generar y ejecutar código Python. Luego, el modelo puede iterar basándose en los resultados de la ejecución del código hasta obtener la salida 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>

A continuación se muestra un ejemplo de resultado. Para el protocolo OpenAI, el código y los resultados de la ejecución del código aparecerán en content. Para el protocolo Gemini, el código está en el campo executableCode, el resultado de la ejecución está en el campo codeExecutionResult y el resumen está en el 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

Con la herramienta URL context, puede proporcionar más contexto al modelo en forma de URLs.
Al agregar URLs a la solicitud, el modelo accederá al contenido de esas páginas web, lo que aportará información a la respuesta y mejorará su calidad.

<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 qué tipo de personas es adecuada esta receta? 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 qué tipo de personas es adecuada esta receta? https://www.foodnetwork.com/recipes/ina-garten/perfect-roast-chicken-recipe-1940592"}]
      }
    ],
    "tools": [
      {
        "urlContext": {}
      }
    ]
  }
  EOF
  ```
</CodeGroup>

Respuesta de ejemplo:

<CodeGroup>
  ```json OpenAI theme={null}
  {
    "id": "82f10046aebe6697ed9d33a9fa398de4",
    "object": "chat.completion",
    "choices": [
      {
        "index": 0,
        "message": {
          "role": "assistant",
          "content": "Esta receta trata sobre cómo preparar el pollo asado perfecto de Ina Garten.\n\n**Información clave:**\n* **Fuente de la receta:** Ina Garten, adaptada de «Barefoot Contessa Cookbook».\n* **Tiempo de preparación:** 20 minutos\n* **Tiempo de horneado:** 1 hora 30 minutos\n* **Tiempo total:** 2 horas 10 minutos\n* **Raciones:** 8 personas\n* **Dificultad:** Media\n\n**Ingredientes:**\n* Un pollo para asar de 5-6 libras\n* Sal kosher\n* Pimienta negra recién molida\n* Un manojo grande de tomillo fresco, más 20 ramitas\n* Un limón, cortado por la mitad\n* Una cabeza de ajo, cortada transversalmente por la mitad\n* 2 cucharadas (1/4 de barra) de mantequilla, derretida\n* 1 cebolla amarilla grande, cortada en rodajas gruesas\n* 4 zanahorias, cortadas en trozos de 2 pulgadas\n* 1 bulbo de hinojo, sin la parte superior y cortado en gajos\n* Aceite de oliva\n\n**Pasos de preparación:**\n1. Precaliente el horno a 425 grados Fahrenheit (aprox. 220 grados Celsius).\n2. Retire las vísceras del pollo y enjuague el pollo por dentro y por fuera. Quite el exceso de grasa y las plumas restantes, y seque el exterior del pollo con papel.\n3. Sazone generosamente el interior del pollo con sal y pimienta. Coloque dentro de la cavidad un manojo de tomillo, medio limón y todo el ajo.\n4. Pinte el exterior del pollo con la mantequilla derretida y vuelva a espolvorear sal y pimienta.\n5. Ate las patas del pollo con hilo de cocina y meta las puntas de las alas debajo del cuerpo.\n6. Coloque la cebolla, las zanahorias y el hinojo en una bandeja para asar. Mezcle con sal, pimienta, 20 ramitas de tomillo y aceite de oliva. Distribuya las verduras en el fondo de la bandeja y coloque el pollo encima.\n7. Hornee el pollo durante 1,5 horas, o hasta que los jugos salgan claros al cortar con un cuchillo entre la pata y el muslo.\n8. Pase el pollo asado y las verduras a una fuente, cúbralos con papel de aluminio y déjelos reposar unos 20 minutos.\n9. Corte el pollo en porciones y sírvalo con las verduras.\n\n**Consejos de cocina y comentarios de usuarios:**\n* La receta menciona que, si las verduras empiezan a dorarse demasiado en el fondo, se puede añadir una taza de caldo de pollo para ayudar a mantener la humedad.\n* Algunos usuarios sugieren usar una bandeja para asar más pequeña para evitar que las verduras se quemen.\n* Algunos usuarios han sustituido el hinojo por patatas.\n* Muchos usuarios comentan que el pollo queda muy tierno, jugoso y lleno de sabor, y que el proceso de cocción es sencillo."
        },
        "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 receta es adecuada para quienes disfrutan del pollo asado clásico, especialmente para cocineros caseros que quieren preparar un plato delicioso y relativamente fácil. La dificultad de la receta se califica como “media” y requiere un total de 2 horas y 10 minutos (incluidos 20 minutos de preparación, 20 minutos de tiempo inactivo y 1 hora y 30 minutos de cocción).\n\nAdemás, también es adecuada para quienes desean preparar un plato principal impresionante para una reunión o una ocasión especial, ya que el pollo asado suele ser un punto destacado en las mesas festivas.\n\nLa receta también menciona que los ingredientes pueden ajustarse según el gusto personal; por ejemplo, algunos comentarios indican que se puede omitir el hinojo o añadir caldo de pollo para ayudar con el Basting, lo que demuestra que también puede ser adecuada para quienes disfrutan experimentando y haciendo ajustes al cocinar."
            }
          ]
        },
        "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 dificultad de la receta se califica como “media” y requiere un total de 2 horas y 10 minutos (incluidos 20 minutos de preparación, 20 minutos de tiempo inactivo y 1 hora y 30 minutos de cocción)."
              },
              "groundingChunkIndices": [
                0
              ]
            },
            {
              "segment": {
                "startIndex": 319,
                "endIndex": 475,
                "text": "Además, también es adecuada para quienes desean preparar un plato principal impresionante para una reunión o una ocasión especial, ya que el pollo asado suele ser un punto destacado en las mesas festivas."
              },
              "groundingChunkIndices": [
                0
              ]
            },
            {
              "segment": {
                "startIndex": 477,
                "endIndex": 695,
                "text": "La receta también menciona que los ingredientes pueden ajustarse según el gusto personal; por ejemplo, algunos comentarios indican que se puede omitir el hinojo o añadir caldo de pollo para ayudar con el Basting, lo que demuestra que también puede ser adecuada para quienes disfrutan experimentando y haciendo ajustes al cocinar."
              },
              "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>