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

# Generar Contenido

> Genera contenido utilizando el formato de la API de Google Gemini

TokenLab es compatible con el formato nativo de la API de Google Gemini para los modelos Gemini. Esto permite una compatibilidad directa con los SDK de Google AI.

## Parámetros de Ruta

<ParamField path="model" type="string" required>
  Nombre del modelo (por ejemplo, `gemini-2.5-pro`, `gemini-3.5-flash`).

  Para integraciones de producción, prefiera partes multimedia basadas en URL `fileData` / `file_data` con una URL pública `https`.
  TokenLab usa la ruta nativa de Gemini cuando está disponible y cambia a una ruta pública compatible cuando el manejo nativo no está disponible para esa solicitud multimodal.
</ParamField>

## Parámetros de Consulta

<ParamField query="key" type="string">
  Clave API (alternativa a la autenticación por encabezado).
</ParamField>

## Autenticación

Los endpoints de Gemini admiten múltiples métodos de autenticación:

* Parámetro de consulta `?key=YOUR_API_KEY`
* Encabezado `x-goog-api-key: YOUR_API_KEY`
* Encabezado `Authorization: Bearer YOUR_API_KEY`

## Cuerpo de la Solicitud

<ParamField body="contents" type="array" required>
  Contenidos de la conversación.

  Cada objeto de contenido contiene:

  * `role` (string): `user` o `model`
  * `parts` (array): partes del contenido. TokenLab admite actualmente:
    * partes de texto: `{ "text": "..." }`
    * partes de medios en línea: `inlineData` / `inline_data`
    * partes de archivo basadas en URL: `fileData` / `file_data`

  Para las partes multimedia, TokenLab acepta actualmente tipos MIME de imagen, audio y video, y los reenvía a través dlos detalhes do modelo compatible con Gemini.

  Los valores de rol `user` y `model` se normalizan sin distinguir mayúsculas. `inlineData` / `inline_data` con `application/octet-stream` solo se acepta cuando TokenLab puede identificar bytes de imagen o video compatibles; de lo contrario, la solicitud falla antes del enrutamiento. Para solicitudes nativas con salida de imagen, solo se acepta la familia de herramientas Google search/maps, y las combinaciones de herramientas no compatibles fallan antes de reintentar con el proveedor.
</ParamField>

<ParamField body="systemInstruction" type="object">
  Instrucción del sistema para el modelo.
</ParamField>

<ParamField body="generationConfig" type="object">
  Configuración de generación:

  * `temperature` (number): Temperatura de muestreo
  * `topP` (number): Probabilidad de muestreo de núcleo (nucleus sampling)
  * `topK` (integer): Muestreo Top-K
  * `maxOutputTokens` (integer): Máximo de tokens de salida
  * `stopSequences` (array): Secuencias de parada
  * `candidateCount` (integer): Número de candidatos para generación sin streaming. Las solicitudes con streaming deben omitirlo o mantenerlo en `1`.
  * `responseModalities` (array): Modalidades de salida solicitadas para rutas nativas compatibles.
  * `responseMimeType` (string): Tipo MIME de salida, como `text/plain` o `application/json`.
  * `responseSchema` (object): JSON schema para salida estructurada cuando `responseMimeType` solicita JSON.
  * `thinkingConfig` / `thinking_config` (object): Opciones de presupuesto de razonamiento para modelos compatibles.
</ParamField>

<ParamField body="safetySettings" type="array">
  Configuración de filtros de seguridad.
</ParamField>

## Respuesta

<ResponseField name="candidates" type="array">
  Candidatos de contenido generado.
</ResponseField>

<ResponseField name="usageMetadata" type="object">
  Información de uso de 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>

## Ejemplos de entrada multimodal

Para solicitudes multimodales de Gemini, coloca los medios dentro de `contents[].parts[]` usando bytes inline o referencias de archivo basadas en URL.

Categorías multimedia compatibles actualmente en los detalhes do modelo de Gemini:

* imagen
* audio
* video

Para medios inline, usa `inlineData` o `inline_data` y pasa los bytes del archivo codificados en Base64.

Para medios mediante URL, usa `fileData` o `file_data` y pasa una URL pública `https`.

### Ejemplo de entrada de imagen

```json theme={null}
{
  "contents": [
    {
      "role": "user",
      "parts": [
        { "text": "Describe esta imagen." },
        {
          "inlineData": {
            "mimeType": "image/jpeg",
            "data": "/9j/4AAQSkZJRgABAQ..."
          }
        }
      ]
    }
  ]
}
```

### Ejemplo de entrada de audio

```json theme={null}
{
  "contents": [
    {
      "role": "user",
      "parts": [
        { "text": "Transcribe y resume este audio." },
        {
          "file_data": {
            "mime_type": "audio/mpeg",
            "file_uri": "https://example.com/sample.mp3"
          }
        }
      ]
    }
  ]
}
```

### Ejemplo de entrada de video

```json theme={null}
{
  "contents": [
    {
      "role": "user",
      "parts": [
        { "text": "Describe brevemente este video." },
        {
          "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>

## Ejemplo de entrada de video

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

## Ejemplo de entrada de audio

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