README.md

ស្វែងយល់អំពី Microsoft Agent Framework

ការណែនាំ

មេរៀននេះនឹងគ្របដណ្តប់៖

• ការយល់ដឹងអំពី Microsoft Agent Framework: លក្ខណៈពិសេសសំខាន់ៗ និងតំលៃ
• ស្វែងយល់ពីគំនិតស្នូលនៃ Microsoft Agent Framework
• លំនាញ MAF ជំនាន់ខ្ពស់: Workflows, Middleware, និង Memory

គោលដៅការសិក្សា

បន្ទាប់ពីបញ្ចប់មេរៀននេះ អ្នកនឹងដឹងពីរបៀបដំណើរការ៖

• កសាង AI Agents ដែលអាចប្រើប្រាស់បានក្នុងផលិតកម្មដោយប្រើ Microsoft Agent Framework
• អនុវត្តលក្ខណៈពិសេសសំខាន់ៗនៃ Microsoft Agent Framework ទៅលើករណីប្រើប្រាស់ Agentic របស់អ្នក
• ប្រើលំនាញជំនាន់ខ្ពស់ រួមមាន workflows, middleware, និង observability

ឧទាហរណ៍កូដ

ឧទាហរណ៍កូដសម្រាប់ Microsoft Agent Framework (MAF) អាចរកបាននៅក្នុងឃ្លាំងនេះក្រោមឯកសារ xx-python-agent-framework និង xx-dotnet-agent-framework។

ការយល់ដឹងអំពី Microsoft Agent Framework

Microsoft Agent Framework (MAF) គឺជាគ្រោងបណ្ដុំតែមួយរបស់ Microsoft សម្រាប់សាងសង់ AI agents។ វាប្រាប់សេរីភាពដើម្បីដោះស្រាយករណីប្រើប្រាស់ agentic ផ្សេងៗដែលបានឃើញទាំងក្នុងផលិតកម្ម និងបរិយាកាសស្រាវជ្រាវរួមមាន៖

• ការត្រួតពិនិត្យ Agent ដោយលំដាប់ ក្នុងសេចក្តីលំអិតជំហាន​ដំណើរការ ដែលចាំបាច់ត្រូវការ workflows ជាជំហានៗ។
• ការត្រួតពិនិត្យជាសម័យស្រប ក្នុងសេចក្តីលំអិតដែលត្រូវការឲ្យ agents បញ្ចប់ភារកិច្ចនៅពេលដូចគ្នា។
• ការត្រួតពិនិត្យជាក្រុមជជែក ក្នុងសេចក្តីលំអិត ដែល agents អាចសហការយ៉ាងរួមគ្នាលើភារកិច្ចតែមួយ។
• ការផ្ទេរភារកិច្ច ក្នុងសេចក្តីលំអិតដែល agents ផ្ទេរភារកិច្ចទៅគ្នា ខណៈដែលការងារសេចក្តីរងបានបញ្ចប់។
• ការត្រួតពិនិត្យទាក់ទាញ ក្នុងសេចក្តីលំអិត ដែល agent ទីប្រឹក្សាបានបង្កើតនិងកែប្រែបញ្ជីភារកិច្ច ហើយជួយសម្របសម្រួល subagents ដើម្បីបញ្ចប់ភារកិច្ច។

ដើម្បីបញ្ជូន AI Agents ក្នុងផលិតកម្ម MAF ក៏បានរួមបញ្ចូលលក្ខណៈពិសេសសម្រាប់៖

