---
title: "DSPy: dspy.LM con api_base compatibile con OpenAI | BroadRouter"
description: "Configura dspy.LM per BroadNet Inference con il prefisso openai/, api_base e model_type=\"chat\", perché DSPy 3.5 manda i modelli OpenAI alla Responses API."
url: https://broadrouter.com/it/guides/dspy-openai-compatible/
lang: it
updated: 2026-11-16
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Tradotto dall’inglese con l’aiuto dell’IA. [Leggi l’originale in inglese](https://broadrouter.com/guides/dspy-openai-compatible/) (aggiornato il 2026-11-16).

# Usare DSPy con BroadNet Inference (imposta model\_type="chat")

Aggiornato 2026-11-16

Crea dspy.LM con il modello "openai/broadnet/glm-5.3", model\_type="chat", api\_base su https://inference.broadnet.ai/v1 e la tua api\_key BroadNet, poi passalo a dspy.configure. model\_type="chat" è decisivo: DSPy 3.5 manda per default i modelli con prefisso openai/ alla Responses API, che BroadNet non serve. Nel nostro test su un server mock, senza quel parametro la chiamata è andata a /v1/responses e ha ricevuto un 404, e anche l’endpoint reale di BroadNet risponde a quel percorso con un 404.

DSPy è un framework Python per programmare modelli linguistici con signature e moduli, e per ottimizzare i prompt che ci stanno dietro. Lo colleghi a un modello con `dspy.LM`. La documentazione di DSPy configura i server compatibili con OpenAI come un modello `openai/` con `api_base`. Per BroadNet Inference, che serve chat completions su `https://inference.broadnet.ai/v1`, serve anche `model_type="chat"`. BroadRouter è il sito di BroadNet; questa guida segue la documentazione di DSPy 3.5.

## Installazione

```bash
pip install dspy
export BROADNET_API_KEY='your-broadnet-key'
```

## Connessione

```python
import os
import dspy

lm = dspy.LM(
    "openai/broadnet/glm-5.3",
    model_type="chat",
    api_base="https://inference.broadnet.ai/v1",
    api_key=os.environ["BROADNET_API_KEY"],
    max_tokens=4000,
)
dspy.configure(lm=lm)

qa = dspy.Predict("question -> answer")
print(qa(question="What is the capital of Saudi Arabia?").answer)
```

-   **`openai/`** dice a DSPy di usare il suo client OpenAI. Il resto della stringa, `broadnet/glm-5.3`, è l’ID del modello inviato a BroadNet.
-   **`model_type="chat"`** tiene DSPy su `/v1/chat/completions`. Il riferimento LM di DSPy dice che il valore predefinito, `'auto'`, fa sì che i modelli OpenAI “use Responses” (traduzione: «usino Responses»).
-   **`max_tokens`** lascia spazio al ragionamento. DeepSeek V4.1 Flash, GLM 5.3 e Qwen3.8 27B ragionano prima di rispondere, e il ragionamento conta nel limite.

## Cosa succede senza model\_type

L’esempio per un server compatibile con OpenAI nella pagina di installazione di DSPy omette `model_type`. Nel nostro test con DSPy 3.5.0, così la richiesta è andata a `/v1/responses` con `max_output_tokens`, e la chiamata è fallita:

```text
dspy.utils.exceptions.LMInvalidRequestError: [openai/broadnet/glm-5.3] /v1/responses not served
```

Quell’errore veniva dal nostro server mock. Anche l’endpoint reale di BroadNet ha risposto a `/v1/responses` con un 404 quando l’abbiamo verificato il 2026-11-16. Aggiungere `model_type="chat"` ha risolto.

## Moduli e modelli

```python
cot = dspy.ChainOfThought("question -> answer")
print(cot(question="A train leaves at 9:40 and arrives at 13:05. How long is the trip?").answer)
```

| Uso in DSPy | Modello |
| --- | --- |
| `Predict`, `ChainOfThought`, esecuzioni degli optimizer | `broadnet/deepseek-v4.1-flash` (prezzo per token basso; piani flat) |
| `ReAct` e altri moduli che chiamano strumenti | `broadnet/glm-5.3` o `broadnet/qwen3.8-27b` |
| Provare DSPy con il credito iniziale | `broadnet/gemma-4-26b-a4b` (contesto da 32.768 token) |

La documentazione di BroadNet indica strumenti e output strutturato solo per GLM 5.3 e Qwen3.8 27B. Puoi usare un modello per il programma e un altro per l’optimizer, ciascuno con il suo `dspy.LM`. [Prezzi di tutti i modelli](https://broadrouter.com/it/pricing/).

## Come l’abbiamo testato

Il 2026-11-15 abbiamo installato dspy 3.5.0 in un ambiente virtuale pulito e lanciato `dspy.Predict` contro un server mock locale che parla il formato di chat completions di BroadNet e risponde a `/v1/responses` con un 404. Senza `model_type`, DSPy ha chiamato `/v1/responses` ed è fallito. Con `model_type="chat"` ha chiamato `/v1/chat/completions` con l’ID del modello `broadnet/glm-5.3` e una chiave Bearer, e ha letto il campo answer. Abbiamo visto che DSPy inviava il limite di output come `max_completion_tokens`. Il riferimento API di BroadNet descrive `max_tokens` e non menziona `max_completion_tokens`, quindi non possiamo confermare che BroadNet applichi un limite inviato in quel modo. Abbiamo testato contro un server mock, non con una chiave BroadNet, quindi non abbiamo verificato l’output reale del modello.

## Risoluzione dei problemi

-   **404 su /v1/responses.** Aggiungi `model_type="chat"`.
-   **404 su /v1/chat/completions.** `api_base` deve finire con `/v1`, e la stringa del modello deve essere `openai/` più l’ID BroadNet completo. I modelli a pagamento richiedono una ricarica; il credito di $5 copre solo `broadnet/gemma-4-26b-a4b` e i due modelli Transcribe.
-   **“Expected to find output fields”.** La risposta era vuota o troncata, spesso perché il ragionamento ha consumato il budget di output. Alza `max_tokens`. [Perché le risposte arrivano vuote](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/).
-   **429 durante l’ottimizzazione.** Una chiave a consumo consente 30 richieste al minuto e 4 in corso. Riduci il numero di thread dell’optimizer e vedi [errori e retry](https://broadrouter.com/it/guides/errors-and-retries/).

## Termini in questa guida

[Pagamento a consumo (pay-as-you-go)](https://broadrouter.com/it/glossary/pay-as-you-go/)

Il pagamento a consumo è un modello di prezzo in cui paghi solo ciò che usi, misurato per unità come token, richieste o minuti di audio, senza abbonamento né impegno minimo. La maggior parte delle API LLM fattura così, da un saldo prepagato o con una fattura periodica.

[Token](https://broadrouter.com/it/glossary/token/)

Un token è l’unità di testo che un modello linguistico legge e scrive: una parola, una parte di parola, un segno di punteggiatura o una sequenza di byte prodotta dal tokenizer del modello. Le API LLM contano, limitano e di solito fatturano l’uso in token.

[Chat Completions API](https://broadrouter.com/it/glossary/chat-completions-api/)

La Chat Completions API è l’endpoint HTTP di OpenAI, POST /v1/chat/completions, che riceve il nome di un modello e una lista di messaggi con un ruolo e restituisce il messaggio successivo del modello. La forma della sua richiesta e risposta è diventata il formato comune che riusano provider e SDK compatibili con OpenAI.

[Concorrenza (concurrency)](https://broadrouter.com/it/glossary/concurrency/)

La concorrenza è il numero di richieste che un client ha in corso nello stesso momento. Le API LLM spesso la limitano per chiave o per piano, separatamente dalle richieste al minuto, perché ogni richiesta aperta occupa capacità GPU finché la sua risposta non è terminata.

[Rate limit (limite di frequenza)](https://broadrouter.com/it/glossary/rate-limit/)

Un rate limit è un tetto che un’API pone a quanto un client può usarla in un intervallo di tempo, per esempio richieste al minuto o token al minuto. Le richieste oltre il limite vengono rifiutate, di solito con HTTP 429 Too Many Requests, finché l’uso non torna sotto la soglia.

[Tool calling (chiamata di strumenti)](https://broadrouter.com/it/glossary/tool-calling/)

Il tool calling, detto anche function calling, è una funzionalità delle API LLM in cui il modello restituisce una richiesta strutturata di eseguire una funzione definita dallo sviluppatore, con argomenti JSON. L’applicazione esegue la funzione e rimanda il risultato; il modello non esegue mai codice da solo.

[Credito prepagato (prepaid credit)](https://broadrouter.com/it/glossary/prepaid-credit/)

Il credito prepagato è denaro aggiunto a un account API prima dell’uso. Ogni richiesta scala il proprio costo dal saldo e, quando il saldo si esaurisce, le richieste a consumo si fermano finché non ricarichi. Limita la spesa a quanto hai versato.

[Output strutturato (structured output)](https://broadrouter.com/it/glossary/structured-output/)

L’output strutturato è una funzionalità delle API LLM che vincola la risposta di un modello a un formato indicato dallo sviluppatore, di solito un JSON Schema, così il codice può interpretarla in modo affidabile. È più rigoroso della JSON mode, che garantisce un JSON valido ma non una struttura precisa.

## Domande frequenti

### Perché DSPy chiama /v1/responses su BroadNet?

Secondo il riferimento di dspy.LM di DSPy 3.5, model\_type "auto", il valore predefinito, fa usare ai modelli OpenAI la Responses API. Un modello openai/ con un api\_base personalizzato viene trattato allo stesso modo. Passa model\_type="chat" per usare chat completions, che è ciò che BroadNet serve.

### Come si scrive l’ID del modello BroadNet in DSPy?

Metti openai/ davanti all’ID BroadNet, per esempio openai/broadnet/glm-5.3. DSPy usa openai/ per scegliere il client e, nel nostro test, ha inviato broadnet/glm-5.3 come modello.

### Quale modello BroadNet è adatto agli optimizer di DSPy?

Gli optimizer fanno molte chiamate, quindi contano costi e rate limit. DeepSeek V4.1 Flash ha un prezzo per token basso ed è il modello dei piani flat di BroadNet, che non sono misurati per token. Usa GLM 5.3 o Qwen3.8 27B per i moduli che chiamano strumenti, come ReAct.

### La cache di DSPy conta con BroadNet?

DSPy mette in cache le chiamate al modello per default (cache=True), quindi ripetere la stessa chiamata non costa nulla. Imposta cache=False mentre verifichi la connessione, altrimenti potresti guardare una risposta presa dalla cache.

## Guide correlate

-   [Usare l’SDK Python di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-python-sdk/)
-   [Instradare LiteLLM verso BroadNet Inference (SDK e proxy)](https://broadrouter.com/it/guides/litellm-proxy-custom-provider/)
-   [Perché un modello di ragionamento restituisce una risposta vuota](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/)
-   [Codici di errore di BroadNet Inference e quando ritentare](https://broadrouter.com/it/guides/errors-and-retries/)
-   [Tutti gli strumenti che funzionano con BroadNet Inference (in inglese)](https://broadrouter.com/integrations/): SDK, agenti di coding, interfacce di chat e strumenti di automazione, con le impostazioni esatte per ciascuno

Provalo sul tuo carico di lavoro reale. I nuovi account partono con USD 5 di credito per Gemma e trascrizione. DeepSeek, GLM e Qwen3.8 richiedono una ricarica.

[Inizia](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-guides-dspy-openai-compatible&utm_content=page-cta) ·

**Fonti**

-   [Documentazione di DSPy, installazione e configurazione del modello linguistico (pagina datata 2026-11-10, verificata il 2026-11-15)](https://dspy.ai/current/getting-started/installation/)
-   [Documentazione di DSPy, riferimento API di dspy.LM (model\_type) (verificata il 2026-11-15)](https://dspy.ai/current/api/models/LM/)
-   [PyPI, dspy 3.5.0 (verificato il 2026-11-15)](https://pypi.org/project/dspy/)
-   [Riferimento API di BroadNet Inference (verificato il 2026-11-16) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-guides-dspy-openai-compatible&utm_content=sources)
