---
title: "LangGraph mit eigener OpenAI-kompatibler base_url | BroadRouter"
description: "Einen LangGraph-StateGraph oder create_agent auf BroadNet Inference betreiben: ChatOpenAI, base_url und BroadNet-Modell-ID, dazu Tools, Streaming und Memory."
url: https://broadrouter.com/de/guides/langgraph-openai-compatible/
lang: de
updated: 2026-11-16
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Mit KI-Unterstützung aus dem Englischen übersetzt. [Englisches Original lesen](https://broadrouter.com/guides/langgraph-openai-compatible/) (aktualisiert am 2026-11-16).

# LangGraph-Agenten auf BroadNet Inference bauen

Aktualisiert 2026-11-16

Installieren Sie langgraph und langchain-openai und erstellen Sie ChatOpenAI mit model auf einer BroadNet-ID wie broadnet/glm-5.3, base\_url auf https://inference.broadnet.ai/v1 und api\_key mit Ihrem BroadNet-Schlüssel. Binden Sie Ihre Tools daran und nutzen Sie das Modell in einem StateGraph-Node oder übergeben Sie es an create\_agent aus langchain. Nehmen Sie GLM 5.3 oder Qwen3.8 27B, die Modelle, für die BroadNet Tools nennt.

LangGraph ist LangChains Bibliothek für zustandsbehaftete, mehrstufige Agenten, die als Graphen aufgebaut sind. Einen eigenen Modell-Client hat es nicht: Ihre Nodes rufen ein Chat-Modell von LangChain auf. Um einen Graphen auf BroadNet Inference laufen zu lassen, geben Sie ihm `ChatOpenAI` aus `langchain-openai` mit der Basis-URL von BroadNet. BroadRouter ist die Website von BroadNet selbst; die Anleitung folgt der Dokumentation von LangGraph und LangChain zum Stand von LangGraph 1.2.22 und langchain-openai 1.8.

## Installation

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

## Ein Graph mit Tool-Calls

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

Der Model-Node ruft BroadNet auf. `tools_condition` leitet den Graphen zum Tool-Node, wenn die Antwort Tool-Calls enthält, und das Tool-Ergebnis geht zurück ans Modell. Der Checkpointer speichert die Unterhaltung pro `thread_id`; ein zweites `invoke` mit derselben Config setzt sie also fort.

## Tokens aus dem Graphen streamen

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

Mit `stream_mode="messages"` sendet `ChatOpenAI` `stream: true` an BroadNet, und LangGraph reicht die Tokens durch.

## Der vorgefertigte Agent

Brauchen Sie keinen eigenen Graphen, nimmt die vorgefertigte Agent-Schleife dasselbe Modell:

```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` aus `langgraph.prebuilt` läuft in LangGraph 1.2.22 noch, gibt aber eine Warnung aus, dass es nach `langchain.agents.create_agent` umgezogen ist.

## Welches Modell passt?

| Graph | Modell |
| --- | --- |
| Agenten mit Tools, strukturierte Ausgabe | `broadnet/glm-5.3` (Kontext von 1.048.576 Token) |
| Tools plus Bildeingabe oder arabischer Text | `broadnet/qwen3.8-27b` (Kontext von 262.144 Token) |
| Graphen ohne Tool-Calls, lange Dokumente | `broadnet/deepseek-v4.1-flash` |

Die BroadNet-Dokumentation nennt Tools und strukturierte Ausgabe nur für GLM 5.3 und Qwen3.8 27B. DeepSeek V4.1 Flash ist das Modell der [unbegrenzten Pläne](https://broadrouter.com/de/guides/unlimited-llm-api-sessions/) und eignet sich daher für Graphen, die zusammenfassen und weiterleiten, ohne Tools aufzurufen. Testen Sie eine Tool-Schleife darauf, bevor Sie sich darauf verlassen. [Preise aller Modelle](https://broadrouter.com/de/pricing/).

## Wichtige Einstellungen

-   **Bei Chat Completions bleiben.** BroadNet stellt `/v1/chat/completions` bereit. Laut LangChain-Dokumentation wechselt `ChatOpenAI` zur Responses API, wenn Sie die eingebauten Tools von OpenAI, Conversation State oder den Parameter `reasoning` nutzen. Lassen Sie diese weg und setzen Sie nicht `use_responses_api=True`.
-   **Ausgabelimit.** Bei DeepSeek V4.1 Flash, GLM 5.3 und Qwen3.8 27B zählt das Reasoning zum Ausgabebudget. Setzen Sie `max_tokens` am Modell auf 2.000 oder mehr. In unserem Test hat langchain-openai 1.8 den Wert als `max_completion_tokens` gesendet.
-   **Parallele Zweige.** Jeder Zweig, der das Modell aufruft, ist eine eigene Anfrage. Ein Pay-as-you-go-Schlüssel erlaubt 4 gleichzeitig laufende Anfragen, und eine Plan-Session verarbeitet eine nach der anderen.

## So haben wir das getestet

Am 15. November 2026 haben wir langgraph 1.2.22, langchain-openai 1.8.0 und langchain 1.5.0 in einer frischen virtuellen Umgebung installiert. Den Graphen oben, die Streaming-Schleife und `create_agent` haben wir gegen einen lokalen Mock-Server laufen lassen, der das Chat-Completions-Format von BroadNet spricht und Tool-Calls zurückgibt. Die protokollierten Anfragen haben wir geprüft: Jeder Aufruf ging an `/v1/chat/completions`, mit unveränderter Modell-ID `broadnet/glm-5.3`, einem Bearer-Schlüssel und dem Tool-Schema, und das Tool-Ergebnis kam als `tool`\-Nachricht zurück. Wir hatten keinen BroadNet-Schlüssel und haben daher keine echte Modellausgabe getestet.

## Fehlerbehebung

-   **401.** Der Schlüssel ist falsch, abgelaufen oder sein Kontingent aufgebraucht.
-   **404.** `base_url` muss auf `/v1` enden. Prüfen Sie die Modell-ID mit dem Präfix `broadnet/`. Kostenpflichtige Modelle brauchen eine Aufladung; das Guthaben von $5 deckt nur `broadnet/gemma-4-26b-a4b` und die beiden Transcribe-Modelle ab.
-   **Der Agent ruft nie ein Tool auf.** Wechseln Sie zu `broadnet/glm-5.3` oder `broadnet/qwen3.8-27b`.
-   **Leere Antworten.** Das Ausgabebudget ging fürs Reasoning drauf. Erhöhen Sie `max_tokens`. [Warum Antworten leer zurückkommen](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/).
-   **429.** Ein Pay-as-you-go-Schlüssel erlaubt 30 Anfragen pro Minute. Ergänzen Sie `max_retries` an `ChatOpenAI` und lesen Sie [Fehlercodes und Retries](https://broadrouter.com/de/guides/errors-and-retries/).

## Begriffe in dieser Anleitung

[Tool Calling (Function Calling)](https://broadrouter.com/de/glossary/tool-calling/)

Tool Calling, auch Function Calling genannt, ist eine Funktion von LLM-APIs, bei der das Modell eine strukturierte Anfrage zurückgibt, eine vom Entwickler definierte Funktion mit JSON-Argumenten auszuführen. Die Anwendung führt die Funktion aus und sendet das Ergebnis zurück; das Modell selbst führt nie Code aus.

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

Ein Token ist die Texteinheit, die ein Sprachmodell liest und schreibt: ein Wort, ein Wortteil, ein Satzzeichen oder eine Bytefolge, die der Tokenizer des Modells erzeugt. LLM-APIs zählen, begrenzen und berechnen die Nutzung meist in Tokens.

[Pay-as-you-go](https://broadrouter.com/de/glossary/pay-as-you-go/)

Pay-as-you-go ist ein Preismodell, bei dem Sie nur für tatsächliche Nutzung zahlen, gemessen pro Einheit wie Tokens, Anfragen oder Audiominuten, ohne Abonnement oder Mindestabnahme. Die meisten LLM-APIs rechnen so ab, aus einem vorausbezahlten Guthaben oder per regelmäßiger Rechnung.

[Rate Limit (Ratenbegrenzung)](https://broadrouter.com/de/glossary/rate-limit/)

Ein Rate Limit ist eine Obergrenze, die eine API festlegt, wie stark ein Client sie in einem Zeitfenster nutzen darf, etwa Anfragen pro Minute oder Tokens pro Minute. Anfragen über dem Limit werden abgelehnt, meist mit HTTP 429 Too Many Requests, bis die Nutzung wieder darunter liegt.

[Strukturierte Ausgabe (Structured Output)](https://broadrouter.com/de/glossary/structured-output/)

Strukturierte Ausgabe (Structured Output) ist eine Funktion von LLM-APIs, die die Antwort eines Modells auf ein vom Entwickler vorgegebenes Format beschränkt, meist ein JSON Schema, damit Code sie zuverlässig parsen kann. Sie ist strenger als der JSON-Modus, der gültiges JSON garantiert, aber keine bestimmte Struktur.

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

Eine Basis-URL ist die feste Stammadresse einer API, etwa https://api.example.com/v1, die ein Client vor jeden Endpoint-Pfad wie /chat/completions setzt. In OpenAI-kompatiblen SDKs lenkt eine geänderte Basis-URL, zusammen mit API-Schlüssel und Modell-ID, denselben Code zu einem anderen Anbieter.

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

Die Chat Completions API ist der HTTP-Endpoint von OpenAI, POST /v1/chat/completions, der einen Modellnamen und eine Liste von Nachrichten mit Rollen entgegennimmt und die nächste Nachricht des Modells zurückgibt. Ihr Format für Anfrage und Antwort wurde zum gemeinsamen Standard, den OpenAI-kompatible Anbieter und SDKs übernehmen.

[Concurrency (Parallelität)](https://broadrouter.com/de/glossary/concurrency/)

Concurrency (Parallelität) ist die Zahl der Anfragen, die ein Client gleichzeitig offen hat. LLM-APIs begrenzen sie oft pro Schlüssel oder Plan, getrennt von den Anfragen pro Minute, weil jede offene Anfrage GPU-Kapazität belegt, bis ihre Antwort fertig ist.

## Häufige Fragen

### Braucht LangGraph eine eigene BroadNet-Integration?

Nein. LangGraph führt das Chat-Modell aus, das Ihre Nodes aufrufen. Nutzen Sie ChatOpenAI aus LangChain mit base\_url https://inference.broadnet.ai/v1, dann geht jeder Node, der das Modell aufruft, per Chat Completions an BroadNet.

### Soll ich create\_react\_agent oder create\_agent nehmen?

In LangGraph 1.2 funktioniert create\_react\_agent aus langgraph.prebuilt noch, gibt aber eine Deprecation-Warnung aus, die auf create\_agent im Paket langchain verweist. Beide liefen gegen unseren Mock-Server mit einer Modell-ID im BroadNet-Format.

### Welches BroadNet-Modell sollte ein LangGraph-Agent nutzen?

GLM 5.3 (broadnet/glm-5.3) oder Qwen3.8 27B (broadnet/qwen3.8-27b). Eine Agent-Schleife hängt von Tool-Calls ab, und BroadNet nennt Tools nur für diese beiden Modelle.

### Warum wird mein max\_tokens als max\_completion\_tokens gesendet?

langchain-openai 1.8 benennt max\_tokens in der Anfrage in max\_completion\_tokens um. Die API-Referenz von BroadNet beschreibt max\_tokens. Scheint ein Ausgabelimit ignoriert zu werden, prüfen Sie die Anfrage, die Ihre App tatsächlich sendet.

## Verwandte Anleitungen

-   [LangChain mit BroadNet Inference nutzen](https://broadrouter.com/de/guides/langchain-openai-base-url/)
-   [OpenAI Agents SDK mit BroadNet Inference betreiben](https://broadrouter.com/de/guides/openai-agents-sdk-custom-provider/)
-   [Warum ein Reasoning-Modell eine leere Antwort liefert](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/)
-   [Fehlercodes von BroadNet Inference: Wann ist ein Retry sinnvoll?](https://broadrouter.com/de/guides/errors-and-retries/)
-   [Alle Tools, die mit BroadNet Inference funktionieren (auf Englisch)](https://broadrouter.com/integrations/): SDKs, Coding-Agenten, Chat-Oberflächen und Automatisierungstools, jeweils mit den genauen Einstellungen

Testen Sie es mit Ihrem echten Workload. Neue Konten starten mit USD 5 Guthaben für Gemma und Transkription. DeepSeek, GLM und Qwen3.8 erfordern eine Aufladung.

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

**Quellen**

-   [LangGraph-Dokumentation, Quickstart und Graph API (geprüft am 2026-11-15)](https://docs.langchain.com/oss/python/langgraph/graph-api)
-   [LangChain-Dokumentation, ChatOpenAI-Integration (geprüft am 2026-11-15)](https://docs.langchain.com/oss/python/integrations/chat/openai)
-   [PyPI, langgraph 1.2.22 (geprüft am 2026-11-15)](https://pypi.org/project/langgraph/)
-   [API-Referenz von BroadNet Inference (geprüft am 2026-11-15) (auf Englisch)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-guides-langgraph-openai-compatible&utm_content=sources)
