---
title: "DSPy: dspy.LM mit OpenAI-kompatibler api_base | BroadRouter"
description: "Konfigurieren Sie dspy.LM für BroadNet Inference mit Präfix openai/, api_base und model_type=\"chat\", denn DSPy 3.5 schickt OpenAI-Modelle an die Responses API."
url: https://broadrouter.com/de/guides/dspy-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/dspy-openai-compatible/) (aktualisiert am 2026-11-16).

# DSPy mit BroadNet Inference nutzen (model\_type="chat" setzen)

Aktualisiert 2026-11-16

Erstellen Sie dspy.LM mit dem Modell "openai/broadnet/glm-5.3", model\_type="chat", api\_base https://inference.broadnet.ai/v1 und Ihrem BroadNet-api\_key und übergeben Sie es an dspy.configure. Entscheidend ist model\_type="chat": DSPy 3.5 schickt OpenAI-Modelle standardmäßig an die Responses API, die BroadNet nicht bereitstellt. In unserem Test mit einem Mock-Server ging der Aufruf ohne diese Option an /v1/responses und bekam einen 404, und auch der Live-Endpoint von BroadNet beantwortet diesen Pfad mit 404.

DSPy ist ein Python-Framework, mit dem Sie Sprachmodelle über Signaturen und Module programmieren und die Prompts dahinter optimieren. Mit einem Modell verbinden Sie es über `dspy.LM`. Die DSPy-Dokumentation zeigt OpenAI-kompatible Server als `openai/`\-Modell mit `api_base`. Für BroadNet Inference, das Chat Completions unter `https://inference.broadnet.ai/v1` bereitstellt, brauchen Sie zusätzlich `model_type="chat"`. BroadRouter ist die Website von BroadNet selbst; diese Anleitung folgt der DSPy-Dokumentation für 3.5.

## Installation

```bash
pip install dspy
export BROADNET_API_KEY='your-broadnet-key'
```

## Verbinden

```python
import os
import dspy

lm = dspy.LM(
    "openai/broadnet/glm-5.3",
    model_type="chat",
    api_base="https://inference.broadnet.ai/v1",
    api_key=os.environ["BROADNET_API_KEY"],
    max_tokens=4000,
)
dspy.configure(lm=lm)

qa = dspy.Predict("question -> answer")
print(qa(question="What is the capital of Saudi Arabia?").answer)
```

-   **`openai/`** sagt DSPy, dass es seinen OpenAI-Client nutzen soll. Der Rest des Strings, `broadnet/glm-5.3`, ist die Modell-ID, die an BroadNet geht.
-   **`model_type="chat"`** hält DSPy auf `/v1/chat/completions`. Laut LM-Referenz von DSPy sorgt der Standardwert `'auto'` dafür, dass OpenAI-Modelle „use Responses“ (Übersetzung: „Responses verwenden“).
-   **`max_tokens`** lässt Platz für Reasoning. DeepSeek V4.1 Flash, GLM 5.3 und Qwen3.8 27B denken nach, bevor sie antworten, und das Nachdenken zählt zum Limit.

## Was ohne model\_type passiert

Das Beispiel auf der Installationsseite von DSPy für einen OpenAI-kompatiblen Server lässt `model_type` weg. In unserem Test mit DSPy 3.5.0 ging die Anfrage dann mit `max_output_tokens` an `/v1/responses`, und der Aufruf scheiterte:

```text
dspy.utils.exceptions.LMInvalidRequestError: [openai/broadnet/glm-5.3] /v1/responses not served
```

Dieser Fehler kam von unserem Mock-Server. Auch der Live-Endpoint von BroadNet beantwortete `/v1/responses` bei unserer Prüfung am 16. November 2026 mit einem 404. Mit `model_type="chat"` war das Problem behoben.

## Module und Modelle

```python
cot = dspy.ChainOfThought("question -> answer")
print(cot(question="A train leaves at 9:40 and arrives at 13:05. How long is the trip?").answer)
```

| Einsatz in DSPy | Modell |
| --- | --- |
| `Predict`, `ChainOfThought`, Optimizer-Läufe | `broadnet/deepseek-v4.1-flash` (niedriger Preis pro Token; Pauschalpläne) |
| `ReAct` und andere Module mit Tool Calls | `broadnet/glm-5.3` oder `broadnet/qwen3.8-27b` |
| DSPy mit dem Startguthaben ausprobieren | `broadnet/gemma-4-26b-a4b` (Kontext von 32.768 Tokens) |

