PydanticAI + Gonka — Typed AI Agents sa Maliit na Halaga

Una, kumuha ng susi: magparehistro sa gate.joingonka.ai/register — sa pagpaparehistro ay nagbibigay kami ng 10M na libreng token — at lumikha ng key na jg-xxx sa Dashboard → API Keys.

Pag-install:

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

Minimal na halimbawa — isang ahente sa pamamagitan ng Gonka. Nagtatakda ang PydanticAI ng custom na 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(
    "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    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, ano ang PoUW")
print(result.output)

Ito na — ang iyong PydanticAI agent ay gumagana sa pamamagitan ng desentralisadong network ng Gonka sa maliit na halaga. Ang run_sync na paraan ay maginhawa para sa mga script; para sa async code, mayroong await agent.run(...).

Mga Parameter ng Modelo: ang context window ng Qwen3-235B ay 128K token (131072), ang maximum na haba ng tugon sa pamamagitan ng Gateway ay hanggang 8192 token. Maaaring limitahan ang output sa pamamagitan ng mga setting ng modelo (OpenAIChatModelSettings(max_tokens=8192)). Magagamit din ang moonshotai/Kimi-K2.6 (hanggang 3072 output token) at MiniMaxAI/MiniMax-M2.7 (hanggang 4096) — sapat na palitan ang pangalan ng modelo sa unang argumento ng OpenAIChatModel.

Ang pangunahing dahilan upang piliin ang PydanticAI ay ang structured output. Sa halip na mag-parse ng text mula sa sagot gamit ang regular expressions, inilalarawan mo ang resulta bilang isang Pydantic model at ipinapasa ito sa parameter na output_type. Ginagamit ng framework ang tool calling ng modelo upang pilitin itong magbalik ng data na mahigpit ayon sa schema, i-validate ang mga ito, at ibalik 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(
    "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    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(
    "Kuhanin ang data: Si Anna ay isang backend developer, marunong siya sa 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, hindi text

Umuobra ito dahil sinusuportahan ng Qwen3-235B (at ang dalawa pang models ng Gonka) ang native tool calling — umaasa ang PydanticAI dito upang magbalik ng valid JSON structure. Ang resulta ay isang typed Python object, hindi isang string na kailangan mong i-parse nang manu-mano. Ideal para sa data extraction, classification, form filling, at RAG-pipelines, kung saan ang resulta ay dapat lumabas sa structured na format.

Ang PydanticAI ay isang framework para sa mga ahente at pipeline na patuloy na gumagana: nagkuha ng data, tumatawag ng mga tool, nagpoproseso ng mga stream ng kahilingan. Dito, ang halaga ng mga token ang nagpapasya kung ang proyekto ay mananatiling prototype o magpapatuloy sa produksyon. Paghambingin natin ang tipikal na mga workload:

Ang pagkakaiba ay daan-daan at libu-libong beses. Para sa prototype, nangangahulugan ito na ang 10M na libreng token ay sapat na para sa daan-daang pagpapatakbo ng ahente. Para sa produksyon, na nagpoproseso ng daan-daang libong kahilingan bawat araw, ang pagtitipid ay sampu-sampung libong dolyar bawat buwan — na may parehong code sa PydanticAI, na may iba lamang na base_url.

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

Ang pangalawang pangunahing kakayahan ng PydanticAI ay mga tool. Maaaring irehistro ang isang function gamit ang decorator na @agent.tool_plain (walang konteksto) o @agent.tool (na may access sa RunContext at dependency injection). Ang modelo mismo ang nagpapasya kung kailan tatawagan ang tool, nakakakuha ng resulta at nagpapatuloy sa paghuhusga:

import random
from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIChatModel
from pydantic_ai.providers.openai import OpenAIProvider

model = OpenAIChatModel(
    "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    provider=OpenAIProvider(
        base_url="https://gate.joingonka.ai/v1",
        api_key="jg-your-key",
    ),
)

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


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


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


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

Dahil ang tool calling ng Gonka ay native, ang mga tool ay tinatawagan nang mapagkakatiwalaan — nang walang marupok na pag-parse ng mga text na sagot. Ang buong cycle (kahilingan → tool call → pangwakas na sagot) ay nagkakahalaga ng humigit-kumulang $0.00001 sa pamamagitan ng Gonka kumpara sa $0.04–0.22 sa OpenAI/Anthropic.

Anong modelo ang pipiliin: Qwen/Qwen3-235B-A22B-Instruct-2507-FP8 — default, pinakamahusay na balanse ng kalidad at pinakamalaking limitasyon sa output (8192). Ang moonshotai/Kimi-K2.6 ay malakas sa coding at kumplikadong pangangatwiran (output hanggang 3072). Ang MiniMaxAI/MiniMax-M2.7 — para sa mahabang diyalogo (output hanggang 4096). Lahat ng tatlo ay magagamit na ngayon sa iisang key — ang pangalan ng modelo lamang ang nagbabago. Ang mga katulad na tool: LangChain para sa mga chains at RAG, LlamaIndex para sa data indexing.