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

# Modelos de razonamiento

> Usar modelos de razonamiento con pensamiento visible en la API de Venice

Algunos modelos piensan en voz alta antes de responder. Resuelven los problemas paso a paso y luego dan una respuesta final. Esto los hace más fuertes en matemáticas, código y tareas con mucha lógica.

<div id="reasoning-models-placeholder" />

Consulta la lista completa de modelos, precios y límites de contexto en la [página de Modelos](/models/overview). No todos los modelos de razonamiento admiten el parámetro [`reasoning_effort`](#reasoning-effort). Consulta [soporte por modelo](#model-support) para más detalles.

## Leer la salida

Los modelos de razonamiento devuelven su pensamiento en un campo separado `reasoning_content`, manteniendo `content` limpio:

<CodeGroup>
  ```python Python theme={"dark"}
  response = client.chat.completions.create(
      model="zai-org-glm-5-1",
      messages=[{"role": "user", "content": "What is 15% of 240?"}]
  )

  thinking = response.choices[0].message.reasoning_content
  answer = response.choices[0].message.content
  ```

  ```javascript Node.js theme={"dark"}
  const response = await client.chat.completions.create({
      model: "zai-org-glm-5-1",
      messages: [{ role: "user", content: "What is 15% of 240?" }]
  });

  const thinking = response.choices[0].message.reasoning_content;
  const answer = response.choices[0].message.content;
  ```

  ```bash cURL theme={"dark"}
  curl https://api.venice.ai/api/v1/chat/completions \
    -H "Authorization: Bearer $VENICE_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "zai-org-glm-5-1",
      "messages": [{"role": "user", "content": "What is 15% of 240?"}]
    }'
  ```
</CodeGroup>

<Info>
  Algunos proveedores (Anthropic, Google, OpenAI, Qwen) devuelven tokens de razonamiento cifrados o resumidos. Cuando esto ocurre, `reasoning_content` contiene un marcador `"[Some reasoning content is encrypted]"`.
</Info>

### Streaming

Al hacer streaming, `reasoning_content` llega en el delta antes que la respuesta final:

<CodeGroup>
  ```python Python theme={"dark"}
  stream = client.chat.completions.create(
      model="zai-org-glm-5-1",
      messages=[{"role": "user", "content": "Explain photosynthesis"}],
      stream=True
  )

  for chunk in stream:
      if chunk.choices:
          delta = chunk.choices[0].delta
          if delta.reasoning_content:
              print(delta.reasoning_content, end="")
          if delta.content:
              print(delta.content, end="")
  ```

  ```javascript Node.js theme={"dark"}
  const stream = await client.chat.completions.create({
      model: "zai-org-glm-5-1",
      messages: [{ role: "user", content: "Explain photosynthesis" }],
      stream: true
  });

  for await (const chunk of stream) {
      if (chunk.choices?.[0]?.delta) {
          const delta = chunk.choices[0].delta;
          if (delta.reasoning_content) process.stdout.write(delta.reasoning_content);
          if (delta.content) process.stdout.write(delta.content);
      }
  }
  ```

  ```bash cURL theme={"dark"}
  curl https://api.venice.ai/api/v1/chat/completions \
    -H "Authorization: Bearer $VENICE_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "zai-org-glm-5-1",
      "messages": [{"role": "user", "content": "Explain photosynthesis"}],
      "stream": true
    }'
  ```
</CodeGroup>

## Esfuerzo de razonamiento

El parámetro `reasoning_effort` controla cuánto piensa un modelo antes de responder. Mayor esfuerzo implica razonamiento más profundo pero más tokens y latencia.

### Valores aceptados

| Valor     | Descripción                                        |
| --------- | -------------------------------------------------- |
| `none`    | Desactiva el razonamiento por completo             |
| `minimal` | Razonamiento básico con esfuerzo mínimo            |
| `low`     | Razonamiento ligero para problemas simples         |
| `medium`  | Razonamiento equilibrado para complejidad moderada |
| `high`    | Razonamiento profundo para problemas complejos     |
| `xhigh`   | Profundidad de razonamiento extra-alta             |
| `max`     | Capacidad máxima de razonamiento                   |

<Warning>
  No todos los modelos admiten todos los valores. Venice **no** mapea automáticamente al nivel admitido más cercano. Los valores no admitidos devuelven un error 400 del proveedor upstream. Por ejemplo, enviar `xhigh` a Claude o `max` a GPT-5.2 fallará.

  En caso de duda, usa `low`, `medium` o `high`. Son los valores más ampliamente admitidos.
</Warning>

### Soporte por modelo

#### OpenAI

| Modelo                       | Valores admitidos                        |
| ---------------------------- | ---------------------------------------- |
| GPT-5.2                      | `none`, `low`, `medium`, `high`, `xhigh` |
| GPT-5.2 Codex, GPT-5.3 Codex | `low`, `medium`, `high`, `xhigh`         |

#### Anthropic

| Modelo                                  | Valores admitidos              |
| --------------------------------------- | ------------------------------ |
| Claude Opus 4.6, Opus 4.6 Fast          | `low`, `medium`, `high`, `max` |
| Claude Opus 4.5, Sonnet 4.5, Sonnet 4.6 | `low`, `medium`, `high`        |

#### Google

| Modelo                 | Valores admitidos                  |
| ---------------------- | ---------------------------------- |
| Gemini 3 Pro Preview   | `low`, `high`                      |
| Gemini 3.1 Pro Preview | `low`, `medium`, `high`            |
| Gemini 3 Flash Preview | `minimal`, `low`, `medium`, `high` |

#### xAI

Los modelos Grok (Grok 4.1 Fast, Grok Code Fast) **no** admiten `reasoning_effort`. Especificarlo resultará en un error.

#### Otros modelos

| Modelo                                      | Valores admitidos                            |
| ------------------------------------------- | -------------------------------------------- |
| Qwen 3 235B A22B Thinking, Qwen 3.5 35B A3B | `low`, `medium`, `high`                      |
| Kimi K2.5                                   | `low`, `medium`, `high`                      |
| MiniMax M2.5, M2.1                          | `low`, `medium`, `high`                      |
| Serie GLM 5.1                               | Solo razonamiento integrado, no configurable |
| DeepSeek R1                                 | Solo razonamiento integrado, no configurable |

### Uso

Pasa `reasoning_effort` como parámetro de nivel superior o usa el formato anidado `reasoning.effort`:

<CodeGroup>
  ```python Python theme={"dark"}
  response = client.chat.completions.create(
      model="minimax-m25",
      messages=[{"role": "user", "content": "Prove that there are infinitely many primes"}],
      extra_body={"reasoning": {"effort": "high"}}
  )
  ```

  ```javascript Node.js theme={"dark"}
  const response = await client.chat.completions.create({
      model: "minimax-m25",
      messages: [{ role: "user", content: "Prove that there are infinitely many primes" }],
      reasoning: { effort: "high" }
  });
  ```

  ```bash cURL theme={"dark"}
  curl https://api.venice.ai/api/v1/chat/completions \
    -H "Authorization: Bearer $VENICE_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "minimax-m25",
      "messages": [{"role": "user", "content": "Prove that there are infinitely many primes"}],
      "reasoning": {"effort": "high"}
    }'
  ```
</CodeGroup>

También se acepta el formato plano `"reasoning_effort": "high"`.

## Desactivar el razonamiento

Hay dos formas de desactivar el razonamiento:

| Método                     | Sintaxis                          | Cómo funciona                                                                                                       |
| -------------------------- | --------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
| `reasoning.enabled: false` | `"reasoning": {"enabled": false}` | Conmutador a nivel de Venice que impide que los parámetros de razonamiento se envíen al proveedor. **Recomendado.** |
| `reasoning.effort: "none"` | `"reasoning": {"effort": "none"}` | Se pasa al proveedor, que decide cómo gestionarlo. Solo lo admiten algunos modelos (p. ej., GPT-5.x).               |

Para los modelos que lo admiten, `reasoning.enabled: false` es la opción más fiable:

| Modelo                                       | ¿Se puede desactivar?                         |
| -------------------------------------------- | --------------------------------------------- |
| GPT-5.2                                      | Sí                                            |
| GPT-5.2 Codex, GPT-5.3 Codex                 | Sí (pero el esfuerzo `none` no es compatible) |
| Qwen 3 235B A22B Thinking, Qwen 3.5 35B A3B  | Sí                                            |
| Serie GLM 5.1                                | Sí                                            |
| Claude Opus 4.5/4.6/4.6 Fast, Sonnet 4.5/4.6 | No (siempre razona)                           |
| Gemini 3 Pro, 3.1 Pro, 3 Flash               | No (siempre razona)                           |
| DeepSeek R1                                  | No (siempre razona)                           |

<CodeGroup>
  ```python Python theme={"dark"}
  response = client.chat.completions.create(
      model="openai-gpt-52",
      messages=[{"role": "user", "content": "What's the capital of France?"}],
      extra_body={"reasoning": {"enabled": False}}
  )
  ```

  ```javascript Node.js theme={"dark"}
  const response = await client.chat.completions.create({
      model: "openai-gpt-52",
      messages: [{ role: "user", content: "What's the capital of France?" }],
      reasoning: { enabled: false }
  });
  ```

  ```bash cURL theme={"dark"}
  curl https://api.venice.ai/api/v1/chat/completions \
    -H "Authorization: Bearer $VENICE_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "openai-gpt-52",
      "messages": [{"role": "user", "content": "What is the capital of France?"}],
      "reasoning": {"enabled": false}
    }'
  ```
</CodeGroup>

## Límites de tokens

Los modelos de razonamiento generan tokens visibles de respuesta (en `content`) y tokens de razonamiento (en `reasoning_content`). Ambos cuentan para tu presupuesto de tokens.

### Establecer un tope de tokens

Usa `max_completion_tokens` para limitar el número total de tokens que el modelo genera, incluido el razonamiento:

```json theme={"dark"}
{
  "model": "deepseek-v4-flash",
  "messages": [...],
  "max_completion_tokens": 500
}
```

`max_tokens` también se acepta y se comporta igual. Si se establecen ambos, `max_completion_tokens` tiene prioridad.

Para obtener más salida visible, sube el tope, baja `reasoning_effort` o [desactiva el razonamiento](#disabling-reasoning).

### Leer el desglose

El objeto `usage` muestra cómo se gastó tu presupuesto:

```json theme={"dark"}
"usage": {
  "completion_tokens": 501,
  "completion_tokens_details": { "reasoning_tokens": 169 },
  "prompt_tokens": 13,
  "total_tokens": 514
}
```

En este ejemplo, se gastaron 169 tokens en razonamiento y 332 en la respuesta visible. Cuando se alcanza el tope, `finish_reason` es `length`.

El límite superior de cada modelo está disponible como `maxCompletionTokens` en el endpoint [`/v1/models`](/api-reference/endpoint/models/list).

### Modelos sin razonamiento

`max_tokens` y `max_completion_tokens` se comportan igual en modelos sin razonamiento, limitando la salida visible directamente.

## Descubrir capacidades

Comprueba qué admite un modelo mediante el endpoint [`/v1/models`](/api-reference/endpoint/models/list):

| Campo                     | Significado                                                           |
| ------------------------- | --------------------------------------------------------------------- |
| `supportsReasoning`       | El modelo tiene capacidad de razonamiento (cadena de pensamiento)     |
| `supportsReasoningEffort` | El modelo acepta el parámetro `reasoning_effort` / `reasoning.effort` |

## Mejores prácticas

* Por defecto, usa `medium` para uso general
* Usa `high` o `xhigh` para tareas complejas (matemáticas, código, análisis)
* Usa `low` para aplicaciones sensibles a la latencia
* Usa `reasoning.enabled: false` o establece el effort en `none` para desactivar el razonamiento
* En caso de duda, usa `low`, `medium` o `high`. Son los valores más ampliamente admitidos