Reasoning Models | Venice API Docs

Alcuni modelli pensano ad alta voce prima di rispondere. Lavorano sui problemi passo dopo passo, quindi forniscono una risposta finale. Questo li rende più forti su matematica, codice e compiti ad alto contenuto logico.

Consulta l’elenco completo dei modelli, dei prezzi e dei limiti di contesto nella pagina Modelli. Non tutti i modelli di ragionamento supportano il parametro reasoning_effort. Vedi il supporto dei modelli per i dettagli.

Leggere l’output

I modelli di ragionamento restituiscono il loro thinking in un campo separato reasoning_content, mantenendo content pulito:

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

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;

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?"}]
  }'

Alcuni provider (Anthropic, Google, OpenAI, Qwen) restituiscono token di ragionamento cifrati o riassunti. Quando questo accade, reasoning_content contiene un placeholder "[Some reasoning content is encrypted]".

Streaming

In streaming, reasoning_content arriva nel delta prima della risposta finale:

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="")

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);
    }
}

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

Reasoning effort

Il parametro reasoning_effort controlla quanto thinking fa un modello prima di rispondere. Più sforzo significa ragionamento più profondo ma più token e latenza.

Valori accettati

Valore	Descrizione
`none`	Disabilita completamente il ragionamento
`minimal`	Ragionamento di base con sforzo minimo
`low`	Ragionamento leggero per problemi semplici
`medium`	Ragionamento bilanciato per complessità moderata
`high`	Ragionamento profondo per problemi complessi
`xhigh`	Profondità di ragionamento extra-alta
`max`	Capacità di ragionamento massima

Non tutti i modelli supportano tutti i valori. Se invii un valore che un modello non supporta, Venice potrebbe adattarlo a un livello supportato. Alcuni modelli invece restituiscono un errore 400 che elenca i valori supportati.In caso di dubbi, usa low, medium o high. Sono i valori più ampiamente supportati.

Supporto dei modelli

I valori supportati cambiano man mano che i modelli vengono aggiunti e aggiornati, quindi leggili dall’endpoint /v1/models invece di codificarli in modo fisso. Ogni modello che accetta reasoning_effort li elenca sotto model_spec.capabilities:

Campo	Significato
`reasoningEffortOptions`	I valori di `reasoning_effort` supportati dal modello. Se include `none`, il ragionamento può essere disabilitato
`defaultReasoningEffort`	Il valore usato quando la richiesta non ne imposta uno

Entrambi i campi sono presenti solo quando supportsReasoningEffort è true.

curl -s "https://api.venice.ai/api/v1/models?type=text" \
  | jq '.data[]
    | select(.model_spec.capabilities.supportsReasoningEffort)
    | {id, options: .model_spec.capabilities.reasoningEffortOptions,
       default: .model_spec.capabilities.defaultReasoningEffort}'

{
  "id": "zai-org-glm-5-1",
  "options": ["none", "low", "medium", "high"],
  "default": "low"
}

Utilizzo

Passa reasoning_effort come parametro di primo livello o usa il formato nidificato reasoning.effort:

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

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

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"}
  }'

Anche il formato piatto "reasoning_effort": "high" è accettato.

Disabilitare il ragionamento

Ci sono due modi per disabilitare il ragionamento:

Metodo	Sintassi	Come funziona
`reasoning.enabled: false`	`"reasoning": {"enabled": false}`	Toggle a livello Venice che impedisce l’invio di parametri di ragionamento al provider. Consigliato.
`reasoning.effort: "none"`	`"reasoning": {"effort": "none"}`	Passato al provider, che decide come gestirlo. Supportato solo da alcuni modelli (es. GPT-5.x).

Per i modelli che lo supportano, reasoning.enabled: false è l’opzione più affidabile:

Modello	Disabilitabile?
GPT-5.2	Sì
GPT-5.3 Codex	Sì
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 (ragiona sempre)
Gemini 3.1 Pro, 3 Flash	No (ragiona sempre)

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

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

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

Limiti di token

I modelli di ragionamento generano token di risposta visibili (in content) e token di ragionamento (in reasoning_content). Entrambi contano verso il tuo budget di token.

Impostare un limite di token

Usa max_completion_tokens per limitare il numero totale di token generati dal modello, ragionamento incluso:

{
  "model": "deepseek-v4-flash",
  "messages": [...],
  "max_completion_tokens": 500
}

Anche max_tokens è accettato e si comporta allo stesso modo. Se entrambi sono impostati, max_completion_tokens ha la precedenza. Per ottenere più output visibile, alza il limite, abbassa reasoning_effort o disabilita il ragionamento.

Leggere il dettaglio

L’oggetto usage mostra come è stato speso il tuo budget:

"usage": {
  "completion_tokens": 501,
  "completion_tokens_details": { "reasoning_tokens": 169 },
  "prompt_tokens": 13,
  "total_tokens": 514
}

In questo esempio, 169 token sono stati spesi per il ragionamento e 332 per la risposta visibile. Quando viene raggiunto il limite, finish_reason è length. Il limite superiore di ciascun modello è disponibile come maxCompletionTokens nell’endpoint /v1/models.

Modelli senza ragionamento

max_tokens e max_completion_tokens si comportano allo stesso modo sui modelli senza ragionamento, limitando direttamente l’output visibile.

Discovery delle capacità

Controlla cosa supporta un modello tramite l’endpoint /v1/models:

Campo	Significato
`supportsReasoning`	Il modello ha capacità di ragionamento (chain-of-thought)
`supportsReasoningEffort`	Il modello accetta il parametro `reasoning_effort` / `reasoning.effort`
`reasoningEffortOptions`	Valori di effort supportati (vedi supporto dei modelli)
`defaultReasoningEffort`	Effort usato quando la richiesta non ne imposta uno

Best practice

Per uso generale, imposta come default medium
Usa high o xhigh per compiti complessi (matematica, codice, analisi)
Usa low per applicazioni sensibili alla latenza
Usa reasoning.enabled: false o imposta effort su none per disabilitare il ragionamento
In caso di dubbi, usa low, medium o high. Sono i valori più ampiamente supportati

Documentazione

Per iniziare

Testo e chat

Immagini

Video

Audio

Ricerca e RAG

Agenti e integrazioni

Strumenti di sviluppo

Strumenti per agenti

SDK e framework

Modelli di ragionamento

Leggere l’output

Streaming

Reasoning effort

Valori accettati

Supporto dei modelli

Utilizzo

Disabilitare il ragionamento

Limiti di token

Impostare un limite di token

Leggere il dettaglio

Modelli senza ragionamento

Discovery delle capacità

Best practice

​Leggere l’output

​Streaming

​Reasoning effort

​Valori accettati

​Supporto dei modelli

​Utilizzo

​Disabilitare il ragionamento

​Limiti di token

​Impostare un limite di token

​Leggere il dettaglio

​Modelli senza ragionamento

​Discovery delle capacità

​Best practice

Leggere l’output

Streaming

Reasoning effort

Valori accettati

Supporto dei modelli

Utilizzo

Disabilitare il ragionamento

Limiti di token

Impostare un limite di token

Leggere il dettaglio

Modelli senza ragionamento

Discovery delle capacità

Best practice