---
title: "LangGraph con base_url custom compatibile OpenAI | BroadRouter"
description: "Esegui uno StateGraph o create_agent di LangGraph su BroadNet Inference con ChatOpenAI, base_url e un ID di modello BroadNet, con strumenti, streaming e memoria."
url: https://broadrouter.com/it/guides/langgraph-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/langgraph-openai-compatible/) (aggiornato il 2026-11-16).

# Creare agenti LangGraph su BroadNet Inference

Aggiornato 2026-11-16

Installa langgraph e langchain-openai, poi crea ChatOpenAI con model impostato su un ID BroadNet come broadnet/glm-5.3, base\_url su https://inference.broadnet.ai/v1 e api\_key con la tua chiave BroadNet. Collega gli strumenti e usalo in un nodo di uno StateGraph, oppure passalo a create\_agent di langchain. Usa GLM 5.3 o Qwen3.8 27B, i modelli per cui BroadNet indica gli strumenti.

LangGraph è la libreria di LangChain per agenti con stato e a più passaggi, costruiti come grafi. Non ha un client di modelli proprio: i tuoi nodi chiamano un chat model di LangChain. Per eseguire un grafo su BroadNet Inference, dagli `ChatOpenAI` di `langchain-openai` con il base URL di BroadNet. BroadRouter è il sito di BroadNet; questa guida segue la documentazione di LangGraph e LangChain alle versioni LangGraph 1.2.22 e langchain-openai 1.8.

## Installazione

```bash
pip install langgraph langchain-openai
export BROADNET_API_KEY='your-broadnet-key'
```

## Un grafo con tool calling

```python
import os
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langgraph.graph import StateGraph, MessagesState, START
from langgraph.prebuilt import ToolNode, tools_condition
from langgraph.checkpoint.memory import InMemorySaver

@tool
def get_weather(city: str) -> str:
    """Get the weather for a city."""
    return f"21C and sunny in {city}"

tools = [get_weather]
model = ChatOpenAI(
    model="broadnet/glm-5.3",
    base_url="https://inference.broadnet.ai/v1",
    api_key=os.environ["BROADNET_API_KEY"],
).bind_tools(tools)

def call_model(state: MessagesState):
    return {"messages": [model.invoke(state["messages"])]}

builder = StateGraph(MessagesState)
builder.add_node("model", call_model)
builder.add_node("tools", ToolNode(tools))
builder.add_edge(START, "model")
builder.add_conditional_edges("model", tools_condition)
builder.add_edge("tools", "model")
graph = builder.compile(checkpointer=InMemorySaver())

config = {"configurable": {"thread_id": "demo-1"}}
result = graph.invoke({"messages": [{"role": "user", "content": "What's the weather in Riyadh?"}]}, config)
print(result["messages"][-1].content)
```

Il nodo del modello chiama BroadNet. `tools_condition` manda il grafo al nodo degli strumenti quando la risposta contiene chiamate agli strumenti, e il risultato dello strumento torna al modello. Il checkpointer conserva la conversazione per `thread_id`, quindi un secondo `invoke` con la stessa config la continua.

## Streaming dei token dal grafo

```python
for chunk, meta in graph.stream(
    {"messages": [{"role": "user", "content": "And in Dubai?"}]},
    config,
    stream_mode="messages",
):
    if chunk.content and meta["langgraph_node"] == "model":
        print(chunk.content, end="", flush=True)
```

Con `stream_mode="messages"`, `ChatOpenAI` invia `stream: true` a BroadNet e LangGraph inoltra i token.

## L’agente prebuilt

Se non ti serve un grafo personalizzato, il ciclo dell’agente prebuilt accetta lo stesso modello:

```python
from langchain.agents import create_agent  # pip install langchain

agent = create_agent(
    ChatOpenAI(model="broadnet/glm-5.3", base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"]),
    tools=tools,
)
agent.invoke({"messages": [{"role": "user", "content": "Weather in Riyadh?"}]})
```

`create_react_agent` di `langgraph.prebuilt` funziona ancora in LangGraph 1.2.22, ma stampa un avviso secondo cui è stato spostato in `langchain.agents.create_agent`.

## Quale modello scegliere

| Grafo | Modello |
| --- | --- |
| Agenti con strumenti, output strutturato | `broadnet/glm-5.3` (contesto da 1.048.576 token) |
| Strumenti più input di immagini o testo in arabo | `broadnet/qwen3.8-27b` (contesto da 262.144 token) |
| Grafi senza chiamate agli strumenti, documenti lunghi | `broadnet/deepseek-v4.1-flash` |

