មេរៀន Pydantic AI៖ ការបង្កើត LLM Agent ប្រកបដោយសុវត្ថិភាពប្រភេទប្រភេទ (Type Safety) ចាប់ពីកម្មវិធីដំបូងរហូតដល់ដាក់ឱ្យដំណើរការ

០៣កិច្ច៖ មូលហេតុដែលលទ្ធផលឆ្លើយតបរបស់ Model មិនដូចគ្នាម្ដងៗ

ប្រសិនបើអ្នកធ្លាប់ភ្ជាប់ API របស់ LLM នោះអ្នកប្រហែលជាคุ้นเคย (ស្គាល់ច្បាស់) នឹងរូបភាពនេះហើយ៖ អ្នកបញ្ជា Model ថា «សូមສົ່ງលទ្ធផលមកវិញជាទម្រង់ JSON ដែលមាន name និង score» ប្រាំបดដំបូងដំណើរការបានល្អ ប៉ុន្តែដល់លើកទីដប់ វាបែរជាថែមប្រយោគមួយថា «បាទ/ចាស ខាងក្រោមនេះគឺជាលទ្ធផល៖» នៅពីមុខ JSON នោះ ហើយកូដ json.loads() របស់អ្នកក៏ដាច់ខ្យល់ស្លាប់នៅទីនោះតែម្ដង។ ពេលនោះ អ្នកក៏ចាប់ផ្តើមសរសេរ Regular Expression ជាច្រើនដើម្បីលាងសម្អាត String បន្ថែម និងសរសេរពាក្យ if ជាច្រើនដើម្បីពិនិត្យមើលថាតើ Field នោះមានឬអត់ - ជាចុងក្រោយ កូដសម្រាប់ «កម្មវិធី AI» របស់អ្នក ៧០% គឺដោះស្រាយជាមួយលទ្ធផលដែលមិនទៀងទាត់របស់ Model។

ខ្ញុំផ្ទាល់ធ្លាប់ថែទាំប្រេវ៉ឺសបញ្ចូនប្រភេទ (Classification Service) ផ្ទៃក្នុងមួយ ដែលគ្រាន់តែដោះស្រាយបញ្ហា Model ជួនកាលខ្វះ Field ណាមួយនោះ បានធ្វើឱ្យខ្ញុំត្រូវធ្វើការថែមម៉ោង៣ថ្ងៃ។ ក្រោយមក ពេលប្តូរមកប្រើ Pydantic AI កូដការពារទាំងនោះត្រូវបានលុបចោលស្ទើរតែទាំងស្រុង ព្រោះកិច្ចការ Validation (ការផ្ទៀងផ្ទាត់ទិន្នន័យ) គឺ Framework នេះជួយទទួលខុសត្រូវជំនួសអ្នកផ្ទាល់។ អត្ថបទនេះនឹងពន្យល់លម្អិតអំពីរបៀបប្រើប្រាស់វា។

Pydantic AI ជាអ្វី?

Pydantic AI គឺជា Agent Framework របស់ Python ដែលបង្កើតឡើងដោយក្រុមការងារ Pydantic។ អ្នកប្រហែលជាធ្លាប់ឮឈ្មោះ Pydantic នៅកន្លែងផ្សេងទៀត - SDK ផ្លូវការរបស់ OpenAI, Anthropic, Google ក៏ដូចជា LangChain និង LlamaIndex ការផ្ទៀងផ្ទាត់ទិន្នន័យនៅជាន់ក្រោម (Underlying) គឺច្រើនតែពឹងផ្អែកលើវា។ និយាយម្យ៉ាងទៀត ក្នុងការធ្វើ Validation ពួកគេគឺជាអ្នកដែលមានសិទ្ធិអំណាចបំផុតក្នុងប្រព័ន្ធអេកូឡូស៊ីនេះ។

