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

# Modèles de raisonnement

> Appelez les modèles de raisonnement Venice : tokens de chaîne de pensée exposés, contrôle de l'effort de réflexion et réponses étape par étape.

Certains modèles réfléchissent à voix haute avant de répondre. Ils résolvent les problèmes étape par étape, puis fournissent une réponse finale. Cela les rend plus performants pour les mathématiques, le code et les tâches de logique exigeante.

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

Consultez la liste complète des modèles, des tarifs et des limites de contexte sur la [page Modèles](/overview/models). Tous les modèles de raisonnement ne prennent pas en charge le paramètre [`reasoning_effort`](#reasoning-effort). Voir la [prise en charge des modèles](#model-support) pour plus de détails.

## Lire la sortie

Les modèles de raisonnement renvoient leur chaîne de pensée dans un champ `reasoning_content` distinct, ce qui garde `content` propre :

<CodeGroup>
  ```python Python theme={"system"}
  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={"system"}
  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={"system"}
  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>
  Certains fournisseurs (Anthropic, Google, OpenAI, Qwen) renvoient des tokens de raisonnement chiffrés ou résumés. Dans ce cas, `reasoning_content` contient un substitut `"[Some reasoning content is encrypted]"`.
</Info>

### Streaming

En mode streaming, `reasoning_content` arrive dans le delta avant la réponse finale :

<CodeGroup>
  ```python Python theme={"system"}
  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={"system"}
  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={"system"}
  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>

## Effort de raisonnement

Le paramètre `reasoning_effort` contrôle à quel point le modèle réfléchit avant de répondre. Un effort plus élevé signifie un raisonnement plus profond, mais davantage de tokens et de latence.

### Valeurs acceptées

| Valeur    | Description                                        |
| --------- | -------------------------------------------------- |
| `none`    | Désactive complètement le raisonnement             |
| `minimal` | Raisonnement basique avec un effort minimal        |
| `low`     | Raisonnement léger pour les problèmes simples      |
| `medium`  | Raisonnement équilibré pour une complexité modérée |
| `high`    | Raisonnement profond pour les problèmes complexes  |
| `xhigh`   | Profondeur de raisonnement très élevée             |
| `max`     | Capacité de raisonnement maximale                  |

<Warning>
  Tous les modèles ne prennent pas en charge toutes les valeurs. Venice ne mappe **pas** automatiquement au niveau pris en charge le plus proche. Les valeurs non prises en charge renvoient une erreur 400 du fournisseur en amont. Par exemple, envoyer `xhigh` à Claude ou `max` à GPT-5.2 échouera.

  En cas de doute, utilisez `low`, `medium` ou `high`. Ce sont les valeurs les plus largement prises en charge.
</Warning>

### Prise en charge des modèles

#### OpenAI

| Modèle                       | Valeurs prises en charge                 |
| ---------------------------- | ---------------------------------------- |
| GPT-5.2                      | `none`, `low`, `medium`, `high`, `xhigh` |
| GPT-5.2 Codex, GPT-5.3 Codex | `low`, `medium`, `high`, `xhigh`         |

#### Anthropic

| Modèle                                  | Valeurs prises en charge       |
| --------------------------------------- | ------------------------------ |
| 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

| Modèle                 | Valeurs prises en charge           |
| ---------------------- | ---------------------------------- |
| Gemini 3 Pro Preview   | `low`, `high`                      |
| Gemini 3.1 Pro Preview | `low`, `medium`, `high`            |
| Gemini 3 Flash Preview | `minimal`, `low`, `medium`, `high` |

#### xAI

Les modèles Grok (Grok 4.1 Fast, Grok Code Fast) ne prennent **pas** en charge `reasoning_effort`. Le spécifier entraînera une erreur.

#### Autres modèles

| Modèle                                      | Valeurs prises en charge                          |
| ------------------------------------------- | ------------------------------------------------- |
| 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`                           |
| Série GLM 5.1                               | Raisonnement intégré uniquement, non configurable |
| DeepSeek R1                                 | Raisonnement intégré uniquement, non configurable |

### Utilisation

Passez `reasoning_effort` comme paramètre de premier niveau ou utilisez le format imbriqué `reasoning.effort` :

<CodeGroup>
  ```python Python theme={"system"}
  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={"system"}
  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={"system"}
  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>

Le format plat `"reasoning_effort": "high"` est également accepté.

## Désactiver le raisonnement

Il existe deux façons de désactiver le raisonnement :

| Méthode                    | Syntaxe                           | Fonctionnement                                                                                                          |
| -------------------------- | --------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `reasoning.enabled: false` | `"reasoning": {"enabled": false}` | Bascule au niveau Venice qui empêche les paramètres de raisonnement d'être envoyés au fournisseur. **Recommandé.**      |
| `reasoning.effort: "none"` | `"reasoning": {"effort": "none"}` | Transmis au fournisseur, qui décide comment le gérer. Pris en charge uniquement par certains modèles (par ex. GPT-5.x). |

Pour les modèles qui le prennent en charge, `reasoning.enabled: false` est l'option la plus fiable :

| Modèle                                       | Peut être désactivé ?                               |
| -------------------------------------------- | --------------------------------------------------- |
| GPT-5.2                                      | Oui                                                 |
| GPT-5.2 Codex, GPT-5.3 Codex                 | Oui (mais l'effort `none` n'est pas pris en charge) |
| Qwen 3 235B A22B Thinking, Qwen 3.5 35B A3B  | Oui                                                 |
| Série GLM 5.1                                | Oui                                                 |
| Claude Opus 4.5/4.6/4.6 Fast, Sonnet 4.5/4.6 | Non (raisonne toujours)                             |
| Gemini 3 Pro, 3.1 Pro, 3 Flash               | Non (raisonne toujours)                             |
| DeepSeek R1                                  | Non (raisonne toujours)                             |

<CodeGroup>
  ```python Python theme={"system"}
  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={"system"}
  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={"system"}
  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>

## Limites de tokens

Les modèles de raisonnement génèrent des tokens de réponse visibles (dans `content`) et des tokens de raisonnement (dans `reasoning_content`). Les deux sont comptabilisés dans votre budget de tokens.

### Définir un plafond de tokens

Utilisez `max_completion_tokens` pour plafonner le nombre total de tokens que le modèle génère, raisonnement compris :

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

`max_tokens` est également accepté et se comporte de la même manière. Si les deux sont définis, `max_completion_tokens` prend la priorité.

Pour obtenir plus de sortie visible, augmentez le plafond, abaissez `reasoning_effort`, ou [désactivez le raisonnement](#disabling-reasoning).

### Lire le détail

L'objet `usage` montre comment votre budget a été dépensé :

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

Dans cet exemple, 169 tokens ont été consacrés au raisonnement et 332 à la réponse visible. Lorsque le plafond est atteint, `finish_reason` vaut `length`.

La limite supérieure de chaque modèle est disponible sous `maxCompletionTokens` sur l'endpoint [`/v1/models`](/api-reference/endpoint/models/list).

### Modèles sans raisonnement

`max_tokens` et `max_completion_tokens` se comportent de la même manière sur les modèles sans raisonnement, en plafonnant directement la sortie visible.

## Découverte des capacités

Vérifiez ce qu'un modèle prend en charge via l'endpoint [`/v1/models`](/api-reference/endpoint/models/list) :

| Champ                     | Signification                                                          |
| ------------------------- | ---------------------------------------------------------------------- |
| `supportsReasoning`       | Le modèle a une capacité de raisonnement (chaîne de pensée)            |
| `supportsReasoningEffort` | Le modèle accepte le paramètre `reasoning_effort` / `reasoning.effort` |

## Bonnes pratiques

* Utilisez `medium` par défaut pour un usage général
* Utilisez `high` ou `xhigh` pour les tâches complexes (mathématiques, code, analyse)
* Utilisez `low` pour les applications sensibles à la latence
* Utilisez `reasoning.enabled: false` ou définissez l'effort à `none` pour désactiver le raisonnement
* En cas de doute, utilisez `low`, `medium` ou `high`. Ce sont les valeurs les plus largement prises en charge