PydanticAI + Gonka – typisierte KI-Agenten für kleines Geld

Besorgen Sie sich zuerst einen Schlüssel: Registrieren Sie sich unter gate.joingonka.ai/register – bei der Registrierung geben wir Ihnen 10 Mio. kostenlose Token – und erstellen Sie einen Schlüssel jg-xxx im Dashboard → API Keys.

Installation:

pip install pydantic-ai
# oder die abgespeckte Version nur mit OpenAI-Abhängigkeiten:
# pip install "pydantic-ai-slim[openai]"

Ein minimales Beispiel – ein Agent über Gonka. PydanticAI legt einen benutzerdefinierten Endpunkt über OpenAIProvider(base_url=..., api_key=...) fest, der an OpenAIChatModel übergeben wird:

from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIChatModel
from pydantic_ai.providers.openai import OpenAIProvider

model = OpenAIChatModel(
    "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    provider=OpenAIProvider(
        base_url="https://gate.joingonka.ai/v1",
        api_key="jg-Ihr-Schlüssel",
    ),
)

agent = Agent(model)

result = agent.run_sync("Erkläre in zwei Sätzen, was PoUW ist")
print(result.output)

Das war's – Ihr PydanticAI-Agent arbeitet über das dezentrale Gonka-Netzwerk für kleines Geld. Die Methode run_sync ist praktisch für Skripte; für Async-Code gibt es await agent.run(...).

Modellparameter: Das Kontextfenster von Qwen3-235B beträgt 128K Token (131072), die maximale Antwortlänge über das Gateway beträgt bis zu 8192 Token. Die Ausgabe kann über die Modelleinstellungen begrenzt werden (OpenAIChatModelSettings(max_tokens=8192)). Verfügbar sind auch moonshotai/Kimi-K2.6 (bis zu 3072 Ausgabetoken) und MiniMaxAI/MiniMax-M2.7 (bis zu 4096) – ändern Sie einfach den Modellnamen im ersten Argument von OpenAIChatModel.

Der Hauptgrund, PydanticAI zu wählen, ist die strukturierte Ausgabe. Anstatt die Antworttext mit regulären Ausdrücken zu parsen, beschreiben Sie das Ergebnis als Pydantic-Modell und übergeben es an den Parameter output_type. Das Framework verwendet den Tool-Aufruf des Modells, um es dazu zu bringen, Daten strikt nach Schema zurückzugeben, validiert diese und gibt dann ein fertiges Objekt über result.output zurück.

from pydantic import BaseModel
from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIChatModel
from pydantic_ai.providers.openai import OpenAIProvider

model = OpenAIChatModel(
    "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    provider=OpenAIProvider(
        base_url="https://gate.joingonka.ai/v1",
        api_key="jg-Ihr-Schlüssel",
    ),
)


class Profile(BaseModel):
    name: str
    role: str
    skills: list[str]


agent = Agent(model, output_type=Profile)

result = agent.run_sync(
    "Extrahieren Sie Daten: Anna ist ein Backend-Entwickler, sie kennt Python, Go und Postgres"
)
print(result.output)
# name='Anna' role='Backend-Entwickler' skills=['Python', 'Go', 'Postgres']
print(result.output.skills)  # ['Python', 'Go', 'Postgres'] – bereits list[str], nicht Text

Dies funktioniert, weil Qwen3-235B (und die beiden anderen Gonka-Modelle) nativen Tool-Calling unterstützen – PydanticAI stützt sich darauf, um eine gültige JSON-Struktur zurückzugeben. Als Ergebnis erhalten Sie ein typisiertes Python-Objekt und keinen String, den Sie manuell parsen müssen. Ideal für Datenextraktion, Klassifizierung, Formularausfüllung und RAG-Pipelines, bei denen das Ergebnis in einem strengen Format weiter im Code verwendet werden muss.

PydanticAI ist ein Framework für Agenten und Pipelines, die kontinuierlich arbeiten: Daten extrahieren, Tools aufrufen, Anfragesequenzen verarbeiten. Hier entscheidet der Tokenpreis, ob ein Projekt ein Prototyp bleibt oder in die Produktion geht. Vergleichen wir typische Lasten:

Der Unterschied beträgt Hunderte oder Tausende von Malen. Für einen Prototypen bedeutet dies, dass 10 Mio. kostenlose Token für Hunderte von Agentenläufen ausreichen. Für die Produktion, die Hunderttausende von Anfragen pro Tag verarbeitet, beträgt die Einsparung Zehntausende von Dollar pro Monat – mit demselben PydanticAI-Code, nur mit einer anderen base_url.

Ein Schlüssel jg-xxx und ein Guthaben funktionieren sowohl für das OpenAI-Format (/v1) als auch für das Anthropic-Format (/v1/messages) – aber für PydanticAI reicht der oben gezeigte OpenAI-kompatible Endpunkt aus.

Die zweite Schlüsselmöglichkeit von PydanticAI sind Tools. Eine Funktion kann mit dem Dekorator @agent.tool_plain (ohne Kontext) oder @agent.tool (mit Zugriff auf RunContext und Dependency Injection) registriert werden. Das Modell entscheidet selbst, wann ein Tool aufgerufen wird, empfängt das Ergebnis und setzt die Argumentation fort:

import random
from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIChatModel
from pydantic_ai.providers.openai import OpenAIProvider

model = OpenAIChatModel(
    "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    provider=OpenAIProvider(
        base_url="https://gate.joingonka.ai/v1",
        api_key="jg-Ihr-Schlüssel",
    ),
)

agent = Agent(
    model,
    instructions="Du bist ein Helfer. Verwende Tools, wenn nötig.",
)


@agent.tool_plain
def roll_dice() -> str:
    """Wirft einen sechsseitigen Würfel und gibt das Ergebnis zurück."""
    return str(random.randint(1, 6))


@agent.tool_plain
def calculator(expression: str) -> str:
    """Berechnet einen mathematischen Ausdruck."""
    return str(eval(expression))


result = agent.run_sync("Wirf einen Würfel und multipliziere das Ergebnis mit 7")
print(result.output)

Da Tool-Aufrufe bei Gonka nativ sind, werden Tools zuverlässig aufgerufen – ohne anfälliges Parsen von Textantworten. Der gesamte Zyklus (Anfrage → Tool-Aufruf → endgültige Antwort) kostet über Gonka etwa 0,00001 $ gegenüber 0,04–0,22 $ bei OpenAI/Anthropic.

Welches Modell wählen: Qwen/Qwen3-235B-A22B-Instruct-2507-FP8 – Standard, bestes Qualitätsgleichgewicht und größtes Ausgabelimit (8192). moonshotai/Kimi-K2.6 ist stark beim Kodieren und komplexen Argumentieren (Ausgabe bis 3072). MiniMaxAI/MiniMax-M2.7 – für lange Dialoge (Ausgabe bis 4096). Alle drei sind derzeit mit einem einzigen Schlüssel verfügbar – nur der Modellstring ändert sich. Ähnliche Tools: LangChain für Ketten und RAG, LlamaIndex für Datenindizierung.