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

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

Installation:

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

Ein Minimalbeispiel — ein Agent über Gonka. PydanticAI definiert einen benutzerdefinierten 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-ihr-schluessel",
    ),
)

agent = Agent(model)

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

Das ist alles — Ihr PydanticAI-Agent läuft über das dezentrale Gonka-Netzwerk zu Cent-Beträgen. Die Methode run_sync ist praktisch für Skripte; für async-Code gibt es await agent.run(...).

Modellparameter: Das Kontextfenster der Netzwerkmodelle beträgt 200K Token (200000), 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 außerdem moonshotai/Kimi-K2.6 und MiniMaxAI/MiniMax-M2.7 (jeweils bis zu 8192 Ausgabe-Token) — ändern Sie einfach den Modellnamen im ersten Argument von OpenAIChatModel.

Der Hauptgrund für PydanticAI ist structured output. Anstatt Antworttexte mit Regex zu parsen, beschreiben Sie das Ergebnis als Pydantic-Modell und übergeben es an den output_type Parameter. Das Framework nutzt das Tool Calling des Modells, um Daten streng nach Schema zurückzugeben, validiert diese 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-schluessel",
    ),
)


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


agent = Agent(model, output_type=Profile)

result = agent.run_sync(
    "Daten extrahieren: 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 list[str], kein Text

Dies funktioniert, weil beide Gonka-Modelle (Kimi K2.6 und MiniMax M2.7) natives Tool Calling unterstützen — PydanticAI verlässt sich darauf, um eine valide JSON-Struktur zurückzugeben. Als Ergebnis erhalten Sie ein typisiertes Python-Objekt und keinen String, der manuell geparst werden muss. Ideal für Datenextraktion, Klassifizierung, Formularausfüllung und RAG-Pipelines, bei denen das Ergebnis streng formatiert weiterverarbeitet werden muss.

PydanticAI ist ein Framework für Agenten und Pipelines, die ununterbrochen arbeiten: Daten extrahieren, Tools aufrufen, Anfrageströme verarbeiten. Hier entscheiden die Token-Kosten darüber, ob ein Projekt ein Prototyp bleibt oder in die Produktion geht. Vergleichen wir typische Lastszenarien:

Der Unterschied beträgt das Hundert- bis Tausendfache. Für einen Prototyp bedeutet dies, dass 10M kostenlose Token für Hunderte von Agenten-Durchläufen ausreichen. Für die Produktion, die Hunderttausende von Anfragen pro Tag verarbeitet, beträgt die Ersparnis Zehntausende von Dollar pro Monat — bei gleichem Code auf PydanticAI, einfach mit einem anderen base_url.

Ein jg-xxx Schlüssel 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 Endpoint aus.

Die zweite Schlüsselfunktion von PydanticAI sind Tools. Eine Funktion kann mit dem Decorator @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, erhält das Ergebnis und setzt das Reasoning 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-Ihr-Schlüssel",
    ),
)

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


@agent.tool_plain
def roll_dice() -> str:
    """Würfelt mit einem 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 bei Gonka ca. $0.00007 gegenüber $0.04–0.22 bei OpenAI/Anthropic.

Welches Modell wählen?: moonshotai/Kimi-K2.6 — stark bei Coding und komplexem Reasoning, Output bis 8192. MiniMaxAI/MiniMax-M2.7 — für lange Dialoge und ausgewogene Aufgaben, Output bis 8192. Beide sind sofort mit einem Schlüssel verfügbar — es wird lediglich der Modellname geändert. Ähnliche Tools: LangChain für Chains und RAG, LlamaIndex für die Datenindizierung.