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

Holen Sie sich zuerst einen Schlüssel: Registrieren Sie sich auf gate.joingonka.ai/register — bei der Registrierung erhalten Sie 3M kostenlose Tokens — und erstellen Sie einen jg-xxx Schlüssel unter Dashboard → API Keys.

Installation:

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

Ein Minimalbeispiel — ein Agent via Gonka. PydanticAI setzt einen benutzerdefinierten Endpunkt über OpenAIProvider(base_url=..., api_key=...), 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(
    "MiniMaxAI/MiniMax-M2.7",
    provider=OpenAIProvider(
        base_url="https://gate.joingonka.ai/v1",
        api_key="jg-ihr-key",
    ),
)

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 läuft über das dezentrale Gonka-Netzwerk zu extrem niedrigen Kosten. Die Methode run_sync ist bequem für Skripte; für async-Code gibt es await agent.run(...).

Modellparameter: Das Kontextfenster von MiniMax M2.7 beträgt 200K Tokens (200000), bei DeepSeek V4 Flash 380K, bei GLM-5.3 Flash 390K; die maximale Antwortlänge über das Gateway beträgt bis zu 8192 Tokens bei MiniMax und GLM-5.3 Flash, bis zu 32768 bei DeepSeek. Die Ausgabe kann über die Modelleinstellungen (OpenAIChatModelSettings(max_tokens=8192)) begrenzt werden. Verfügbar sind MiniMaxAI/MiniMax-M2.7, deepseek-ai/DeepSeek-V4-Flash-0731 und zai-org/GLM-5.3-Flash — ändern Sie einfach den Modellnamen im ersten Argument von OpenAIChatModel.

Der Hauptgrund, sich für PydanticAI zu entscheiden, ist der structured output. Anstatt den Antworttext mit Regex zu parsen, beschreiben Sie das Ergebnis als Pydantic-Modell und übergeben es an den Parameter output_type. Das Framework nutzt die Tool-Calling-Fähigkeiten des Modells, um es zu zwingen, Daten strikt nach Schema zurückzugeben, validiert sie und liefert 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(
    "MiniMaxAI/MiniMax-M2.7",
    provider=OpenAIProvider(
        base_url="https://gate.joingonka.ai/v1",
        api_key="jg-ihr-key",
    ),
)


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


agent = Agent(model, output_type=Profile)

result = agent.run_sync(
    "Extrahiere Daten: Anna ist Backend-Entwicklerin, kennt Python, Go und Postgres"
)
print(result.output)
# name='Anna' role='Backend-Entwicklerin' skills=['Python', 'Go', 'Postgres']
print(result.output.skills)  # ['Python', 'Go', 'Postgres'] — bereits ein list[str], kein Text

Das funktioniert, weil alle drei Gonka-Modelle (MiniMax M2.7, DeepSeek V4 Flash und GLM-5.3 Flash) natives Tool Calling unterstützen — PydanticAI stützt sich darauf, um eine valide JSON-Struktur zurückzugeben. Als Ergebnis erhalten Sie ein typisiertes Python-Objekt anstelle eines Strings, der manuell zerlegt werden müsste. Ideal für Datenextraktion, Klassifizierung, Formularausfüllung und RAG-Pipelines, bei denen das Ergebnis streng formatiert im Code weiterverarbeitet werden muss.

PydanticAI ist ein Framework für Agenten und Pipelines, die kontinuierlich laufen: Daten extrahieren, Tools aufrufen, Anfrageströme verarbeiten. Hier entscheidet die Kostenstruktur der Token darüber, ob ein Projekt ein Prototyp bleibt oder in die Produktion geht. Vergleichen wir typische Auslastungen:

Der Unterschied beträgt das Hundert- bis Tausendfache. Für einen Prototypen bedeutet dies, dass die 3M kostenlosen Token für die ersten Durchläufe des Agenten ausreichen. Für die Produktion, die Hunderttausende von Anfragen pro Tag verarbeitet, beträgt die Einsparung zehntausende Dollar pro Monat — bei gleichem PydanticAI-Code, nur mit einer anderen base_url.

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

Die zweite Schlüsselfunktion 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 es ein Tool aufruft, empfängt das Ergebnis und setzt die Schlussfolgerung fort:

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

model = OpenAIChatModel(
    "MiniMaxAI/MiniMax-M2.7",
    provider=OpenAIProvider(
        base_url="https://gate.joingonka.ai/v1",
        api_key="jg-ваш-ключ",
    ),
)

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


@agent.tool_plain
def roll_dice() -> str:
    """Würfelt 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("Würfle und multipliziere das Ergebnis mit 7")
print(result.output)

Da das Tool Calling bei Gonka nativ ist, werden Tools zuverlässig aufgerufen – ohne fehleranfälliges Parsen von Textantworten. Der gesamte Zyklus (Anfrage → Tool-Aufruf → finale Antwort) kostet über Gonka etwa $0.00007 gegenüber $0.04–0.22 bei OpenAI/Anthropic.

Welches Modell wählen: MiniMaxAI/MiniMax-M2.7 – für lange Dialoge und ausbalancierte Aufgaben, Ausgabe bis 8192. deepseek-ai/DeepSeek-V4-Flash-0731 – eines der längsten Kontexte im Netzwerk (380K) und günstige große Prompts, Ausgabe bis 32768. zai-org/GLM-5.3-Flash – Reasoning-Modell für komplexe Schlussfolgerungen und der längste Kontext im Netzwerk (390K), Ausgabe bis 8192; Schlussfolgerungen verbrauchen einen Teil von max_tokens, setzen Sie diesen daher großzügig (ab 600). Alle drei sind sofort mit einem Schlüssel verfügbar – nur der Modell-String ändert sich. Ähnliche Tools: LangChain für Ketten und RAG, LlamaIndex für Datenindizierung.