PydanticAI + Gonka — Typed AI Agents sa Maliit na Halaga

Una, kumuha ng key: mag-register sa gate.joingonka.ai/register — nagbibigay kami ng 10M libreng tokens pag-register — at gumawa ng key jg-xxx sa Dashboard → API Keys.

Installation:

pip install pydantic-ai
# o ang slim variant na may OpenAI-dependencies lamang:
# pip install "pydantic-ai-slim[openai]"

Minimal na halimbawa — agent sa pamamagitan ng Gonka. Ang PydanticAI ay nagtatakda ng custom endpoint sa pamamagitan ng OpenAIProvider(base_url=..., api_key=...), na ipinapasa sa OpenAIChatModel:

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

agent = Agent(model)

result = agent.run_sync("Ipaliwanag sa dalawang pangungusap kung ano ang PoUW")
print(result.output)

Iyon lang — ang iyong PydanticAI-agent ay tumatakbo sa pamamagitan ng decentralized network na Gonka sa murang halaga. Ang method na run_sync ay maginhawa para sa mga script; para sa async-code, mayroong await agent.run(...).

Model parameters: ang context window ng mga network model ay 200K tokens (200000), ang maximum response length sa pamamagitan ng Gateway — hanggang 8192 tokens. Maaaring limitahan ang output sa pamamagitan ng settings ng model (OpenAIChatModelSettings(max_tokens=8192)). Available din ang moonshotai/Kimi-K2.6 at MiniMaxAI/MiniMax-M2.7 (hanggang 8192 output tokens bawat isa) — kailangan lang baguhin ang pangalan ng model sa unang argument ng OpenAIChatModel.

Ang pangunahing dahilan para piliin ang PydanticAI ay structured output. Imbes na i-parse ang text response gamit ang regex, inilalarawan mo ang resulta bilang isang Pydantic-model at ipinapasa ito sa parameter na output_type. Ginagamit ng framework ang tool calling ng model para pilitin itong magbalik ng data ayon sa schema, i-validate ito, at ibigay ang handa nang object sa pamamagitan ng 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-iyong-key",
    ),
)


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


agent = Agent(model, output_type=Profile)

result = agent.run_sync(
    "I-extract ang data: Si Anna ay isang backend developer, marunong ng Python, Go at Postgres"
)
print(result.output)
# name='Anna' role='backend developer' skills=['Python', 'Go', 'Postgres']
print(result.output.skills)  # ['Python', 'Go', 'Postgres'] — list[str] na ito, hindi na text

Gumagana ito dahil ang parehong Gonka models (Kimi K2.6 at MiniMax M2.7) ay sumusuporta sa native tool calling — umaasa ang PydanticAI dito para ibalik ang valid JSON-structure. Sa output, makakakuha ka ng typed Python object, hindi simpleng string na kailangang i-parse nang manually. Tamang-tama para sa data extraction, classification, form filling at RAG-pipelines, kung saan ang resulta ay dapat magpatuloy sa code sa isang mahigpit na format.

Ang PydanticAI ay isang framework para sa mga agent at pipeline na tumatakbo nang tuluy-tuloy: pagkuha ng data, pagtawag sa mga tool, pag-proseso ng mga flow ng request. Dito, ang gastos ng tokens ang nagpapasya kung mananatiling prototype ang project o magtutuloy sa production. Ihambing natin ang mga tipikal na workload:

Ang pagkakaiba ay daan-daan at libu-libong beses. Para sa prototype, ibig sabihin nito na ang 10M libreng tokens ay sapat para sa daan-daang run ng agent. Para sa production na nagpoproseso ng daan-daang libong request kada araw, ang pagtitipid ay umaabot sa libu-libong dolyar kada buwan — gamit ang parehong code sa PydanticAI, dahil lang sa ibang base_url.

Isang key na jg-xxx at isang balanse ang gumagana para sa parehong OpenAI-format (/v1) at Anthropic-format (/v1/messages) — ngunit para sa PydanticAI, sapat na ang OpenAI-compatible endpoint na ipinakita sa itaas.

Ang pangalawang pangunahing kakayahan ng PydanticAI ay ang mga tools. Ang function ay maaaring irehistro gamit ang decorator na @agent.tool_plain (walang context) o @agent.tool (na may access sa RunContext at dependency injection). Ang modelo mismo ang nagpapasya kung kailan tatawagin ang tool, natatanggap ang resulta, at ipinagpapatuloy ang pangangatwiran:

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

agent = Agent(
    model,
    instructions="Ikaw ay isang assistant. Gamitin ang mga tool kung kinakailangan.",
)


@agent.tool_plain
def roll_dice() -> str:
    """Nagro-roll ng six-sided dice at ibinabalik ang resulta."""
    return str(random.randint(1, 6))


@agent.tool_plain
def calculator(expression: str) -> str:
    """Nagkalkula ng mathematical expression."""
    return str(eval(expression))


result = agent.run_sync("I-roll ang dice at i-multiply ang resulta sa 7")
print(result.output)

Dahil ang tool calling sa Gonka ay native, ang mga tool ay tinatawag nang maaasahan — nang walang marupok na pag-parse ng mga text response. Ang buong cycle (request → tool call → final response) ay nagkakahalaga ng humigit-kumulang $0.00007 sa pamamagitan ng Gonka kumpara sa $0.04–0.22 sa OpenAI/Anthropic.

Aling modelo ang pipiliin: moonshotai/Kimi-K2.6 — malakas sa coding at mahihirap na pangangatwiran, output hanggang 8192. MiniMaxAI/MiniMax-M2.7 — para sa mahahabang dialogue at balanseng gawain, output hanggang 8192. Parehong available ngayon gamit ang isang key — ang model string lang ang binabago. Mga tool na malapit ang konsepto: LangChain para sa mga chain at RAG, LlamaIndex para sa data indexing.