PydanticAI + Gonka — Typed AI Agents sa Maliit na Halaga

Kunin muna ang key: magrehistro sa gate.joingonka.ai/register — may 3M libreng token sa pag-sign up — at gumawa ng jg-xxx key sa Dashboard → API Keys.

Pag-install:

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

Minimal na halimbawa — agent sa pamamagitan ng Gonka. Nagtatakda ang PydanticAI ng custom endpoint gamit ang 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-your-key",
    ),
)

agent = Agent(model)

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

Iyon lang — tumatakbo na ang PydanticAI agent mo sa decentralized na network ng Gonka nang napakamura. Ang run_sync ay mainam para sa mga script; para sa async na code, may await agent.run(...).

Mga parameter ng modelo: ang context window ng MiniMax M2.7 ay 180K token (180000), ang DeepSeek V4 Flash ay 380K, ang GLM-5.3 Flash ay 390K; ang max na haba ng sagot sa Gateway ay hanggang 8192 token sa MiniMax at GLM-5.3 Flash, hanggang 32768 sa DeepSeek. Maaari mong limitahan ang output sa settings ng modelo (OpenAIChatModelSettings(max_tokens=8192)). Available ang MiniMaxAI/MiniMax-M2.7, deepseek-ai/DeepSeek-V4-Flash-0731, at zai-org/GLM-5.3-Flash — palitan lang ang pangalan ng modelo sa unang argumento ng OpenAIChatModel.

Ang pangunahing dahilan para piliin ang PydanticAI ay ang structured output. Sa halip na i-parse ang text ng sagot gamit ang regex, ilalarawan mo ang resulta bilang Pydantic model at ipapasa ito sa output_type parameter. Ginagamit ng framework ang tool calling ng modelo para pilitin itong magbalik ng data ayon sa schema, bini-validate ito, at ibinibigay ang ready na object sa 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

Gumagana ito dahil ang tatlong modelo ng Gonka (MiniMax M2.7, DeepSeek V4 Flash, at GLM-5.3 Flash) ay sumusuporta sa native tool calling — umaasa ang PydanticAI dito para makapagbalik ng valid na JSON structure. Ang nakukuha mo ay typed na Python object, hindi string na kailangan pang i-parse nang manu-mano. Perpekto para sa data extraction, classification, form filling, at RAG pipeline, kung saan kailangang dumaan ang resulta sa code sa strict na format.

Ang PydanticAI ay isang framework para sa mga agent at pipeline na tumatakbo nang tuloy-tuloy: kumukuha ng data, gumagamit ng mga tool, at nagpoproseso ng mga request stream. Dito, ang presyo ng tokens ang nagtatakda kung ang proyekto ay mananatiling prototype o tutuloy sa production. Ihambing natin ang mga tipikal na load:

Ang pagkakaiba ay nasa daan-daan at libu-libong beses. Para sa prototype, ibig sabihin nito na ang 3M libreng tokens ay sapat na para sa unang mga run ng agent. Para sa production na nagpoproseso ng daan-daang libong request bawat araw, ang matitipid ay umaabot sa sampu-sampung libong dolyar kada buwan — gamit ang parehong code sa PydanticAI, pero may ibang base_url.

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

Ang pangalawang pangunahing feature ng PydanticAI ay ang mga tool. Maaari mong i-register ang isang function gamit ang @agent.tool_plain decorator (walang context) o @agent.tool (may access sa RunContext at dependency injection). Ang modelo mismo ang magdedesisyon kung kailan tatawagin ang tool, tatanggapin ang resulta, at magpapatuloy sa pag-iisip:

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)

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

Aling modelo ang pipiliin: MiniMaxAI/MiniMax-M2.7 — para sa mahahabang usapan at balanseng gawain, output hanggang 8192. deepseek-ai/DeepSeek-V4-Flash-0731 — isa sa pinakamahabang context sa network (380K) at murang malalaking prompt, output hanggang 32768. zai-org/GLM-5.3-Flash — reasoning model para sa mahirap na pangangatwiran at ang pinakamahabang context sa network (390K), output hanggang 8192; ang pag-iisip ay gumagamit ng bahagi ng max_tokens, kaya itakda ito nang may allowance (mula 600). Available ang tatlo ngayon sa isang key — ang modelo lang na string ang binabago. Mga kaugnay na tool: LangChain para sa chains at RAG, LlamaIndex para sa data indexing.