• ការសង្កេតមើល តាមរយៈការប្រើប្រាស់ OpenTelemetry ដែលសកម្មភាពរបស់ AI Agent រាល់យ៉ាង រួមមានការហៅឧបករណ៍ ដំណើរការត្រួតពិនិត្យ ជំនួញចលនា និងការត្រួតពិនិត្យសមត្ថភាពតាម Microsoft Foundry dashboards។
• សុវត្ថិភាព ដោយផឹក agents ដោយដើរឡើងដោយផ្ទាល់លើ Microsoft Foundry ដែលរួមបញ្ចូលការគ្រប់គ្រងសុវត្ថិភាពដូចជាការចូលប្រើប្រាស់ដោយផ្អែកលើតួនាទី ការគ្រប់គ្រងទិន្នន័យឯកជន និងសុវត្ថិភាពមាតិកាដែលបានបញ្ចូលរួចហើយ។
• ភាពធន់ទ្រាំ ដោយថ្រង Agent threads និង workflows អាចបញ្ឈប់ បន្ត និងស្ដារឡើងវិញពីកំហុស ដែលអាចអនុញ្ញាតឲ្យដំណើរការប្រតិបត្តិការរយៈពេលយូរជាងមុន។
• ការត្រួតការណ៍ ដោយគាំទ្រចំហ៊ុមមនុស្សក្នុងបរិដ្ឋានយោង ដែលភារកិច្ចត្រូវបានសម្គាល់ថាចាំបាច់ត្រូវការអនុម័តពីមនុស្ស។

Microsoft Agent Framework ក៏ផ្តោតលើភាពអាចប្រើប្រាស់រួមគ្នាបានដោយ៖

• មិន់ពឹងផ្អែកលើ Cloud ណាមួយទេ - Agents អាចរត់នៅក្នុង containers, នៅលើ premises និងនៅក្នុង cloud ផ្សេងៗច្រើន។
• មិន់ពឹងផ្អែកលើ Provider ទេ - Agents អាចត្រូវបានបង្កើតតាម SDK ដែលអ្នកចូលចិត្ត រួមទាំង Azure OpenAI និង OpenAI
• បញ្ចូលស្ទង់វិធាន Open Standards - Agents អាចប្រើ protocols ដូចជា Agent-to-Agent(A2A) និង Model Context Protocol (MCP) ដើម្បីស្វែងយល់និងប្រើប្រាស់ agents និងឧបករណ៍ផ្សេងទៀត។
• Plugins និង Connectors - ការតភ្ជាប់អាចធ្វើទៅកាន់សេវាកម្មទិន្នន័យ និង memory ដូច Microsoft Fabric, SharePoint, Pinecone និង Qdrant។

មកមើលរបៀបដែលលក្ខណៈទាំងនេះត្រូវបានអនុវត្តទៅលើគំនិតស្នូលខ្លះៗនៃ Microsoft Agent Framework។

គំនិតស្នូលនៃ Microsoft Agent Framework

Agents

ការបង្កើត Agents

ការបង្កើត Agent ត្រូវបានធ្វើរួចដោយកំណត់សេវាកម្ម inference (LLM Provider), សំណុំនៃសេចក្តីណែនាំសម្រាប់ AI Agent ចង់អោយអនុវត្ត និង name ដែលបានផ្ដល់៖

agent = AzureOpenAIChatClient(credential=AzureCliCredential()).create_agent( instructions="You are good at recommending trips to customers based on their preferences.", name="TripRecommender" )

ខាងលើកំពុងប្រើ Azure OpenAI ប៉ុន្តែ agents អាចត្រូវបានបង្កើតដោយប្រើសេវាកម្មផ្សេងទៀត រួមមាន Microsoft Foundry Agent Service៖

AzureAIAgentClient(async_credential=credential).create_agent( name="HelperAgent", instructions="You are a helpful assistant." ) as agent

OpenAI API ដូចជា Responses, ChatCompletion

agent = OpenAIResponsesClient().create_agent( name="WeatherBot", instructions="You are a helpful weather assistant.", )

agent = OpenAIChatClient().create_agent( name="HelpfulAssistant", instructions="You are a helpful assistant.", )

ឬ MiniMax ដែលផ្តល់ API ស្រដៀង OpenAI ជាមួយ context window ធំទូលាយ (ដល់ 204K tokens)៖

agent = OpenAIChatClient(base_url="https://api.minimax.io/v1", api_key=os.environ["MINIMAX_API_KEY"], model_id="MiniMax-M2.7").create_agent( name="HelpfulAssistant", instructions="You are a helpful assistant.", )