ปรัชญา (Philosophy) នៃការរចនារបស់វាគឺស្រដៀងនឹង FastAPI ខ្លាំងណាស់៖ ប្រើប្រាស់ Type Hints ដើមរបស់ Python ដើម្បីកំណត់អាកប្បកិរិຍាឱ្យបានច្បាស់លាស់ ហើយរឿងដែលនៅសល់ប្រគល់ឱ្យ Framework ដោះស្រាយ។ គោលគំនិតស្នូលមានត្រឹមតែប៉ុន្មានប៉ុណ្ណោះ - Agent, Tools, Dependencies (ការចាក់បញ្ចូលការពឹងផ្អែក), Structured Output (លទ្ធផលដែលមានโครงสร้าง)។ អ្នកមិនចាំបាច់ទន្ទេញចាំ Abstract Class ជាច្រើនដែលវាបង្កើតឡើងដោយខ្លួនឯងនោះទេ ការសរសេរគឺដូចជា Python ធម្មតា ប៉ុន្តែ IDE នឹងផ្តល់ការបំពេញកូដដោយស្វ័យប្រវត្តិ (Auto-complete) ហើយ Type Checker (ដូចជា Pyright, mypy) អាចចាប់កំហុសមុនពេលអ្នករត់កូដទៅទៀត។

វាជា Model-agnostic មានន័យថាវាមិនผูกขาดជាមួយក្រុមហ៊ុន Model ណាមួយឡើយ។ OpenAI, Anthropic, Google, Groq, Cohere, Mistral, Ollama និងក្រុមហ៊ុនផ្សេងៗទៀតជាងដប់ត្រូវបានគាំទ្រ ការប្តូរ Model គឺគ្រាន់តែប្តូរ String មួយប៉ុណ្ណោះ។ ដើម្បីស្វែងយល់ពីភាពខុសគ្នារវាង Agent និងការហៅ API ធម្មតា អ្នកអាចអាន តើ AI Agent ជាអ្វី? ជាមុនសិន។

អាចយកទៅប្រើប្រាស់ធ្វើអ្វីបានខ្លះ?

និយាយឱ្យចំទៅ គ្រប់កាលៈទេសៈទាំងអស់ដែល «ត្រូវការលទ្ធផលដែលអាចទុកចិត្តបានពី Model» គឺសុទ្ធតែសាកសមទាំងអស់៖

• ការទាញយកទិន្នន័យដែលមានโครงสร้าง (Structured Extraction)៖ បញ្ចូលសំបុត្រប្តឹងតវ៉ារបស់អតិថិជនទៅក្នុងនោះ រួចបញ្ជាឱ្យវាထုတ်មកនូវ Field អារម្មណ៍ (Sentiment) ប្រភេទ (Category) ភាពបន្ទាន់ (Urgency) ហើយធានាថាប្រភេទិន្នន័យ (Type) គឺត្រឹមត្រូវ។
• ការចាត់ថ្នាក់ និងដាក់ស្លាក (Classification and Labeling)៖ เอกสารចំនួនច្រើនត្រូវដាក់ស្លាក ដែលលទ្ធផលត្រូវបានកំណត់ត្រឹម Enum ដែលអ្នកបានកំណត់ Model ដែលឆ្លើយតបផ្ដេសផ្ដាសនឹងត្រូវបដិសេធ។
• Agent បែបឧបករណ៍ (Tool-use Agent)៖ អនុញ្ញាតឱ្យ Model អាចហៅមុខងាររបស់អ្នកបាន - ស្វែងរកទិន្នន័យក្នុង Database, ហៅ Weather API, គណនាលេខ ដោយ Framework ជាអ្នកទទួលខុសត្រូវក្នុងការបម្លែង Type របស់ Function ទៅជាការពិពណ៌នាឧបករណ៍ដែល Model អាចយល់បាន។
• សំណួរចម្លើយ RAG (RAG Q&A)៖ រួមផ្សំជាមួយនឹង Vector Search ដើម្បីបង្កើតប្រព័ន្ធសំណួរចម្លើយដែលមានមូលដ្ឋានច្បាស់លាស់ ផ្នែកនេះអាចយោងតាម មគ្គុទ្ទេសក៍អនុវត្ត RAG របស់យើងបាន។

បើប្រៀបធៀបទៅនឹង Framework ធំៗដែលខ្ចប់គ្រប់យ៉ាងដូចជា LangChain នោះ Pydantic AI ត្រូវបានរចនាឡើងយ៉ាងស្តើងដោយចេតនា។ ប្រសិនបើអ្នកគ្រាន់តែចង់ធ្វើឱ្យលទ្ធផលរបស់ Model កាន់តែអាចទុកចិត្តបាន និងមិនចង់ទន្ទេញប្រព័ន្ធអេកូឡូស៊ីទាំងមូលសម្រាប់មុខងារតូចមួយនោះ ខ្សែកោងនៃការរៀនសូត្រ (Learning Curve) របស់มันនឹងងាយស្រួលជាងច្រើន។

