---
title: "LangGraph avec une base_url compatible OpenAI | BroadRouter"
description: "Faites tourner un StateGraph LangGraph ou create_agent sur BroadNet Inference avec ChatOpenAI, base_url et un ID BroadNet, plus outils, streaming et mémoire."
url: https://broadrouter.com/fr/guides/langgraph-openai-compatible/
lang: fr
updated: 2026-11-16
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/guides/langgraph-openai-compatible/) (mis à jour le 2026-11-16).

# Créer des agents LangGraph sur BroadNet Inference

Mis à jour 2026-11-16

Installez langgraph et langchain-openai, puis créez ChatOpenAI avec model réglé sur un ID BroadNet comme broadnet/glm-5.3, base\_url sur https://inference.broadnet.ai/v1 et api\_key sur votre clé BroadNet. Liez-y vos outils et utilisez-le dans un nœud de StateGraph, ou passez-le à create\_agent de langchain. Prenez GLM 5.3 ou Qwen3.8 27B, les modèles pour lesquels BroadNet indique les outils.

LangGraph est la bibliothèque de LangChain pour créer des agents à état, en plusieurs étapes, sous forme de graphes. Elle n’a pas de client de modèle propre : vos nœuds appellent un modèle de chat LangChain. Pour faire tourner un graphe sur BroadNet Inference, donnez-lui le `ChatOpenAI` de `langchain-openai` avec l’URL de base de BroadNet. BroadRouter est le site de BroadNet ; ce guide suit la documentation de LangGraph et de LangChain à la date de LangGraph 1.2.22 et langchain-openai 1.8.

## Installation

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

## Un graphe avec appels d’outils

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

Le nœud du modèle appelle BroadNet. `tools_condition` envoie le graphe vers le nœud d’outils quand la réponse contient des appels d’outils, et le résultat de l’outil revient au modèle. Le checkpointer conserve la conversation par `thread_id` : un second `invoke` avec la même configuration la poursuit donc.

## Streamer les tokens du graphe

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

Avec `stream_mode="messages"`, `ChatOpenAI` envoie `stream: true` à BroadNet et LangGraph transmet les tokens.

## L’agent prêt à l’emploi

Si vous n’avez pas besoin d’un graphe sur mesure, la boucle d’agent prête à l’emploi accepte le même modèle :

```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` de `langgraph.prebuilt` tourne encore dans LangGraph 1.2.22, mais affiche un avertissement indiquant qu’il a été déplacé vers `langchain.agents.create_agent`.

## Quel modèle choisir ?

| Graphe | Modèle |
| --- | --- |
| Agents avec outils, sortie structurée | `broadnet/glm-5.3` (contexte de 1 048 576 tokens) |
| Outils plus entrée image ou texte arabe | `broadnet/qwen3.8-27b` (contexte de 262 144 tokens) |
| Graphes sans appels d’outils, longs documents | `broadnet/deepseek-v4.1-flash` |