ឬ agents ឆ្ងាយដោយប្រើ protocol A2A៖

agent = A2AAgent( name=agent_card.name, description=agent_card.description, agent_card=agent_card, url="https://your-a2a-agent-host" )

ការប្រតិបត្តិ Agents

Agents ត្រូវបានដំណើរការដោយប្រើវិធី .run ឬ .run_stream សម្រាប់ការឆ្លើយតបទាំងមិនប្រើ stream និងប្រើ stream។

result = await agent.run("What are good places to visit in Amsterdam?")
print(result.text)

async for update in agent.run_stream("What are the good places to visit in Amsterdam?"):
    if update.text:
        print(update.text, end="", flush=True)

រាល់ការប្រតិបត្តិ agent អាចមានជម្រើសក្នុងការប្តូរព្រមានតាមបម្រែបម្រួលដូចជា max_tokens ដែល agent ប្រើ, tools ដែល agent អាចហៅ, និង ទោះជាចំលើយដែលបានប្រើ model ផ្ទាល់ ដូចដែលដែលគេទាមទារ។

នេះមានប្រយោជន៍ក្នុងករណីដែលត្រូវការ model ឬឧបករណ៍ពិសេសសម្រាប់បញ្ចប់ភារកិច្ចរបស់អ្នកប្រើប្រាស់។

ឧបករណ៍

ឧបករណ៍អាចកំណត់ទាំងនៅពេលកំណត់ agent៖

def get_attractions( location: Annotated[str, Field(description="The location to get the top tourist attractions for")], ) -> str: """Get the top tourist attractions for a given location.""" return f"The top attractions for {location} are." 


# នៅពេលបង្កើត ChatAgent ដោយផ្ទាល់