របៀបប្រើប្រាស់៖ ការចាប់ផ្តើមដំបូង

1. ការដំឡើង (Installation)

bash
pip install pydantic-ai

សូមណែនាំឱ្យបើក Virtual Environment មួយ។ កំណែ (Version) Python គួរតែប្រើ 3.9 ឡើងទៅទើបមានសុវត្ថិភាពជាង។

2. ការកំណត់ API Key

ឧទាហរណ៍ដូចជា Anthropic សូមកំណត់ Environment Variable៖

bash
export ANTHROPIC_API_KEY=គ្រាប់ចុចរបស់អ្នក

ប្រសិនបើប្រើ OpenAI សូមកំណត់ OPENAI_API_KEY ហើយបន្តបន្ទាប់ទៀត។

3. សរសេរ Agent ដំបូង

python
from pydantic_ai import Agent

agent = Agent('anthropic:claude-sonnet-4-6')
result = agent.run_sync('용ប្រយោគមួយដើម្បីពន្យល់ពីអ្វីជា Vector Database')
print(result.output)

ប៉ារ៉ាម៉ែត្រទីមួយគឺឈ្មោះ Model ដែលមានទម្រង់ ក្រុមហ៊ុនផលិត:Model។ ប្រសិនបើចង់ប្តូរទៅ OpenAI សូមប្តូរទៅ 'openai:gpt-4o' ជាដើម កូដផ្សេងទៀតមិនចាំបាច់ប្តូរទេ - នេះគឺជាអត្ថប្រយោជន៍នៃ Model-agnostic។

4. ធ្វើឱ្យលទ្ធផលមានโครงสร้าง (Structured Output)

នេះគឺជាចំណុចសំខាន់។ អ្នកកំណត់ Pydantic Model មួយជាទម្រង់លទ្ធផល៖

python
from pydantic import BaseModel
from pydantic_ai import Agent

class Review(BaseModel):
sentiment: str # positive / negative / neutral
score: int # ១ ដល់ ៥
summary: str

agent = Agent('anthropic:claude-sonnet-4-6', output_type=Review)
result = agent.run_sync('ម្ហូបនៅហាងនេះឆ្ងាញ់ ប៉ុន្តែចាំជិតមួយម៉ោង ច្រើនពេកហើយ')
print(result.output.score) # ទទួលបានចំនួនគត់ (Integer) ដោយផ្ទាល់ មិនបាច់ parse ដោយខ្លួនឯងទេ
print(result.output.sentiment) # ទទួលបាន String ដោយផ្ទាល់

ប្រសិនបើអ្វីដែល Model ផ្ញើមកមិនត្រូវគ្នានឹង Type របស់ Review ទេ Framework នឹងផ្ញើសារកំហុសត្រឡប់ទៅ Model វិញដោយស្វ័យប្រវត្តិដើម្បីឱ្យវាព្យាយាមម្តងទៀត។ នៅពេលដែលអ្នកទទួលបាន result.output វាគឺជា Python Object ដែលត្រូវបានផ្ទៀងផ្ទាត់រួចជាស្រេច ហើយ IDE ក៏នឹងជួយបំពេញ Field ឱ្យអ្នកផងដែរ។

5. ផ្តល់ឧបករណ៍ (Tool) ដល់ Agent

python
from pydantic_ai import Agent

agent = Agent('anthropic:claude-sonnet-4-6')

@agent.tool_plain
def get_weather(city: str) -> str:
"""ស្វែងរកអាកាសធាតុបច្ចុប្បន្ននៃទីក្រុងដែលបានកំណត់"""
return f'{city} ពេលនេះ ២៨ អង្សារ មានពន្លឺថ្ងៃ'

result = agent.run_sync('តើអាកាសធាតុនៅទីក្រុងតៃប៉ិពេលនេះយ៉ាងម៉េចដែរ?')
print(result.output)

Docstring នោះមិនមែនសរសេរឡើងដើម្បីតែមើលស្អាតនោះទេ - វាจะกลายเป็น คำอธิบายเครื่องมือที่โมเดลมองเห็น។ Type Hint របស់ Function (city: str) ក៏ត្រូវបានបម្លែងទៅជា Specs របស់ប៉ារ៉ាម៉ែត្រដែល Model អាចយល់បាន ហើយប៉ារ៉ាម៉ែត្រក៏ត្រូវបាន Validation តាមរយៈ Pydantic ផងដែរ។

