पाइडांटिक AI + गोंका - बहुत कम लागत पर टाइप किए गए AI-एजेंट

सबसे पहले एक की (key) प्राप्त करें: gate.joingonka.ai/register पर रजिस्टर करें — रजिस्टर करने पर हम 10M मुफ्त टोकन देते हैं — और डैशबोर्ड → API Keys में jg-xxx की (key) बनाएं।

इंस्टॉलेशन:

pip install pydantic-ai
# या केवल OpenAI निर्भरता के साथ लाइटवेट संस्करण:
# pip install "pydantic-ai-slim[openai]"

एक न्यूनतम उदाहरण — Gonka के माध्यम से एक एजेंट। PydanticAI एक कस्टम एंडपॉइंट को OpenAIProvider(base_url=..., api_key=...) के माध्यम से सेट करता है, जिसे 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-आपकी-की",
    ),
)

agent = Agent(model)

result = agent.run_sync("PoUW क्या है, दो वाक्यों में समझाएं")
print(result.output)

बस इतना ही — आपका PydanticAI एजेंट विकेंद्रीकृत Gonka नेटवर्क के माध्यम से बहुत कम खर्च में काम कर रहा है। run_sync विधि स्क्रिप्ट के लिए सुविधाजनक है; async-कोड के लिए await agent.run(...) है।

मॉडल पैरामीटर्स: नेटवर्क मॉडल का कॉन्टेक्स्ट विंडो 200K टोकन (200000) है, गेटवे के माध्यम से अधिकतम उत्तर लंबाई 8192 टोकन तक है। आउटपुट को मॉडल सेटिंग्स (OpenAIChatModelSettings(max_tokens=8192)) के माध्यम से सीमित किया जा सकता है। moonshotai/Kimi-K2.6 और MiniMaxAI/MiniMax-M2.7 (प्रत्येक 8192 आउटपुट टोकन तक) भी उपलब्ध हैं — बस OpenAIChatModel के पहले तर्क में मॉडल का नाम बदलना पर्याप्त है।

PydanticAI चुनने का मुख्य कारण structured output है। टेक्स्ट रिस्पॉन्स को रेगुलर एक्सप्रेशन (regex) से पार्स करने के बजाय, आप परिणाम को एक Pydantic मॉडल के रूप में वर्णित करते हैं और इसे output_type पैरामीटर में पास करते हैं। फ्रेमवर्क मॉडल के टूल कॉलिंग का उपयोग करके डेटा को सख्ती से स्कीम के अनुसार वापस लाने के लिए मजबूर करता है, उसे वैलिडेट करता है और 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-आपकी-की",
    ),
)


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


agent = Agent(model, output_type=Profile)

result = agent.run_sync(
    "डेटा निकालें: अन्ना — backend-developer, Python, Go और Postgres जानती हैं"
)
print(result.output)
# name='अन्ना' role='backend-developer' skills=['Python', 'Go', 'Postgres']
print(result.output.skills)  # ['Python', 'Go', 'Postgres'] — यह list[str] है, टेक्स्ट नहीं

यह इसलिए काम करता है क्योंकि दोनों Gonka मॉडल (Kimi K2.6 और MiniMax M2.7) नेटिव टूल कॉलिंग का समर्थन करते हैं — PydanticAI एक वैध JSON-स्ट्रक्चर वापस करने के लिए इसका उपयोग करता है। आउटपुट में आपको एक टाइप्ड Python ऑब्जेक्ट मिलता है, न कि कोई स्ट्रिंग जिसे मैन्युअल रूप से संभालना पड़े। यह डेटा निकालने, वर्गीकरण, फ़ॉर्म भरने और RAG-पाइपलाइनों के लिए आदर्श है, जहाँ परिणाम को सख्त प्रारूप में कोड में आगे बढ़ना चाहिए।

PydanticAI उन एजेंटों और पाइपलाइनों के लिए फ्रेमवर्क है जो निरंतर काम करते हैं: डेटा एक्सट्रैक्ट करते हैं, टूल्स को कॉल करते हैं, रिक्वेस्ट स्ट्रीम्स को प्रोसेस करते हैं। यहाँ टोकन्स की लागत ही तय करती है कि प्रोजेक्ट केवल प्रोटोटाइप रहेगा या प्रोडक्शन में जाएगा। आइए सामान्य लोड्स की तुलना करें:

अंतर सैकड़ों और हजारों गुना का है। एक प्रोटोटाइप के लिए, इसका मतलब है कि 10M मुफ्त टोकन एजेंट के सैकड़ों रन के लिए पर्याप्त हैं। प्रोडक्शन के लिए, जो प्रतिदिन लाखों रिक्वेस्ट प्रोसेस करते हैं, बचत प्रति माह हज़ारों डॉलर की होती है — PydanticAI पर कोड वही रहता है, बस base_url बदलना होता है।

एक सिंगल jg-xxx की और एक बैलेंस OpenAI-फॉर्मेट (/v1) और Anthropic-फॉर्मेट (/v1/messages) दोनों के लिए काम करता है — लेकिन PydanticAI के लिए ऊपर दिखाया गया OpenAI-संगत एंडपॉइंट ही काफी है।

PydanticAI की दूसरी प्रमुख क्षमता टूल्स है। किसी फ़ंक्शन को @agent.tool_plain (बिना कॉन्टेक्स्ट) या @agent.tool (RunContext और dependency injection तक एक्सेस के साथ) डेकोरेटर का उपयोग करके रजिस्टर किया जा सकता है। मॉडल स्वयं तय करता है कि टूल को कब कॉल करना है, परिणाम प्राप्त करता है, और तर्क (reasoning) जारी रखता है:

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-आपकी-की",
    ),
)

agent = Agent(
    model,
    instructions="आप एक सहायक हैं। जरूरत पड़ने पर टूल्स का उपयोग करें।",
)


@agent.tool_plain
def roll_dice() -> str:
    """छह तरफा पासा फेंकता है और परिणाम लौटाता है।"""
    return str(random.randint(1, 6))


@agent.tool_plain
def calculator(expression: str) -> str:
    """गणितीय अभिव्यक्ति की गणना करता है।"""
    return str(eval(expression))


result = agent.run_sync("पासा फेंकें और परिणाम को 7 से गुणा करें")
print(result.output)

चूँकि Gonka पर tool calling नेटिव है, इसलिए टूल्स विश्वसनीय रूप से कॉल किए जाते हैं — बिना नाजुक टेक्स्ट रिस्पॉन्स पार्सिंग के। पूरा चक्र (रिक्वेस्ट → टूल कॉल → अंतिम रिस्पॉन्स) Gonka के माध्यम से लगभग $0.00007 खर्च करता है, जबकि OpenAI/Anthropic पर यह $0.04–0.22 है।

कौन सा मॉडल चुनें: moonshotai/Kimi-K2.6 — कोडिंग और जटिल तर्क में मजबूत, आउटपुट 8192 तक। MiniMaxAI/MiniMax-M2.7 — लंबे संवादों और संतुलित कार्यों के लिए, आउटपुट 8192 तक। दोनों एक ही की (key) के साथ अभी उपलब्ध हैं — केवल मॉडल स्ट्रिंग बदलनी होती है। संबंधित टूल्स: LangChain चेन और RAG के लिए, LlamaIndex डेटा इंडेक्सिंग के लिए।