agent = ChatAgent( chat_client=OpenAIChatClient(), instructions="You are a helpful assistant", tools=[get_attractions]

រួមទាំងពេលប្រតិបត្ត agent នោះផងដែរ៖

result1 = await agent.run( "What's the best place to visit in Seattle?", tools=[get_attractions] # ឧបករណ៍ផ្តល់សម្រាប់ការប្រតិបត្តិនេះត្រឹមតែម្ដងប៉ុណ្ណោះ )

Agent Threads

Agent Threads ត្រូវបានប្រើសម្រាប់ដោះស្រាយការសន្ទនាច្រើនជំហាន។ Threads អាចត្រូវបានបង្កើតដោយ៖

• ប្រើ get_new_thread() ដែលអនុញ្ញាតឲ្យបញ្ចូល thread សម្រាប់រក្សាទុកពេលក្រោយ
• បង្កើត thread ដោយស្វ័យប្រវត្តិនៅពេលដំណើរការ agent ហើយ thread នោះមានអាយុរយៈពេលតែប៉ុណ្ណោះ។

ដើម្បីបង្កើត thread គូដមើលដូចខាងក្រោម៖

# បង្កើតខ្សែចង្រ្កានថ្មីមួយ។
thread = agent.get_new_thread() # ប្រតិបត្តិភ្នាក់ងារជាមួយខ្សែចង្រ្កាននោះ។
response = await agent.run("Hello, I am here to help you book travel. Where would you like to go?", thread=thread)

អ្នកអាចប្រើ serialize thread ដើម្បីរក្សាទុកសម្រាប់ប្រើពេលក្រោយ៖

# បង្កើតខ្សែថ្មីមួយ។
thread = agent.get_new_thread() 

# ប្រតិបត្តិភាគីជាមួយខ្សែ។

response = await agent.run("Hello, how are you?", thread=thread) 

# រៀបចំខ្សែសម្រាប់ការផ្ទុកឯកសារ។

serialized_thread = await thread.serialize() 

# បំបែកស្ថានភាពខ្សែក្រោយពីបើកពីស្តុក។

resumed_thread = await agent.deserialize_thread(serialized_thread)

Agent Middleware

Agents ប្រតិបត្តិការជាមួយឧបករណ៍ និង LLM ដើម្បីបញ្ចប់ភារកិច្ចរបស់អ្នកប្រើ។ ក្នុងសេចក្តីលំអិតខ្លះៗ យើងចង់អនុវត្ត ឬតាមដានការទំនាក់ទំនងរវាង agent និងឧបករណ៍។ Agent middleware អាចធ្វើបានតាមរយៈ៖

Function Middleware

Middleware នេះអនុញ្ញាតឲ្យអនុវត្តសកម្មភាពរវាង agent និង function/ឧបករណ៍ដែលវានឹងហៅ។ ឧទាហរណ៍បើចង់ចុះកត់ត្រាកាលណាហៅ function នោះ។

ក្នុងកូដខាងក្រោម next កំណត់ថា middleware ឬ function ទីបន្ទាប់គួរត្រូវបានហៅ។

async def logging_function_middleware(
    context: FunctionInvocationContext,
    next: Callable[[FunctionInvocationContext], Awaitable[None]],
) -> None:
    """Function middleware that logs function execution."""
    # ការបំណាស់មុន៖ កត់ត្រាកម្រិតកំណត់ហេតុនាពេលមុខងារប្រតិបត្តិ
    print(f"[Function] Calling {context.function.name}")

    # បន្តទៅមេឌៀវេររឺការប្រតិបត្តិមុខងារបន្ទាប់
    await next(context)

    # ការបំណាស់បន្ទាប់៖ កត់ត្រាកម្រិតកំណត់ហេតុបន្ទាប់ពីមុខងារបានប្រតិបត្តិ
    print(f"[Function] {context.function.name} completed")

Chat Middleware

Middleware នេះអនុញ្ញាតឲ្យអនុវត្ត ឬកត់ត្រាសកម្មភាពរវាង agent និងសំណើរវចនានុក្រម (LLM)។

វារួមបញ្ចូលព័តមានសំខាន់ ដូចជា messages ដែលត្រូវបានផ្ញើទៅសេវា AI។

async def logging_chat_middleware(
    context: ChatContext,
    next: Callable[[ChatContext], Awaitable[None]],
) -> None:
    """Chat middleware that logs AI interactions."""
    # ការ_Pre-processing: កំណត់ត្រាជាកំណត់ត្រាមុនការហៅ AI
    print(f"[Chat] Sending {len(context.messages)} messages to AI")

    # បន្តទៅ middleware ឬសេវាកម្ម AI បន្ទាប់
    await next(context)

    # ការ_Post-processing: កំណត់ត្រាបន្ទាប់ពីការឆ្លើយតប AI
    print("[Chat] AI response received")

Agent Memory

ដូចដែលបានពិពណ៌នានៅក្នុងមេរៀន Agentic Memory, memory គឺជាធាតុសំខាន់សម្រាប់អោយ agent អាចបើកដំណើរការជាមួយ context ផ្សេងៗគ្នា។ MAF ផ្តល់ជម្រើសនៃ memory៖

In-Memory Storage

នេះគឺ memory ដែលបានរក្សាទុកក្នុង threads កំឡុងពេលកម្មវិធីដំណើរការ។

# បង្កើតខ្សែថ្មីមួយ។
thread = agent.get_new_thread() # ចាប់ផ្តើមភ្នាក់ងារជាមួយខ្សែ។
response = await agent.run("Hello, I am here to help you book travel. Where would you like to go?", thread=thread)

Persistent Messages

Memory នេះប្រើសម្រាប់រក្សាប្រវត្តិការសន្ទនាជារយៈពេលវែងក្នុង session ផ្សេងៗ។ វាត្រូវបានកំណត់តាម chat_message_store_factory៖

from agent_framework import ChatMessageStore

# បង្កើតឃ្លាំងសារបុគ្គលិក
def create_message_store():
    return ChatMessageStore()

agent = ChatAgent(
    chat_client=OpenAIChatClient(),
    instructions="You are a Travel assistant.",
    chat_message_store_factory=create_message_store
)

Dynamic Memory

Memory នេះត្រូវបានបន្ថែមចូលក្នុង context មុនពេល agents ត្រូវបានប្រតិបត្តិ។ Memory ទាំងនេះអាចរក្សាទុកនៅសេវាផ្សេងៗដូច mem0៖

from agent_framework.mem0 import Mem0Provider

# កំពុងប្រើ Mem0 សម្រាប់សមត្ថភាពចងចាំកម្រិតខ្ពស់
memory_provider = Mem0Provider(
    api_key="your-mem0-api-key",
    user_id="user_123",
    application_id="my_app"
)

agent = ChatAgent(
    chat_client=OpenAIChatClient(),
    instructions="You are a helpful assistant with memory.",
    context_providers=memory_provider
)

Agent Observability

ការសង្កេតមើលគឺសំខាន់សម្រាប់សង់ប្រព័ន្ធ agentic ដែលអាចទុកចិត្តបាន និងងាយស្រួលថែទាំ។ MAF បញ្ចូលជាមួយ OpenTelemetry ដើម្បីផ្តល់ tracing និង meters សម្រាប់ការសង្កេតមើលល្អប្រសើរ។

from agent_framework.observability import get_tracer, get_meter

tracer = get_tracer()
meter = get_meter()
with tracer.start_as_current_span("my_custom_span"):
    # ធ្វើអ្វីមួយ
    pass
counter = meter.create_counter("my_custom_counter")
counter.add(1, {"key": "value"})

Workflows

MAF ផ្តល់នូវ workflows ដែលជាជំហានដែលបានកំណត់រួចរួចសម្រាប់បញ្ចប់ភារកិច្ច ហើយរួមបញ្ចូល AI agents ជាផ្នែកមួយនៃជំហានទាំងនោះ។

Workflows មានគ្រឿងផ្សំផ្សេងៗដែលអាចគ្រប់គ្រងចរន្តបានល្អប្រសើរ។ Workflows នេះក៏អាចគ្រប់គ្រង ការ​ដំណើរការ​ឧបករណ៍ agent ច្រើន និង checkpointing ដើម្បីរក្សាទុកស្ថានភាព workflow។

គ្រឿងផ្សំស្នូលនៃ workflow មាន៖

Executors

Executors ទទួលmessages បញ្ចូល, អនុវត្តភារកិច្ចដែលបានផ្ដល់, ហើយបញ្ចេញmessages ផ្លូវចេញ។ វាផ្លាស់ប្តូរដំណើរការផ្លូវ workflow ទៅរកការបញ្ចប់ភារកិច្ចធំបំផុត។ Executors អាចជាឧបករណ៍ AI ឬតុល្យភាព logic។

Edges

Edges ត្រូវបានប្រើសម្រាប់កំណត់ចរន្តmessages ក្នុង workflow។ Edges អាចមានប្រភេទដូចជា៖

Direct Edges - ការតភ្ជាប់មួយទៅមួយជាដំណាក់កាលសាមញ្ញរវាង executors៖

from agent_framework import WorkflowBuilder

builder = WorkflowBuilder()
builder.add_edge(source_executor, target_executor)
builder.set_start_executor(source_executor)
workflow = builder.build()

Conditional Edges - សកម្មបន្ទាប់ពីលក្ខខណ្ឌខ្លះត្រូវបានបំពេញ។ ឧទាហរណ៍ នៅពេលបន្ទប់សណ្ឋាគារមិនមាន អ្នកអាចរៀបចំ អ្នកអនុវត្តណែនាំជម្រើសផ្សេងទៀត។

Switch-case Edges - ផ្ញើ messages ទៅ executors ផ្សេងៗតាមលក្ខខណ្ឌកំណត់។ ឧទាហរណ៍ បើអតិថិជនធ្វើដំណើរមានសិទ្ធិចូលរួមលំដាប់ខ្ពស់ ភារកិច្ចរបស់គាត់នឹងត្រូវបានគ្រប់គ្រងតាម workflow ផ្សេង។

Fan-out Edges - ផ្ញើបានមួយ message ទៅគោលដៅជាច្រើន។

Fan-in Edges - ប្រមូល messages ពី executors ផ្សេងៗហើយផ្ញើទៅគោលដៅតែមួយ។

Events

ដើម្បីផ្តល់សង្កេតមើលកាន់តែប្រសើរចំពោះ workflows, MAF ផ្តល់អ៊ីវ៉ង់ដែលបានបញ្ចូលសម្រាប់ការប្រតិបត្តិរួមមាន៖

• WorkflowStartedEvent - ដំណើរការ workflow ចាប់ផ្ដើម
• WorkflowOutputEvent - workflow ផលិតចេញចម្លើយ
• WorkflowErrorEvent - workflow ជួបកំហុស
• ExecutorInvokeEvent - Executor ចាប់ផ្ដើមដំណើរការ
• ExecutorCompleteEvent - Executor បញ្ចប់ដំណើរការ
• RequestInfoEvent - មានពោងសំណើ

លំនាញ MAF ជំនាន់ខ្ពស់

ផ្នែកខាងលើបានគ្របដណ្តប់គំនិតស្នូលនៃ Microsoft Agent Framework។ នៅពេលអ្នកកសាង agents ស្មុគ​ស្មាញជាងមុន មានលំនាញជំនាន់ខ្ពស់ខាងក្រោមសម្រាប់ពិចារណា៖

• មូលដ្ឋាន Middleware: សង្ស័យតំណរខ្សែ chained middleware គឺមានអ្នកគ្រប់គ្រង middleware ផ្សេងៗ (logging, auth, rate-limiting) ដោយប្រើ function និង chat middleware សម្រាប់ការគ្រប់គ្រងលម្អិតលើចរិតបុគ្គល agent។
• Checkpointing Workflow: ប្រើ workflow events និង serialization ដើម្បីរក្សាទុក និងបន្តដំណើរការដំណើរការអ្នកប្រើបានយូរ។
• ជម្រើសឧបករណ៍ឌីណាមិច: សម្របសម្រួល RAG លើការពិពណ៌នាឧបករណ៍ជាមួយការចុះបញ្ជីឧបករណ៍ MAF ដើម្បីបង្ហាញឧបករណ៍ដែលពាក់ព័ន្ធគត់ក្នុងសំណួរ។
• Multi-Agent Handoff: ប្រើ workflow edges និងការបញ្ជូន conditional ដើម្បីត្រួតពិនិត្យការផ្ទេរជាagent រៀបចំជាស៊ុមទូលាយ។

ឧទាហរណ៍កូដ

ឧទាហរណ៍កូដសម្រាប់ Microsoft Agent Framework អាចរកបាននៅក្នុងឃ្លាំងនេះក្រោមឯកសារ xx-python-agent-framework និង xx-dotnet-agent-framework។

មានសំណួរបន្ថែមអំពី Microsoft Agent Framework?

ចូលរួមនៅក្នុង Microsoft Foundry Discord ដើម្បីជួបជាមួយអ្នករៀនផ្សេងទៀត ចូលរួមម៉ោងការិយាល័យ ហើយទទួលបានចម្លើយចំពោះសំណួរអំពី AI Agents របស់អ្នក។

---

ការស្រាយចេញពីក្រុមហ៊ុន:
ឯកសារនេះត្រូវបានបកប្រែដោយប្រើសេវាកម្មបកប្រែ AI Co-op Translator។ ទោះយើងខិតខំសម្រាប់ភាពត្រឹមត្រូវក៏ដោយ សូមយល់ឲ្យបានថាការបកប្រែដោយស្វ័យប្រវត្តិនេះអាចមានកំហុស ឬភាពមិនត្រឹមត្រូវខ្លះ។ ឯកសារដើមក្នុងភាសាទីតាំងរបស់វាត្រូវបានគិតថាជា​អ្នកផ្តល់ព័ត៌មានដ៏មានអំណាច។ សម្រាប់ព័ត៌មានសំខាន់ៗ សូមណែនាំឲ្យប្រើប្រែដោយមនុស្សអ្នកជំនាញ។ យើងមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកប្រែខុសណាមួយដែលកើតឡើងពីការប្រើប្រាស់បកប្រែនេះឡើយ។