---
title: "LangGraph com base_url compatível com a OpenAI | BroadRouter"
description: "Rode um StateGraph ou create_agent do LangGraph na BroadNet Inference com ChatOpenAI, base_url e um ID de modelo da BroadNet, com ferramentas, streaming e memória."
url: https://broadrouter.com/pt/guides/langgraph-openai-compatible/
lang: pt-BR
updated: 2026-11-16
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/guides/langgraph-openai-compatible/) (atualizado em 2026-11-16).

# Criar agentes LangGraph na BroadNet Inference

Atualizado em 2026-11-16

Instale langgraph e langchain-openai e crie o ChatOpenAI com model definido como um ID da BroadNet, como broadnet/glm-5.3, base\_url como https://inference.broadnet.ai/v1 e api\_key com a sua chave da BroadNet. Vincule as ferramentas e use-o em um nó de um StateGraph, ou passe-o para o create\_agent do langchain. Use GLM 5.3 ou Qwen3.8 27B, os modelos que a BroadNet lista com ferramentas.

O LangGraph é a biblioteca do LangChain para agentes com estado e em várias etapas, montados como grafos. Ele não tem cliente de modelo próprio: os seus nós chamam um chat model do LangChain. Para rodar um grafo na BroadNet Inference, passe para ele o `ChatOpenAI` do `langchain-openai` com o base URL da BroadNet. O BroadRouter é o site da própria BroadNet; este guia segue a documentação do LangGraph e do LangChain nas versões LangGraph 1.2.22 e langchain-openai 1.8.

## Instalação

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

## Um grafo com chamada de ferramentas

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

O nó do modelo chama a BroadNet. O `tools_condition` manda o grafo para o nó de ferramentas quando a resposta traz chamadas de ferramenta, e o resultado da ferramenta volta para o modelo. O checkpointer guarda a conversa por `thread_id`, então um segundo `invoke` com a mesma config continua a conversa.