La documentazione di BroadNet indica strumenti e output strutturato solo per GLM 5.3 e Qwen3.8 27B. DeepSeek V4.1 Flash è il modello dei [piani illimitati](https://broadrouter.com/it/guides/unlimited-llm-api-sessions/), quindi è adatto a grafi di riassunto e instradamento che non chiamano strumenti. Prova un ciclo con strumenti su questo modello prima di farci affidamento. [Prezzi di tutti i modelli](https://broadrouter.com/it/pricing/).

## Impostazioni che contano

-   **Resta su chat completions.** BroadNet serve `/v1/chat/completions`. La documentazione di LangChain dice che `ChatOpenAI` passa alla Responses API quando usi gli strumenti integrati di OpenAI, lo stato della conversazione o il parametro `reasoning`. Lasciali fuori e non impostare `use_responses_api=True`.
-   **Limite di output.** Su DeepSeek V4.1 Flash, GLM 5.3 e Qwen3.8 27B il ragionamento conta nel budget di output. Imposta `max_tokens` a 2.000 o più sul modello. Nel nostro test langchain-openai 1.8 lo ha inviato come `max_completion_tokens`.
-   **Rami paralleli.** Ogni ramo che chiama il modello è una richiesta separata. Una chiave a consumo consente 4 richieste in corso contemporaneamente, e una sessione di un piano ne esegue una alla volta.

## Come l’abbiamo testato

Il 2026-11-15 abbiamo installato langgraph 1.2.22, langchain-openai 1.8.0 e langchain 1.5.0 in un ambiente virtuale pulito. Abbiamo eseguito il grafo qui sopra, il ciclo di streaming e `create_agent` contro un mock server locale che riproduce il formato chat completions di BroadNet e restituisce chiamate agli strumenti. Abbiamo controllato le richieste registrate. Ogni chiamata è arrivata a `/v1/chat/completions` con l’ID del modello `broadnet/glm-5.3` invariato, una chiave Bearer e lo schema dello strumento, e il risultato dello strumento è tornato come messaggio `tool`. Non avevamo una chiave BroadNet, quindi non abbiamo testato l’output reale dei modelli.

## Risoluzione dei problemi

-   **401.** La chiave è sbagliata, scaduta o ha esaurito la quota.
-   **404.** `base_url` deve finire con `/v1`. Controlla l’ID del modello, con il prefisso `broadnet/`. I modelli a pagamento richiedono una ricarica; il credito di $5 copre solo `broadnet/gemma-4-26b-a4b` e i due modelli Transcribe.
-   **L’agente non chiama mai uno strumento.** Passa a `broadnet/glm-5.3` o `broadnet/qwen3.8-27b`.
-   **Risposte vuote.** Il budget di output è andato nel ragionamento. Alza `max_tokens`. [Perché le risposte arrivano vuote](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/).
-   **429.** Una chiave a consumo consente 30 richieste al minuto. Aggiungi `max_retries` a `ChatOpenAI` e vedi [errori e retry](https://broadrouter.com/it/guides/errors-and-retries/).

## Termini in questa guida

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

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

[Streaming](https://broadrouter.com/it/glossary/streaming/)

Lo streaming è un modo di restituire la risposta di un modello linguistico in piccoli pezzi mentre viene ancora generata, invece che in un’unica risposta alla fine. Le API compatibili con OpenAI trasmettono in streaming tramite server-sent event quando la richiesta imposta stream a true.

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

[Base URL (URL di base)](https://broadrouter.com/it/glossary/base-url/)

La base URL è l’indirizzo radice fisso di un’API, come https://api.example.com/v1, che un client antepone a ogni percorso di endpoint, come /chat/completions. Negli SDK compatibili con OpenAI, cambiare la base URL, insieme alla chiave API e all’ID del modello, punta lo stesso codice verso un altro provider.

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

[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

### LangGraph ha bisogno di un’integrazione BroadNet dedicata?

No. LangGraph esegue qualunque chat model chiamino i tuoi nodi. Usa ChatOpenAI di LangChain con base\_url impostato su https://inference.broadnet.ai/v1, e ogni nodo che chiama il modello va a BroadNet tramite chat completions.

### Meglio create\_react\_agent o create\_agent?

In LangGraph 1.2, create\_react\_agent di langgraph.prebuilt funziona ancora, ma stampa un avviso di deprecazione che rimanda a create\_agent del pacchetto langchain. Entrambi hanno funzionato con il nostro mock server e un ID di modello in stile BroadNet.

### Quale modello BroadNet deve usare un agente LangGraph?

GLM 5.3 (broadnet/glm-5.3) o Qwen3.8 27B (broadnet/qwen3.8-27b). Il ciclo di un agente dipende dalle chiamate agli strumenti, e BroadNet indica gli strumenti solo per questi due modelli.

### Perché il max\_tokens che imposto viene inviato come max\_completion\_tokens?

langchain-openai 1.8 rinomina max\_tokens in max\_completion\_tokens nella richiesta. Il riferimento API di BroadNet descrive max\_tokens. Se un limite di output sembra ignorato, controlla la richiesta che la tua app invia davvero.

## Guide correlate

-   [Usare LangChain con BroadNet Inference](https://broadrouter.com/it/guides/langchain-openai-base-url/)
-   [Usare l’OpenAI Agents SDK con BroadNet Inference](https://broadrouter.com/it/guides/openai-agents-sdk-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-langgraph-openai-compatible&utm_content=page-cta) ·

**Fonti**

-   [Documentazione di LangGraph, Quickstart e Graph API (verificata il 2026-11-15)](https://docs.langchain.com/oss/python/langgraph/graph-api)
-   [Documentazione di LangChain, integrazione ChatOpenAI (verificata il 2026-11-15)](https://docs.langchain.com/oss/python/integrations/chat/openai)
-   [PyPI, langgraph 1.2.22 (verificato il 2026-11-15)](https://pypi.org/project/langgraph/)
-   [Riferimento API di BroadNet Inference (verificato il 2026-11-15) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-guides-langgraph-openai-compatible&utm_content=sources)