បច្ចេកទេសកម្រិតខ្ពស់

Dependency Injection (ការបញ្ចូលការពឹងផ្អែក) គឺជាមុខងារដែលត្រូវបានវាយតម្លៃទាបបំផុតរបស់វា។ អ្នកអាចប្រើប្រាស់ RunContext ដើម្បីបញ្ជូនការតភ្ជាប់ Database, អត្តសញ្ញាណអ្នកប្រើប្រាស់ និង API client ទៅក្នុង Agent និង Tools ប្រកបដោយសុវត្ថិភាព Type៖

python
from dataclasses import dataclass
from pydantic_ai import Agent, RunContext

@dataclass
class Deps:
user_id: int
db: object # ការតភ្ជាប់ Database ของคุณ

agent = Agent('anthropic:claude-sonnet-4-6', deps_type=Deps)

@agent.tool
def get_orders(ctx: RunContext[Deps]) -> str:
return f'ស្វែងរកការបញ្ជាទិញរបស់អ្នកប្រើប្រាស់ {ctx.deps.user_id}'

ពេលសរសេរ Unit Test គឺគ្រាន់តែប្តូរ db ទៅជា Object ក្លែងក្លាយ (Mock Object) ដោយមិនចាំបាច់ប៉ះ Database ពិតប្រាកដនោះឡើយ ដែលនេះមានសារៈសំខាន់ខ្លាំងណាស់សម្រាប់ការសរសេរ Unit Test។

Streaming (ការបញ្ជូនទិន្នន័យជាបន្តបន្ទាប់)៖ ដើម្បីធ្វើបែបផែនพิมพ์ดีดแบบเรียลไทม์ សូមប្រើ agent.run_stream() វាจะทำการตรวจสอบโครงสร้างผลลัพธ์ในขณะที่สร้าง ทำให้ประสบการณ์ของผู้ใช้ดีขึ้นมาก။

Observability (ភាពអាចយល់បាននៃប្រព័ន្ធ)៖ Pydantic AI រួមបញ្ចូលគ្នាอย่างราบรื่นกับ Logfire ซึ่งเป็นทีมเดียวกัน។ បន្ទាប់ពីភ្ជាប់រួច រាល់ការហៅ Model នីមួយៗ រាល់ការកេះ Tool នីមួយៗ ចំណាយ Token អស់ប៉ុន្មាន និងចំណាយពេលប៉ុន្មានវិនាទី គឺអាចមើលឃើញទាំងអស់។ បញ្ហាដែលពិបាកបំផុតក្នុងការ Debug សម្រាប់កម្មវិធី LLM គឺ «ហេតុអ្វីបានជា Model ឆ្លើយតបបែបនេះ» ដោយមានមុខងារនេះ អ្នកលែងចាំបាច់ស្មានទៀតហើយ។ ប្រសិនបើអ្នកចង់រៀបចំផែនការ Agent ឱ្យកាន់តែពេញលេញ សូមអាន មគ្គុទ្ទេសក៍អភិវឌ្ឍន៍ AI Agent របស់យើងរួមគ្នា។

កំហុសទូໄປ និងចំណុចត្រូវប្រុងប្រយ័ត្ន

