BroadRouter
Inizia

Creare agenti LangGraph su BroadNet Inference

Aggiornato

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

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

Un grafo con tool calling

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

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:

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

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.
  • 429. Una chiave a consumo consente 30 richieste al minuto. Aggiungi max_retries a ChatOpenAI e vedi errori e retry.

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.

Leggi in MarkdownChiedi a ChatGPTChiedi a ClaudeChiedi a Perplexity