Die BroadNet-Dokumentation nennt Tools und strukturierte Ausgabe nur für GLM 5.3 und Qwen3.8 27B. Sie können ein Modell für das Programm und ein anderes für einen Optimizer nutzen, jeweils mit eigenem `dspy.LM`. [Preise aller Modelle](https://broadrouter.com/de/pricing/).

## So haben wir das getestet

Am 15. November 2026 haben wir dspy 3.5.0 in einer frischen virtuellen Umgebung installiert und `dspy.Predict` gegen einen lokalen Mock-Server laufen lassen, der das Chat-Completions-Format von BroadNet spricht und `/v1/responses` mit 404 beantwortet. Ohne `model_type` rief DSPy `/v1/responses` auf und scheiterte. Mit `model_type="chat"` rief es `/v1/chat/completions` mit der Modell-ID `broadnet/glm-5.3` und einem Bearer-Schlüssel auf und las das Antwortfeld aus. Dabei haben wir gesehen, dass DSPy das Output-Limit als `max_completion_tokens` sendet. Die API-Referenz von BroadNet beschreibt `max_tokens` und erwähnt `max_completion_tokens` nicht; ob BroadNet ein so gesendetes Limit anwendet, können wir daher nicht bestätigen. Wir haben gegen einen Mock-Server getestet, nicht mit einem BroadNet-Schlüssel, und daher keine echte Modellausgabe geprüft.

## Fehlerbehebung

-   **404 auf /v1/responses.** Ergänzen Sie `model_type="chat"`.
-   **404 auf /v1/chat/completions.** `api_base` muss auf `/v1` enden, und der Modell-String muss `openai/` plus die vollständige BroadNet-ID sein. Kostenpflichtige Modelle brauchen eine Aufladung; das Guthaben von $5 deckt nur `broadnet/gemma-4-26b-a4b` und die beiden Transcribe-Modelle ab.
-   **„Expected to find output fields“.** Die Antwort war leer oder abgeschnitten, oft weil das Reasoning das Output-Budget aufgebraucht hat. Erhöhen Sie `max_tokens`. [Warum Antworten leer zurückkommen](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/).
-   **429 während der Optimierung.** Ein Pay-as-you-go-Schlüssel erlaubt 30 Anfragen pro Minute und 4 gleichzeitig laufende. Senken Sie die Thread-Zahl des Optimizers und lesen Sie [Fehlercodes und Retries](https://broadrouter.com/de/guides/errors-and-retries/).

## Begriffe in dieser Anleitung

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

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

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

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

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

[max\_tokens](https://broadrouter.com/de/glossary/max-tokens/)

max\_tokens ist ein Parameter von LLM-APIs, der festlegt, wie viele Tokens ein Modell in einer Antwort höchstens erzeugen darf. Erreicht die Generierung das Limit, bricht sie ab, und die Antwort wird als abgeschnitten markiert, zum Beispiel mit finish\_reason „length“.

[Prepaid-Guthaben (Prepaid Credit)](https://broadrouter.com/de/glossary/prepaid-credit/)

Prepaid-Guthaben ist Geld, das vor der Nutzung auf ein API-Konto eingezahlt wird. Jede Anfrage zieht ihre Kosten vom Guthaben ab, und wenn es aufgebraucht ist, stoppen abgerechnete Anfragen, bis Sie aufladen. So sind die Ausgaben auf das eingezahlte Geld begrenzt.

## Häufige Fragen

### Warum ruft DSPy bei BroadNet /v1/responses auf?

Laut der Referenz zu dspy.LM in DSPy 3.5 sorgt model\_type 'auto', der Standardwert, dafür, dass OpenAI-Modelle die Responses API nutzen. Ein openai/-Modell mit eigener api\_base wird genauso behandelt. Übergeben Sie model\_type="chat", um Chat Completions zu nutzen, also das, was BroadNet bereitstellt.

### Wie schreibe ich die BroadNet-Modell-ID in DSPy?

Setzen Sie openai/ vor die BroadNet-ID, zum Beispiel openai/broadnet/glm-5.3. DSPy wählt anhand von openai/ den Client und hat in unserem Test broadnet/glm-5.3 als Modell gesendet.

### Welches BroadNet-Modell eignet sich für DSPy-Optimizer?

Optimizer machen viele Aufrufe, daher zählen Kosten und Rate Limits. DeepSeek V4.1 Flash hat einen niedrigen Preis pro Token und ist das Modell der Pauschalpläne von BroadNet, die nicht pro Token abrechnen. Für Module, die Tools aufrufen, etwa ReAct, nutzen Sie GLM 5.3 oder Qwen3.8 27B.

### Spielt der Cache von DSPy bei BroadNet eine Rolle?

DSPy cacht LM-Aufrufe standardmäßig (cache=True), ein wiederholter identischer Aufruf kostet also nichts. Setzen Sie cache=False, während Sie die Verbindung prüfen, sonst sehen Sie womöglich eine gecachte Antwort.

## Verwandte Anleitungen

-   [OpenAI Python SDK mit BroadNet Inference nutzen](https://broadrouter.com/de/guides/openai-python-sdk/)
-   [LiteLLM an BroadNet Inference anbinden (SDK und Proxy)](https://broadrouter.com/de/guides/litellm-proxy-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-dspy-openai-compatible&utm_content=page-cta) ·

**Quellen**

-   [DSPy-Dokumentation, Installation und Einrichtung des Sprachmodells (Seite vom 2026-11-10, geprüft am 2026-11-15)](https://dspy.ai/current/getting-started/installation/)
-   [DSPy-Dokumentation, API-Referenz zu dspy.LM (model\_type) (geprüft am 2026-11-15)](https://dspy.ai/current/api/models/LM/)
-   [PyPI, dspy 3.5.0 (geprüft am 2026-11-15)](https://pypi.org/project/dspy/)
-   [API-Referenz von BroadNet Inference (geprüft am 2026-11-16) (auf Englisch)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-guides-dspy-openai-compatible&utm_content=sources)