• គិតថាការបន្ថែម output_type គឺមានសុវត្ថិភាព ១០០%៖ Framework នឹងស្នើសុំឱ្យ Model ព្យាយាមម្តងទៀតនៅពេលដែល Validation បរាជ័យ ប៉ុន្តែការลองใหม่มีขีดจำกัด។ ប្រសិនបើវាបរាជ័យជាបន្តបន្ទាប់ វានឹងបោះ Exception ហើយអ្នកនៅតែត្រូវ try/except ដដែល។ Type Validation កាត់បន្ថយ «ទិន្នន័យខូចដែលជ្រៀតចូលប្រព័ន្ធ» មិនមែន «Model មិនធ្លាប់ខុសទាល់តែសោះ» នោះទេ។
• សរសេរ Docstring របស់ Tool របៀបចៃដន្យ៖ Model ពឹងផ្អែកទាំងស្រុងលើ Docstring ដើម្បី判断ថាពេលណាត្រូវហៅ Tool។ ប្រសិនបើវាសរសេរមិនច្បាស់ Model នឹងហៅវាផ្ដេសផ្ដាស ឬមិនហៅទាល់តែសោះ។ សូមចាត់ទុកវាជាសៀវភៅណែនាំអ្នកប្រើប្រាស់ដែលសរសេរឡើងសម្រាប់ Model មើល។
• ដាក់ Logic ច្រើនពេកក្នុង Tool ប៉ុន្តែមិនដោះស្រាយ Exception៖ កូដក្នុង Tool មានកំហុស សារនឹងត្រូវផ្ញើត្រឡប់ទៅ Model វិញ ដែលធ្វើឱ្យ Model អាចវិលវល់ជុំវិញកំហុសនោះ និងដុតបំផ្លាញ Token អស់ជាច្រើន។ កំហុសដែលគួររារាំង គឺត្រូវសរសេរកូដទប់ដោយខ្លួនឯងឱ្យបានល្អ។
• មិនអើពើនឹងថ្លៃដើម (Cost)៖ ការลองใหม่ຂອງ Structured Output, ການเรียก Tool หลายรอบ ការប្រើប្រាស់ Token គឺលឿនជាងអ្វីដែលអ្នកគិត។ មុនពេលដាក់ដំណើរការ (Go live) ត្រូវតែភ្ជាប់ Observability ដើម្បីមើលឱ្យច្បាស់អំពីថ្លៃដើមពិតប្រាកដ។
• ប្រើវាជា Framework ធំ៖ វាត្រូវបានរចនាឡើងយ៉ាងស្តើងដោយចេតនា។ ប្រសិនបើអ្នកត្រូវការການจัดระเบียบหลายขั้นตอนที่ซับซ้อน (Complex Multi-step Orchestration) ឬ Connector ที่มีอยู่มากมาย อาจจะ LlamaIndex ឬដំណោះស្រាយផ្សេងទៀតងាយស្រួលជាង មិនបាច់បង្ខំប្រើវាទេ។

ការវាយតម្លៃពី TheAI學院

និយាយតាមត្រង់ ទីផ្សារមាន Agent Framework ច្រើនហួសហេតុរហូតដល់ធ្វើឱ្យមានការពិបាកក្នុងការជ្រើសរើស ប៉ុន្តែ Pydantic AI ដោះស្រាយបញ្ហាដ៏ជាក់លាក់មួយ ដែលអ្នកអភិវឌ្ឍន៍ LLM គ្រប់រូបធ្លាប់ជួបប្រទះ៖ លទ្ធផលមិនអាចទុកចិត្តได้។ ມັນមិនបានพยายามធ្វើเป็น «Framework ที่แข็งแกร่งที่สุดในจักรวาล» នោះទេ វាគ្រាន់តែយក «Type Safety» ដែលសហគមន៍ Python យកចិត្តទុកដាក់ស្រាប់ មកដាក់ចូលក្នុងការអភិវឌ្ឍ AI យ៉ាងသေသេច។ សម្រាប់អ្នកដែលធ្លាប់ស្គាល់វិធីសាស្ត្រសរសេររបស់ FastAPI និង Pydantic គឺแทบจะไม่มีต้นทุนในการเรียนรู้เลย।

វានឹងមិនធ្វើឱ្យ Model របស់អ្នកកាន់តែឆ្លាតវៃនោះទេ ប៉ុន្តែវាจะทำให้โค้ดของคุณมีความน่าเชื่อถือมากขึ้น—และสิ่งหลังนี้ต่างหากที่เป็นสิ่งที่จะช่วยคุณได้อย่างแท้จริงหลังจากนำไปใช้งานจริง (Go Live)។

ប្រសិនបើអ្នកគ្រាន់តែធ្វើ Demo ឬលេងកម្សាន្ត អ្នកอาจจะไม่ค่อยមានអារម្មណ៍ច្បាស់នោះទេ ប៉ុន្តែរាល់ពេលដែលប្រព័ន្ធរបស់អ្នកត្រូវដាក់ដំណើរការจริง ត្រូវគេប្រើប្រាស់ និងត្រូវថែទាំរយៈពេលវែង តម្លៃនៃ Type Safety និង Observability នឹងកាន់តែលេចធ្លោឡើងរាល់ថ្ងៃ។

ប្រភពទិន្នន័យ

• ឯកសារផ្លូវការរបស់ Pydantic AI
• Pydantic AI GitHub