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

# Reasoning-Modelle

> Rufen Sie Venice-Reasoning-Modelle auf, die Chain-of-Thought-Tokens offenlegen, den Denkaufwand steuern und Schritt-für-Schritt-Antworten liefern.

Einige Modelle "denken laut", bevor sie antworten. Sie arbeiten Probleme Schritt für Schritt durch und geben dann eine finale Antwort. Das macht sie stärker bei Mathematik-, Code- und logiklastigen Aufgaben.

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

Die vollständige Liste der Modelle, Preise und Kontextlimits finden Sie auf der [Models-Seite](/overview/models). Nicht alle Reasoning-Modelle unterstützen den Parameter [`reasoning_effort`](#reasoning-effort). Siehe [Modellunterstützung](#model-support) für Details.

## Die Ausgabe lesen

Reasoning-Modelle geben ihr Thinking in einem separaten Feld `reasoning_content` zurück und halten `content` sauber:

<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>
  Einige Anbieter (Anthropic, Google, OpenAI, Qwen) geben verschlüsselte oder zusammengefasste Reasoning-Tokens zurück. In diesem Fall enthält `reasoning_content` einen Platzhalter `"[Some reasoning content is encrypted]"`.
</Info>

### Streaming

Beim Streaming kommt `reasoning_content` im Delta vor der finalen Antwort an:

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

## Reasoning effort

Der Parameter `reasoning_effort` steuert, wie viel ein Modell vor der Antwort denkt. Höherer Effort bedeutet tieferes Reasoning, aber mehr Tokens und Latenz.

### Akzeptierte Werte

| Wert      | Beschreibung                                    |
| --------- | ----------------------------------------------- |
| `none`    | Deaktiviert Reasoning vollständig               |
| `minimal` | Grundlegendes Reasoning mit minimalem Aufwand   |
| `low`     | Leichtes Reasoning für einfache Probleme        |
| `medium`  | Ausgewogenes Reasoning für mittlere Komplexität |
| `high`    | Tiefes Reasoning für komplexe Probleme          |
| `xhigh`   | Besonders hohe Reasoning-Tiefe                  |
| `max`     | Maximale Reasoning-Fähigkeit                    |

<Warning>
  Nicht alle Modelle unterstützen alle Werte. Venice mappt **nicht** automatisch auf die nächstgelegene unterstützte Stufe. Nicht unterstützte Werte geben einen 400-Fehler vom Upstream-Anbieter zurück. Beispielsweise schlägt das Senden von `xhigh` an Claude oder `max` an GPT-5.2 fehl.

  Verwenden Sie im Zweifel `low`, `medium` oder `high`. Dies sind die am breitesten unterstützten Werte.
</Warning>

### Modellunterstützung

#### OpenAI

| Modell                       | Unterstützte Werte                       |
| ---------------------------- | ---------------------------------------- |
| GPT-5.2                      | `none`, `low`, `medium`, `high`, `xhigh` |
| GPT-5.2 Codex, GPT-5.3 Codex | `low`, `medium`, `high`, `xhigh`         |

#### Anthropic

| Modell                                  | Unterstützte Werte             |
| --------------------------------------- | ------------------------------ |
| 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

| Modell                 | Unterstützte Werte                 |
| ---------------------- | ---------------------------------- |
| Gemini 3 Pro Preview   | `low`, `high`                      |
| Gemini 3.1 Pro Preview | `low`, `medium`, `high`            |
| Gemini 3 Flash Preview | `minimal`, `low`, `medium`, `high` |

#### xAI

Grok-Modelle (Grok 4.1 Fast, Grok Code Fast) unterstützen `reasoning_effort` **nicht**. Die Angabe führt zu einem Fehler.

#### Weitere Modelle

| Modell                                      | Unterstützte Werte                              |
| ------------------------------------------- | ----------------------------------------------- |
| 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`                         |
| GLM 5.1-Serie                               | Nur eingebautes Reasoning, nicht konfigurierbar |
| DeepSeek R1                                 | Nur eingebautes Reasoning, nicht konfigurierbar |

### Verwendung

Übergeben Sie `reasoning_effort` als Top-Level-Parameter oder verwenden Sie das verschachtelte Format `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>

Das flache Format `"reasoning_effort": "high"` wird ebenfalls akzeptiert.

## Reasoning deaktivieren

Es gibt zwei Möglichkeiten, Reasoning zu deaktivieren:

| Methode                    | Syntax                            | Funktionsweise                                                                                                                        |
| -------------------------- | --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| `reasoning.enabled: false` | `"reasoning": {"enabled": false}` | Venice-Toggle, der verhindert, dass Reasoning-Parameter an den Anbieter gesendet werden. **Empfohlen.**                               |
| `reasoning.effort: "none"` | `"reasoning": {"effort": "none"}` | Wird an den Anbieter weitergegeben, der entscheidet, wie damit umgegangen wird. Nur von einigen Modellen unterstützt (z. B. GPT-5.x). |

Für Modelle, die es unterstützen, ist `reasoning.enabled: false` die zuverlässigere Option:

| Modell                                       | Kann deaktiviert werden?                  |
| -------------------------------------------- | ----------------------------------------- |
| GPT-5.2                                      | Ja                                        |
| GPT-5.2 Codex, GPT-5.3 Codex                 | Ja (aber `none`-Effort nicht unterstützt) |
| Qwen 3 235B A22B Thinking, Qwen 3.5 35B A3B  | Ja                                        |
| GLM 5.1-Serie                                | Ja                                        |
| Claude Opus 4.5/4.6/4.6 Fast, Sonnet 4.5/4.6 | Nein (immer reasoning)                    |
| Gemini 3 Pro, 3.1 Pro, 3 Flash               | Nein (immer reasoning)                    |
| DeepSeek R1                                  | Nein (immer reasoning)                    |

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

## Token-Limits

Reasoning-Modelle generieren sichtbare Antwort-Tokens (in `content`) und Reasoning-Tokens (in `reasoning_content`). Beide zählen zu Ihrem Token-Budget.

### Eine Token-Obergrenze setzen

Verwenden Sie `max_completion_tokens`, um die Gesamtzahl der vom Modell generierten Tokens einschließlich Reasoning zu begrenzen:

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

`max_tokens` wird ebenfalls akzeptiert und verhält sich genauso. Wenn beide gesetzt sind, hat `max_completion_tokens` Vorrang.

Um mehr sichtbare Ausgabe zu erhalten, erhöhen Sie die Obergrenze, senken Sie `reasoning_effort` oder [deaktivieren Sie Reasoning](#disabling-reasoning).

### Die Aufschlüsselung lesen

Das `usage`-Objekt zeigt, wofür Ihr Budget verwendet wurde:

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

In diesem Beispiel wurden 169 Tokens für Reasoning und 332 für die sichtbare Antwort aufgewendet. Wenn die Obergrenze erreicht ist, lautet `finish_reason` `length`.

Die Obergrenze jedes Modells ist als `maxCompletionTokens` am Endpoint [`/v1/models`](/api-reference/endpoint/models/list) verfügbar.

### Nicht-Reasoning-Modelle

`max_tokens` und `max_completion_tokens` verhalten sich bei Nicht-Reasoning-Modellen gleich und begrenzen die sichtbare Ausgabe direkt.

## Capability-Erkennung

Prüfen Sie über den Endpoint [`/v1/models`](/api-reference/endpoint/models/list), was ein Modell unterstützt:

| Feld                      | Bedeutung                                                               |
| ------------------------- | ----------------------------------------------------------------------- |
| `supportsReasoning`       | Modell besitzt Reasoning-Fähigkeit (Chain-of-Thought)                   |
| `supportsReasoningEffort` | Modell akzeptiert den Parameter `reasoning_effort` / `reasoning.effort` |

## Best Practices

* Standardmäßig `medium` für allgemeine Verwendung verwenden
* `high` oder `xhigh` für komplexe Aufgaben (Mathematik, Code, Analyse) verwenden
* `low` für latenzempfindliche Anwendungen verwenden
* `reasoning.enabled: false` verwenden oder Effort auf `none` setzen, um Reasoning zu deaktivieren
* Im Zweifel `low`, `medium` oder `high` verwenden. Dies sind die am breitesten unterstützten Werte