PydanticAI + Gonka — Typed AI Agents sa Maliit na Halaga

Una, kumuha ng key: mag-register sa gate.joingonka.ai/register — sa pag-register, bibigyan ka namin ng 3M libreng tokens — 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 — isang 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-your-key",
    ),
)

agent = Agent(model)

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

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

Model parameters: ang context window ng MiniMax M2.7 ay 200K tokens (200000), sa DeepSeek V4 Flash ay 380K, sa GLM-5.3 Flash ay 390K; ang maximum response length sa pamamagitan ng Gateway ay hanggang 8192 tokens sa MiniMax at GLM-5.3 Flash, hanggang 32768 sa DeepSeek. Maaaring limitahan ang output sa pamamagitan ng mga settings ng model (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 model sa unang argument ng OpenAIChatModel.

Ang pangunahing dahilan para piliin ang PydanticAI ay structured output. Sa halip na i-parse ang text response gamit ang regex, ilalarawan mo ang resulta bilang Pydantic-model at ipapasa 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-your-key",
    ),
)


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


agent = Agent(model, output_type=Profile)

result = agent.run_sync(
    "Kunin ang data: Anna — backend developer, alam ang 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 text

Gumagana ito dahil lahat ng tatlong Gonka models (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. Sa output, makakakuha ka ng typed Python object, hindi string na kailangang i-parse nang manu-mano. Ideal ito 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 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 kakayahan ng PydanticAI ay mga tool. Ang function ay maaaring irehistro gamit ang decorator na @agent.tool_plain (walang context) o @agent.tool (may access sa RunContext at dependency injection). Ang modelo mismo ang nagpapasya kung kailan tatawagin ang tool, makukuha ang resulta, at ipagpapatuloy ang 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-iyong-key",
    ),
)

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


@agent.tool_plain
def roll_dice() -> str:
    """Nagro-roll ng anim na panig na dice at nagbabalik ng resulta."""
    return str(random.randint(1, 6))


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


result = agent.run_sync("Mag-roll ng 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: MiniMaxAI/MiniMax-M2.7 — para sa mahahabang diyalogo 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 kumplikadong pag-iisip at ang pinakamahabang context sa network (390K), output hanggang 8192; ang reasoning ay gumagamit ng bahagi ng max_tokens, itakda ito nang may allowance (mula 600). Lahat ng tatlo ay available ngayon sa iisang key — ang model string lang ang nagbabago. Mga tool na malapit ang konsepto: LangChain para sa mga chain at RAG, LlamaIndex para sa pag-index ng data.