---
title: "Pydantic AI mit eigener OpenAI-kompatibler base_url | BroadRouter"
description: "Pydantic-AI-Agents mit OpenAIChatModel und OpenAICompatibleProvider auf BroadNet Inference betreiben: Tool Calls, strukturierte Ausgabe, Model Profiles."
url: https://broadrouter.com/de/guides/pydantic-ai-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/pydantic-ai-openai-compatible/) (aktualisiert am 2026-11-16).

# Pydantic AI mit BroadNet Inference nutzen (OpenAICompatibleProvider)

Aktualisiert 2026-11-16

Installieren Sie pydantic-ai-slim\[openai\] und bauen Sie OpenAIChatModel mit einer BroadNet-Modell-ID wie broadnet/glm-5.3 und einem OpenAICompatibleProvider mit der Basis-URL https://inference.broadnet.ai/v1 und Ihrem BroadNet-Schlüssel als API-Key. Übergeben Sie das Modell an Agent. Nehmen Sie OpenAIChatModel, nicht das Responses-Modell, denn BroadNet bietet Chat Completions. Laut Pydantic-AI-Dokumentation ist OpenAIProvider mit base\_url für OpenAI selbst gedacht.

Pydantic AI ist ein Python-Agent-Framework des Pydantic-Teams. Für einen Dienst, für den es keinen eingebauten Provider hat, empfiehlt seine Dokumentation `OpenAICompatibleProvider` mit der `base_url` des Dienstes. BroadNet Inference bietet Standard-Chat-Completions unter `https://inference.broadnet.ai/v1`, also ist das der richtige Weg. BroadRouter ist die eigene Website von BroadNet; diese Anleitung folgt der Dokumentation von Pydantic AI mit Stand von Version 2.68.

## Installieren

```bash
pip install "pydantic-ai-slim[openai]"
export BROADNET_API_KEY='your-broadnet-key'
```

## Verbinden

```python
import os
from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIChatModel
from pydantic_ai.providers.openai_compatible import OpenAICompatibleProvider

model = OpenAIChatModel(
    'broadnet/glm-5.3',
    provider=OpenAICompatibleProvider(
        'broadnet',
        base_url='https://inference.broadnet.ai/v1',
        api_key=os.environ['BROADNET_API_KEY'],
    ),
)

agent = Agent(model)
result = agent.run_sync('Give me three names for a Go linting tool.')
print(result.output)
```

Das Ausführen ist der Test: Eine ausgegebene Antwort bedeutet, dass Schlüssel, URL und Modell-ID stimmen.

-   **Das erste Argument ist die Modell-ID**, die an BroadNet geht. Verwenden Sie sie exakt, mit dem Präfix `broadnet/`.
-   **Der Provider-Name** (hier `'broadnet'`) wird bei jeder Antwort gespeichert. Laut Dokumentation von Pydantic AI sollte er stabil bleiben, weil er bestimmt, welche Daten aus früheren Antworten an den Dienst zurückgeschickt werden.
-   **Bleiben Sie bei `OpenAIChatModel`.** Laut Dokumentation von Pydantic AI sollten Sie `OpenAIResponsesModel` nur nutzen, wenn der Dienst die Responses API implementiert. BroadNet listet sie nicht.

## Tools und strukturierte Ausgabe

```python
from pydantic import BaseModel

class City(BaseModel):
    name: str
    country: str

agent = Agent(model, output_type=City)
print(agent.run_sync('Which city hosts the Burj Khalifa?').output)
```

Nehmen Sie `broadnet/glm-5.3` oder `broadnet/qwen3.8-27b` für Tools und strukturierte Ausgabe; die Dokumentation von BroadNet listet beide Funktionen nur für diese zwei Modelle.

## Wann Sie ein Model Profile setzen sollten

Pydantic AI wählt ein Request-Profil anhand des Modellnamens. Wird eine Funktion ignoriert oder abgelehnt, empfiehlt seine Dokumentation, ein eigenes `OpenAIModelProfile` zu übergeben. Zwei Einstellungen sind für BroadNet wissenswert:

```python
from pydantic_ai.profiles.openai import OpenAIModelProfile

model = OpenAIChatModel(
    'broadnet/glm-5.3',
    provider=OpenAICompatibleProvider('broadnet', base_url='https://inference.broadnet.ai/v1', api_key=os.environ['BROADNET_API_KEY']),
    profile=OpenAIModelProfile(
        openai_chat_supports_max_completion_tokens=False,  # send max_tokens, the field BroadNet documents
        openai_supports_strict_tool_definition=False,      # only if strict tool schemas are rejected
    ),
)
```

Übergeben Sie das Ausgabelimit über die Model Settings, zum Beispiel `agent.run_sync(prompt, model_settings={'max_tokens': 2000})`. Bei DeepSeek V4.1 Flash, GLM 5.3 und Qwen3.8 27B zählt Reasoning dazu.

