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

Zuerst den Schlüssel holen: registriere dich auf gate.joingonka.ai/register — bei der Anmeldung gibt es 3M kostenlose Tokens — und erstelle einen jg-xxx-Schlüssel im Dashboard → API Keys.

Installation:

pip install pydantic-ai
# or the slim variant with only the OpenAI dependencies:
# pip install "pydantic-ai-slim[openai]"

Minimales Beispiel — ein Agent über Gonka. PydanticAI setzt einen eigenen Endpoint ü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-your-key",
    ),
)

agent = Agent(model)

result = agent.run_sync("Explain in two sentences what PoUW is")
print(result.output)

Das war's — dein PydanticAI-Agent läuft über das dezentrale Gonka-Netzwerk für ein paar Cent. Die Methode run_sync ist praktisch für Skripte; für Async-Code gibt es await agent.run(...).

Modellparameter: Das Kontextfenster von MiniMax M2.7 umfasst 180K Tokens (180000), das von DeepSeek V4 Flash 380K, das von GLM-5.3 Flash 390K; die maximale Antwortlänge über das Gateway liegt bei bis zu 8192 Tokens bei MiniMax und GLM-5.3 Flash, bis zu 32768 bei DeepSeek. Die Ausgabe lässt sich über die Modelleinstellungen begrenzen (OpenAIChatModelSettings(max_tokens=8192)). Verfügbar sind MiniMaxAI/MiniMax-M2.7, deepseek-ai/DeepSeek-V4-Flash-0731 und zai-org/GLM-5.3-Flash — es genügt, den Modellnamen im ersten Argument von OpenAIChatModel zu ändern.

Der Hauptgrund für PydanticAI ist der strukturierte Output. Statt die Antwort mit regulären Ausdrücken zu parsen, beschreibst du das Ergebnis als Pydantic-Modell und übergibst es an den Parameter output_type. Das Framework nutzt das Tool Calling des Modells, um es zu zwingen, Daten streng nach Schema zurückzugeben, validiert sie und liefert dir ein fertiges Objekt über result.output.

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-your-key",
    ),
)


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


agent = Agent(model, output_type=Profile)

result = agent.run_sync(
    "Extract the data: Anna is a backend developer who knows Python, Go and Postgres"
)
print(result.output)
# name='Anna' role='backend developer' skills=['Python', 'Go', 'Postgres']
print(result.output.skills)  # ['Python', 'Go', 'Postgres'] — already a list[str], not 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 gültige JSON-Struktur zurückzugeben. Am Ende erhältst du ein typisiertes Python-Objekt statt eines Strings, den du manuell zerlegen müsstest. Perfekt für Datenextraktion, Klassifizierung, Formularausfüllung und RAG-Pipelines, bei denen das Ergebnis in einem strikten Format weiter durch den Code fließen 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 lässt sich mit dem Decorator @agent.tool_plain (ohne Kontext) oder @agent.tool (mit Zugriff auf RunContext und Dependency Injection) registrieren. Das Modell entscheidet selbst, wann es das Tool aufruft, erhält das Ergebnis und führt die Überlegung 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-your-key",
    ),
)

agent = Agent(
    model,
    instructions="You are an assistant. Use the tools when needed.",
)


@agent.tool_plain
def roll_dice() -> str:
    """Rolls a six-sided die and returns the result."""
    return str(random.randint(1, 6))


@agent.tool_plain
def calculator(expression: str) -> str:
    """Evaluates a math expression."""
    return str(eval(expression))


result = agent.run_sync("Roll the die and multiply the result by 7")
print(result.output)

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

Welches Modell wählen: MiniMaxAI/MiniMax-M2.7 — für lange Dialoge und ausgewogene Aufgaben, Ausgabe bis 8192. deepseek-ai/DeepSeek-V4-Flash-0731 — einer der längsten Kontexte des Netzwerks (380K) und günstige große Prompts, Ausgabe bis 32768. zai-org/GLM-5.3-Flash — ein Reasoning-Modell für komplexe Überlegungen und der längste Kontext des Netzwerks (390K), Ausgabe bis 8192; Überlegungen verbrauchen einen Teil der max_tokens, also setze diesen mit Puffer an (ab 600). Alle drei sind jetzt mit einem einzigen Schlüssel verfügbar — nur die Modellzeile ändert sich. Verwandte Tools: LangChain für Chains und RAG, LlamaIndex für die Datenindizierung.