La documentation de BroadNet indique les outils et la sortie structurée pour GLM 5.3 et Qwen3.8 27B uniquement. DeepSeek V4.1 Flash est le modèle des [forfaits illimités](https://broadrouter.com/fr/guides/unlimited-llm-api-sessions/) : il convient donc aux graphes qui résument et aiguillent sans appeler d’outils. Testez une boucle d’outils dessus avant de vous y fier. [Les prix de chaque modèle](https://broadrouter.com/fr/pricing/).

## Les réglages qui comptent

-   **Restez sur chat completions.** BroadNet sert `/v1/chat/completions`. D’après la documentation de LangChain, `ChatOpenAI` bascule vers l’API Responses quand vous utilisez les outils intégrés d’OpenAI, l’état de conversation ou le paramètre `reasoning`. Laissez-les de côté et ne réglez pas `use_responses_api=True`.
-   **Limite de sortie.** Sur DeepSeek V4.1 Flash, GLM 5.3 et Qwen3.8 27B, le raisonnement est décompté du budget de sortie. Réglez `max_tokens` sur 2 000 ou plus sur le modèle. Lors de notre test, langchain-openai 1.8 l’a envoyé sous la forme `max_completion_tokens`.
-   **Branches parallèles.** Chaque branche qui appelle le modèle est une requête distincte. Une clé à l’usage autorise 4 requêtes en cours, et une session de forfait les traite une par une.

## Comment nous l’avons testé

Le 15 novembre 2026, nous avons installé langgraph 1.2.22, langchain-openai 1.8.0 et langchain 1.5.0 dans un environnement virtuel vierge. Nous avons exécuté le graphe ci-dessus, la boucle de streaming et `create_agent` face à un serveur fictif local qui parle le format chat completions de BroadNet et renvoie des appels d’outils. Nous avons vérifié les requêtes journalisées. Chaque appel est arrivé sur `/v1/chat/completions` avec l’ID de modèle `broadnet/glm-5.3` inchangé, une clé Bearer et le schéma de l’outil, et le résultat de l’outil est revenu sous forme de message `tool`. Faute de clé BroadNet, nous n’avons pas testé de vraie sortie de modèle.

## Dépannage

-   **401.** La clé est erronée, a expiré ou a épuisé son allocation.
-   **404.** `base_url` doit se terminer par `/v1`. Vérifiez l’ID du modèle, avec le préfixe `broadnet/`. Les modèles payants nécessitent une recharge ; le crédit de $5 ne couvre que `broadnet/gemma-4-26b-a4b` et les deux modèles Transcribe.
-   **L’agent n’appelle jamais d’outil.** Passez à `broadnet/glm-5.3` ou `broadnet/qwen3.8-27b`.
-   **Réponses vides.** Le budget de sortie a été consommé par le raisonnement. Augmentez `max_tokens`. [Pourquoi les réponses reviennent vides](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/).
-   **429.** Une clé à l’usage autorise 30 requêtes par minute. Ajoutez `max_retries` à `ChatOpenAI` et consultez [codes d’erreur et nouvelles tentatives](https://broadrouter.com/fr/guides/errors-and-retries/).

## Termes de ce guide

[Appel d’outils (tool calling, function calling)](https://broadrouter.com/fr/glossary/tool-calling/)

L’appel d’outils, aussi appelé function calling, est une fonctionnalité des API LLM dans laquelle le modèle renvoie une demande structurée d’exécution d’une fonction définie par le développeur, avec des arguments JSON. L’application exécute la fonction et renvoie le résultat ; le modèle n’exécute jamais de code lui-même.

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

Un token est l’unité de texte qu’un modèle de langage lit et écrit : un mot, une partie de mot, un signe de ponctuation ou une suite d’octets produite par le tokenizer du modèle. Les API LLM comptent, limitent et facturent généralement l’usage en tokens.

[Concurrence (requêtes simultanées)](https://broadrouter.com/fr/glossary/concurrency/)

La concurrence est le nombre de requêtes qu’un client a en cours au même moment. Les API de LLM la plafonnent souvent par clé ou par forfait, indépendamment des requêtes par minute, car chaque requête ouverte occupe de la capacité GPU jusqu’à la fin de sa réponse.

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

L’API Chat Completions est l’endpoint HTTP d’OpenAI, POST /v1/chat/completions, qui reçoit un nom de modèle et une liste de messages associés à un rôle, et renvoie le message suivant du modèle. Sa forme de requête et de réponse est devenue le format commun que reprennent les fournisseurs et SDK compatibles OpenAI.

[Limite de débit (rate limit)](https://broadrouter.com/fr/glossary/rate-limit/)

Une limite de débit (rate limit) est un plafond qu’une API impose à l’usage d’un client sur une période, par exemple en requêtes ou en tokens par minute. Les requêtes au-delà sont refusées, généralement avec HTTP 429 Too Many Requests, jusqu’à ce que l’usage repasse sous la limite.

[Paiement à l’usage (pay-as-you-go)](https://broadrouter.com/fr/glossary/pay-as-you-go/)

Le paiement à l’usage (pay-as-you-go) est un modèle tarifaire où vous ne payez que ce que vous consommez, mesuré par unité, comme les tokens, les requêtes ou les minutes d’audio, sans abonnement ni engagement minimal. La plupart des API LLM facturent ainsi, à partir d’un solde prépayé ou d’une facture périodique.

[Sortie structurée (structured output)](https://broadrouter.com/fr/glossary/structured-output/)

La sortie structurée est une fonction des API LLM qui contraint la réponse d’un modèle à un format défini par le développeur, en général un JSON Schema, pour que le code puisse l’analyser de façon fiable. Elle est plus stricte que le mode JSON, qui garantit un JSON valide mais pas une structure précise.

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

Le streaming est une manière de renvoyer la réponse d’un modèle de langage par petits chunks pendant sa génération, plutôt qu’en un seul bloc à la fin. Les API compatibles OpenAI streament via des server-sent events quand la requête règle stream sur true.

## Questions fréquentes

### LangGraph a-t-il besoin d’une intégration BroadNet dédiée ?

Non. LangGraph exécute le modèle de chat qu’appellent vos nœuds. Utilisez le ChatOpenAI de LangChain avec base\_url réglé sur https://inference.broadnet.ai/v1, et chaque nœud qui appelle le modèle passe par BroadNet en chat completions.

### Faut-il utiliser create\_react\_agent ou create\_agent ?

Dans LangGraph 1.2, create\_react\_agent de langgraph.prebuilt fonctionne encore mais affiche un avertissement d’obsolescence qui renvoie vers create\_agent du paquet langchain. Les deux ont fonctionné avec notre serveur fictif et un ID de modèle au format BroadNet.

### Quel modèle BroadNet choisir pour un agent LangGraph ?

GLM 5.3 (broadnet/glm-5.3) ou Qwen3.8 27B (broadnet/qwen3.8-27b). Une boucle d’agent repose sur les appels d’outils, et BroadNet n’indique les outils que pour ces deux modèles.

### Pourquoi le max\_tokens que je règle part-il en max\_completion\_tokens ?

langchain-openai 1.8 renomme max\_tokens en max\_completion\_tokens dans la requête. La référence de l’API de BroadNet décrit max\_tokens. Si une limite de sortie semble ignorée, vérifiez la requête que votre application envoie réellement.

## Guides associés

-   [Utiliser LangChain avec BroadNet Inference](https://broadrouter.com/fr/guides/langchain-openai-base-url/)
-   [Faire tourner l’OpenAI Agents SDK sur BroadNet Inference](https://broadrouter.com/fr/guides/openai-agents-sdk-custom-provider/)
-   [Pourquoi un modèle de raisonnement renvoie une réponse vide](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/)
-   [Codes d’erreur de BroadNet Inference : quand réessayer ?](https://broadrouter.com/fr/guides/errors-and-retries/)
-   [Tous les outils compatibles avec BroadNet Inference (en anglais)](https://broadrouter.com/integrations/) : SDK, agents de code, interfaces de chat et outils d’automatisation, avec les réglages exacts pour chacun

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

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

**Sources**

-   [Documentation de LangGraph, Quickstart et Graph API (consulté le 2026-11-15)](https://docs.langchain.com/oss/python/langgraph/graph-api)
-   [Documentation de LangChain, intégration ChatOpenAI (consulté le 2026-11-15)](https://docs.langchain.com/oss/python/integrations/chat/openai)
-   [PyPI, langgraph 1.2.22 (consulté le 2026-11-15)](https://pypi.org/project/langgraph/)
-   [Référence de l’API de BroadNet Inference (consulté le 2026-11-15) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-guides-langgraph-openai-compatible&utm_content=sources)