## Welches Modell passt

| Agent | Modell |
| --- | --- |
| Tools, strukturierte Ausgabe | `broadnet/glm-5.3` |
| Bilder oder arabischer Text, mit Tools | `broadnet/qwen3.8-27b` |
| Lange Dokumente, Flatrate-Plan | `broadnet/deepseek-v4.1-flash` |
| Kostenloses Startguthaben | `broadnet/gemma-4-26b-a4b` (32.768 Token Kontext) |

[Preise aller Modelle](https://broadrouter.com/de/pricing/).

## Fehlerbehebung

-   **401.** Der Schlüssel ist falsch, abgelaufen oder das Kontingent ist aufgebraucht.
-   **404 oder Modell nicht gefunden.** `base_url` muss auf `/v1` enden. Prüfen Sie die Modell-ID. Kostenpflichtige Modelle erfordern eine Aufladung; das Guthaben von $5 deckt nur `broadnet/gemma-4-26b-a4b` und die beiden Transcribe-Modelle ab.
-   **Leere Ausgabe oder eine Schleife aus Validierungs-Retries.** Reasoning hat das Ausgabebudget verbraucht. Erhöhen Sie `max_tokens`. [Warum Antworten leer zurückkommen](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/).
-   **400 bei Tool-Definitionen.** Setzen Sie `openai_supports_strict_tool_definition=False` im Profil und nehmen Sie ein Modell, das BroadNet mit Tools listet.
-   **429, wenn Sie Agents gleichzeitig ausführen.** Ein Pay-as-you-go-Schlüssel erlaubt 30 Anfragen pro Minute und 4 gleichzeitig laufende. Siehe [Fehler 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.

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

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

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

[LLM-Flatrate (Flat-rate LLM plan)](https://broadrouter.com/de/glossary/flat-rate-llm-plan/)

Eine LLM-Flatrate ist ein Plan, der für den Zugang zu einer Sprachmodell-API einen Festpreis pro Zeitraum, etwa pro Monat, berechnet statt pro Token. Solche Pläne begrenzen meist etwas anderes, etwa Parallelität, Geschwindigkeit, Modelle oder Nutzungsfenster. Die Limits zählen also so viel wie der Preis.

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

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

## Häufige Fragen

### Sollte ich für BroadNet OpenAIProvider oder OpenAICompatibleProvider verwenden?

OpenAICompatibleProvider. Laut Dokumentation von Pydantic AI akzeptiert zwar auch OpenAIProvider eine base\_url, er ist aber für OpenAI selbst oder einen transparenten Proxy dorthin gedacht und setzt die Modelle und Funktionen von OpenAI voraus.

### Warum OpenAIChatModel und nicht das Standard-OpenAI-Modell?

Das Standard-OpenAI-Modell von Pydantic AI nutzt die Responses API. BroadNet bietet Chat Completions unter /v1/chat/completions, und genau das ruft OpenAIChatModel auf.

### Funktionieren Tools und strukturierte Ausgabe?

Bei den Modellen, die BroadNet mit Tools und strukturierter Ausgabe listet, GLM 5.3 und Qwen3.8 27B, ja. Für DeepSeek V4.1 Flash listet die Dokumentation von BroadNet keine Tools, testen Sie Agents mit Tools darauf also zuerst.

### Wie verhindere ich, dass Pydantic AI max\_completion\_tokens sendet?

Übergeben Sie profile=OpenAIModelProfile(openai\_chat\_supports\_max\_completion\_tokens=False) an OpenAIChatModel. Pydantic AI sendet dann das ältere Feld max\_tokens, das die API-Referenz von BroadNet beschreibt.

## Verwandte Anleitungen

-   [OpenAI Python SDK mit BroadNet Inference nutzen](https://broadrouter.com/de/guides/openai-python-sdk/)
-   [LangChain mit BroadNet Inference nutzen](https://broadrouter.com/de/guides/langchain-openai-base-url/)
-   [CrewAI mit BroadNet Inference als eigenem OpenAI-Endpoint nutzen](https://broadrouter.com/de/guides/crewai-custom-openai-endpoint/)
-   [Warum ein Reasoning-Modell eine leere Antwort liefert](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/)
-   [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-pydantic-ai-openai-compatible&utm_content=page-cta) ·

**Quellen**

-   [Dokumentation von Pydantic AI, Other compatible APIs (Other endpoints, Model profile) (geprüft am 2026-11-15)](https://pydantic.dev/docs/ai/models/compatible-apis/)
-   [Dokumentation von Pydantic AI, OpenAI-Modelle (geprüft am 2026-11-15)](https://pydantic.dev/docs/ai/models/openai/)
-   [PyPI, pydantic-ai 2.68.0, Python 3.11+ (geprüft am 2026-11-15)](https://pypi.org/project/pydantic-ai/)
-   [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-pydantic-ai-openai-compatible&utm_content=sources)