## Streaming de tokens do 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)
```

Com `stream_mode="messages"`, o `ChatOpenAI` envia `stream: true` para a BroadNet e o LangGraph repassa os tokens.

## O agente pronto (prebuilt)

Se você não precisa de um grafo personalizado, o loop de agente pronto aceita o mesmo modelo:

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

O `create_react_agent` de `langgraph.prebuilt` ainda roda no LangGraph 1.2.22, mas mostra um aviso de que foi movido para `langchain.agents.create_agent`.

## Qual modelo escolher

| Grafo | Modelo |
| --- | --- |
| Agentes com ferramentas, saída estruturada | `broadnet/glm-5.3` (contexto de 1.048.576 tokens) |
| Ferramentas com entrada de imagem ou texto em árabe | `broadnet/qwen3.8-27b` (contexto de 262.144 tokens) |
| Grafos sem chamadas de ferramenta, documentos longos | `broadnet/deepseek-v4.1-flash` |

A documentação da BroadNet lista ferramentas e saída estruturada só para o GLM 5.3 e o Qwen3.8 27B. O DeepSeek V4.1 Flash é o modelo dos [planos ilimitados](https://broadrouter.com/pt/guides/unlimited-llm-api-sessions/), então serve para grafos de resumo e roteamento que não chamam ferramentas. Teste um loop com ferramentas nele antes de depender disso. [Preços de todos os modelos](https://broadrouter.com/pt/pricing/).

## Configurações que importam

-   **Fique em chat completions.** A BroadNet serve `/v1/chat/completions`. A documentação do LangChain diz que o `ChatOpenAI` passa para a Responses API quando você usa ferramentas nativas da OpenAI, estado de conversa ou o parâmetro `reasoning`. Deixe isso de fora e não defina `use_responses_api=True`.
-   **Limite de saída.** No DeepSeek V4.1 Flash, no GLM 5.3 e no Qwen3.8 27B, o raciocínio conta para o orçamento de saída. Defina `max_tokens` como 2.000 ou mais no modelo. No nosso teste, o langchain-openai 1.8 enviou esse valor como `max_completion_tokens`.
-   **Ramos paralelos.** Cada ramo que chama o modelo é uma requisição separada. Uma chave de pagamento por uso permite 4 requisições em andamento, e uma sessão de plano roda uma de cada vez.

## Como testamos

Em 2026-11-15 instalamos o langgraph 1.2.22, o langchain-openai 1.8.0 e o langchain 1.5.0 em um ambiente virtual limpo. Rodamos o grafo acima, o loop de streaming e o `create_agent` contra um servidor mock local que imita o formato de chat completions da BroadNet e devolve chamadas de ferramenta. Conferimos as requisições registradas. Todas as chamadas foram para `/v1/chat/completions` com o ID do modelo `broadnet/glm-5.3` sem alteração, uma chave Bearer e o schema da ferramenta, e o resultado da ferramenta voltou como mensagem `tool`. Não tínhamos uma chave da BroadNet, então não testamos a saída real dos modelos.

## Solução de problemas

-   **401.** A chave está errada, expirou ou ficou sem cota.
-   **404.** O `base_url` precisa terminar em `/v1`. Confira o ID do modelo, com o prefixo `broadnet/`. Modelos pagos exigem uma recarga; o crédito de $5 cobre só `broadnet/gemma-4-26b-a4b` e os dois modelos Transcribe.
-   **O agente nunca chama uma ferramenta.** Troque para `broadnet/glm-5.3` ou `broadnet/qwen3.8-27b`.
-   **Respostas vazias.** O orçamento de saída foi todo para o raciocínio. Aumente `max_tokens`. [Por que as respostas vêm vazias](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/).
-   **429.** Uma chave de pagamento por uso permite 30 requisições por minuto. Adicione `max_retries` ao `ChatOpenAI` e veja [erros e novas tentativas](https://broadrouter.com/pt/guides/errors-and-retries/).

## Termos neste guia

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

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

[Tool calling (chamada de ferramentas)](https://broadrouter.com/pt/glossary/tool-calling/)

Tool calling, também chamado de function calling ou chamada de ferramentas, é um recurso de APIs de LLM em que o modelo devolve um pedido estruturado para executar uma função definida pelo desenvolvedor, com argumentos JSON. A aplicação executa a função e devolve o resultado; o modelo nunca executa código sozinho.

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

Streaming é uma forma de devolver a resposta de um modelo de linguagem em pequenos pedaços enquanto ela ainda está sendo gerada, em vez de uma resposta única no final. APIs compatíveis com a OpenAI fazem streaming via server-sent events quando a requisição define stream como true.

[Pagamento por uso (pay-as-you-go)](https://broadrouter.com/pt/glossary/pay-as-you-go/)

Pagamento por uso é um modelo de preço em que você paga só pelo que usa, medido por unidade, como tokens, requisições ou minutos de áudio, sem assinatura nem compromisso mínimo. A maioria das APIs de LLM cobra assim, a partir de um saldo pré-pago ou de uma fatura periódica.

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

A base URL é o endereço raiz fixo de uma API, como https://api.example.com/v1, que um cliente coloca antes de cada caminho de endpoint, como /chat/completions. Nos SDKs compatíveis com a OpenAI, trocar a base URL, junto com a chave de API e o ID do modelo, aponta o mesmo código para outro provedor.

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

A Chat Completions API é o endpoint HTTP da OpenAI, POST /v1/chat/completions, que recebe o nome de um modelo e uma lista de mensagens marcadas com papéis e devolve a próxima mensagem do modelo. O formato da requisição e da resposta virou o padrão comum que provedores e SDKs compatíveis com a OpenAI reutilizam.

[Concorrência (concurrency)](https://broadrouter.com/pt/glossary/concurrency/)

Concorrência é o número de requisições que um cliente tem em andamento ao mesmo tempo. APIs de LLM muitas vezes a limitam por chave ou por plano, separadamente das requisições por minuto, porque cada requisição aberta ocupa capacidade de GPU até a resposta terminar.

[Rate limit (limite de taxa)](https://broadrouter.com/pt/glossary/rate-limit/)

Um rate limit é um teto que uma API impõe a quanto um cliente pode usá-la em um intervalo de tempo, como requisições por minuto ou tokens por minuto. As requisições acima do limite são recusadas, normalmente com HTTP 429 Too Many Requests, até que o uso volte a ficar abaixo dele.

## Perguntas frequentes

### O LangGraph precisa de uma integração própria com a BroadNet?

Não. O LangGraph roda qualquer chat model que os seus nós chamem. Use o ChatOpenAI do LangChain com base\_url definido como https://inference.broadnet.ai/v1, e todo nó que chama o modelo vai para a BroadNet via chat completions.

### Devo usar create\_react\_agent ou create\_agent?

No LangGraph 1.2, o create\_react\_agent de langgraph.prebuilt ainda funciona, mas mostra um aviso de descontinuação que aponta para o create\_agent do pacote langchain. Os dois funcionaram no nosso servidor mock com um ID de modelo no formato da BroadNet.

### Qual modelo da BroadNet um agente LangGraph deve usar?

GLM 5.3 (broadnet/glm-5.3) ou Qwen3.8 27B (broadnet/qwen3.8-27b). O loop de um agente depende de chamadas de ferramenta, e a BroadNet lista ferramentas só para esses dois modelos.

### Por que o max\_tokens que eu defino é enviado como max\_completion\_tokens?

O langchain-openai 1.8 renomeia max\_tokens para max\_completion\_tokens na requisição. A referência da API da BroadNet descreve max\_tokens. Se um limite de saída parecer ignorado, confira a requisição que o seu app realmente envia.

## Guias relacionados

-   [Como usar o LangChain com a BroadNet Inference](https://broadrouter.com/pt/guides/langchain-openai-base-url/)
-   [Rodar o OpenAI Agents SDK na BroadNet Inference](https://broadrouter.com/pt/guides/openai-agents-sdk-custom-provider/)
-   [Por que um modelo de raciocínio devolve uma resposta vazia](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/)
-   [Códigos de erro da BroadNet Inference e quando tentar de novo](https://broadrouter.com/pt/guides/errors-and-retries/)
-   [Todas as ferramentas que funcionam com a BroadNet Inference (em inglês)](https://broadrouter.com/integrations/): SDKs, agentes de programação, interfaces de chat e ferramentas de automação, com as configurações exatas de cada uma

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

[Começar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-guides-langgraph-openai-compatible&utm_content=page-cta) ·

**Fontes**

-   [Documentação do LangGraph, Quickstart e Graph API (conferido em 2026-11-15)](https://docs.langchain.com/oss/python/langgraph/graph-api)
-   [Documentação do LangChain, integração ChatOpenAI (conferido em 2026-11-15)](https://docs.langchain.com/oss/python/integrations/chat/openai)
-   [PyPI, langgraph 1.2.22 (conferido em 2026-11-15)](https://pypi.org/project/langgraph/)
-   [Referência da API da BroadNet Inference (conferido em 2026-11-15) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-guides-langgraph-openai-compatible&utm_content=sources)
