Paano Gumawa ng Makapangyarihang mga Ahente ng AI Gamit ang mga Tool sa Csharp

Home » Python » Paano Gumawa ng Makapangyarihang mga Ahente ng AI Gamit ang mga Tool sa Csharp

Ang pagbuo ng mga AI agent gamit ang mga tool sa C# ay lumipat mula sa isang eksperimento sa pananaliksik patungo sa isang napaka-praktikal na paraan ng pagdaragdag ng totoong katalinuhan sa mga aplikasyon sa negosyo. Ang mga modernong framework mula sa Microsoft at ang pinakabagong OpenAI at Azure OpenAI SDK ay nagbibigay-daan upang higit pa sa mga simpleng chatbot, na nagkokonekta sa malalaking modelo ng wika sa code, mga file, mga daloy ng trabaho at mga sistema ng enterprise habang pinapanatili pa rin ang kontrol sa seguridad, gastos at pagiging maaasahan.

Ipapakita sa iyo ng gabay na ito ang mga pangunahing konsepto, mga desisyon sa arkitektura, at mga konkretong halimbawa ng .NET na kailangan mo upang magdisenyo ng mga ahente na handa na sa produksyon sa C#. Pagsasama-samahin natin ang mga ideya mula sa Azure OpenAI Assistants, Microsoft Agent Framework, mga pattern ng orkestrasyon, pagsubok, kakayahang maobserbahan, at pag-deploy ng cloud, na magpapaliwanag kung paano umaangkop ang lahat sa isang magkakaugnay na estratehiya para sa mga aplikasyon sa totoong mundo.

Ano nga ba ang isang AI agent (at bakit ito mahalaga sa .NET)

Sa .NET ecosystem, ang isang AI agent ay pinakamahusay na nauunawaan bilang isang bahagi ng software na nakabatay sa layunin na pinapagana ng isang LLM na maaaring mangatwiran, pumili ng mga tool at kumilos sa loob ng iyong aplikasyon. Sa halip na isang mahigpit na script na palaging sumusunod sa parehong landas, ang isang agent ay tumatanggap ng bukas na input, nagpapasya kung ano ang susunod na gagawin at ginagamit ang iyong code at data upang makamit ang isang resulta.

Nagiging mas kapaki-pakinabang ang mga ahente kapag nagdagdag ka ng tatlong kakayahan sa ibabaw ng pagbuo ng plain text. Binibigyan mo sila ng pangangatwiran at paggawa ng desisyon (sa pamamagitan ng mga LLM, search o planning algorithm), ang kakayahang tumawag ng mga tool (mga lokal na C# function, MCP server, API, code execution) at kamalayan sa konteksto (chat history, threads, vector stores, enterprise knowledge graphs o file search). Ito ang siyang nagiging isang component na maaaring awtomatikong mag-coordinate ng multi-step na gawain sa isang simpleng chat completion.

Habang nagiging mas kumplikado ang iyong mga layunin, bihira mong patakbuhin ang lahat bilang isang higanteng opaque prompt; hinahati mo ang trabaho sa mga workflow. Ang workflow ay isang pagkakasunod-sunod o graph ng mga hakbang na kailangan upang maabot ang isang layunin: halimbawa, pangangalap ng mga kinakailangan, pagdidisenyo, pagpapatupad, pagsubok at pag-deploy ng isang feature. Ang bawat hakbang ay maaaring maglaman ng mga sub-task at maaaring umulit depende sa mga error o bagong impormasyon, kaya ang orchestration ay mabilis na nagiging isang pangunahing alalahanin.

Kapag naglagay ka ng mga ahente sa loob ng mga daloy ng trabahong ito, makakakuha ka ng mga daloy ng trabahong ahente : mga daloy kung saan nakikipagtulungan ang mga ahente upang isagawa, iakma, at i-optimize ang mga gawain. Maaari kang magkaroon ng isang ahente na nagsusuri ng mga log, isa pa na nagbabalangkas ng mga pag-aayos ng code, at pangatlo na naghahanda ng mga ulat ng stakeholder. Ang mahalagang bahagi ay kung paano nila ipinapasa ang impormasyon, kung paano sila kino-coordinate, at kung paano mo pinapanatiling naoobserbahan at nao-audit ang buong sistema.

Mga pangunahing bloke ng pagbuo ng mga AI assistant at agent

Karamihan sa mga modernong platform ng AI agent na nakatuon sa C# at .NET ay may maliit na hanay ng mga pangunahing bahagi, kahit na bahagyang magkaiba ang pagpapangalan sa pagitan ng Azure OpenAI Assistants at Microsoft Agent Framework. Ang pag-unawa sa mga blokeng ito ay makakatulong sa iyong idisenyo ang iyong sariling arkitektura sa halip na kopyahin ang mga snippet nang walang taros.

Ang isang assistant o agent ay ang central AI client na gumagamit ng LLM plus configuration upang iproseso ang mga instruksyon, pamahalaan ang mga pag-uusap, at gamitin ang mga tool. Sa Azure OpenAI Assistants, ibinabalot ng object na ito ang configuration ng modelo, mga tagubilin, at configuration ng tool. Sa Microsoft Agent Framework, isang AIAgent bumabalot sa isang chat client (OpenAI o Azure OpenAI) kasama ang mga tool at tagubilin, at sadyang walang estado upang makapaghatid ito ng maraming pag-uusap nang sabay-sabay.

Ang isang thread o session ay kumakatawan sa isang pag-uusap sa pagitan ng isang user at ng agent, kabilang ang lahat ng mensahe at kaugnay na estado. Ang mga Azure OpenAI Assistant ay tumatalakay sa mga thread , na nagmamay-ari ng mga mensahe at humahawak ng awtomatikong pagputol upang umangkop sa konteksto ng modelo. Ang Microsoft Agent Framework naman ay tumatalakay sa AgentSession , na naglalaman ng history at maaaring i-serialize at iimbak. Pareho silang may parehong layunin: pagsubaybay sa konteksto sa maraming turno.

Ang mga mensahe ay ang mga indibidwal na kontribusyon sa loob ng isang thread o session, na ginawa ng mga user o ng assistant. Ang mga mensahe ay maaaring maglaman ng plain text, mga imahe o mga file, at sa mga Assistant API, ang mga ito ay iniimbak bilang mga nakaayos na listahan sa loob ng isang thread. Sa panig ng C#, karaniwan mong kinukuha ang mga ito bilang mga koleksyon na may mahigpit na pagkaka-type kung saan maaari mong suriin ang teksto, mga anotasyon at mga sanggunian sa file.

Ang isang run, execution, o invocation ay isang beses na pag-activate ng agent sa ibabaw ng isang partikular na thread o session. Kukunin mo ang kasalukuyang konteksto, ipapadala ito sa modelo kasama ang mga tool at configuration, at maghihintay hanggang sa maabot ng run ang isang terminal state. Habang tumatakbo, maaaring gumawa ang agent ng mga bagong mensahe, tumawag ng mga tool, at i-update ang thread o session state.

Ang mga hakbang sa pagpapatupad ay bumubuo ng isang detalyadong bakas ng lahat ng nangyari habang tumatakbo ang isang ahente. Maaaring tumawag ang isang assistant ng isang file search tool, i-trigger ang code interpreter, o tumawag ng isang custom function nang maraming beses habang pinag-iisipan nito ang gawain. Ang pagkakaroon ng isang nakabalangkas na pananaw sa mga hakbang na ito ay lubhang kapaki-pakinabang upang maunawaan kung bakit ginawa ang isang partikular na sagot at upang i-debug o i-audit ang pag-uugali sa ibang pagkakataon.

Paglikha ng isang minimal na C# console agent gamit ang Azure OpenAI Assistants

Para maisagawa ang mga konseptong ito, maaari kang gumawa ng isang minimal na .NET console application na gumagamit ng opisyal na OpenAI o Azure OpenAI SDKs para bumuo ng isang assistant na nagbabasa ng data mula sa mga file at bumubuo ng mga visualization. Ang ideya ay ikonekta ang isang LLM sa parehong paghahanap ng file at pagpapatupad ng code, at pagkatapos ay hayaan itong sumagot sa mga tanong sa analytics sa natural na wika.

Ang unang hakbang ay ang pag-setup ng proyekto: lumikha ng isang bagong .NET console app at idagdag ang mga NuGet package para sa OpenAI at Azure.AI.OpenAI. Pagkatapos ay i-instantiate mo ang mga pangunahing kliyente sa Program.cs, para sa OpenAI nang direkta o para sa Azure OpenAI gamit ang isang kredensyal tulad ng DefaultAzureCredentialMula sa OpenAI client, makakakuha ka ng AssistantClient upang pamahalaan ang mga katulong at isang hiwalay na OpenAIFileClient para sa mga pag-upload ng file.

Susunod, maghahanda ka ng makatotohanang datos para magamit ng ahente sa pamamagitan ng pagbuo ng dokumento sa memorya, pag-serialize nito bilang JSON at pag-stream nito sa file client. Sa halimbawa, ang JSON na ito ay nagko-code ng ilang buwan ng benta ng produkto para sa isang kathang-isip na kumpanya, na mina-map ang mga buwan sa mga dami ng bawat produkto. Sa pamamagitan ng pag-upload nito gamit ang Assistants layunin ng file, minarkahan mo ito bilang materyal na maaaring hanapin ng ahente.

Kapag mayroon nang datos sa sistema, iko-configure mo ang assistant sa pamamagitan ng AssistantCreationOptions para paganahin ang paghahanap ng file at ang tool na interpreter ng code. Tumutukoy ka ng pangalan, isang hanay ng malinaw na mga tagubilin (“ikaw ay isang assistant na naghahanap ng datos ng mga benta at gumagawa ng mga visualization kapag hiniling”), at pagkatapos ay ikakabit ang mga tool: a FileSearchToolDefinition para makapag-query ang assistant sa mga file, kasama ang isang CodeInterpreterToolDefinition kaya nitong magsulat at magpatakbo ng code sa isang sandboxed environment para sa pagsusuri o pagbuo ng tsart.

Para magamit talaga ng paghahanap ng file ang iyong na-upload na dokumento ng pagbebenta, iuugnay mo ito sa isang bagong vector store sa loob ToolResources. Ang katulong VectorStoreCreationHelper Binibigkis nito ang na-upload na file ID sa isang vector store na maaaring i-query ng assistant nang semantiko sa halip na i-scan ang raw text. Ito ay isang magaan ngunit makapangyarihang paraan upang magdagdag ng retrieval-augmented generation behavior.

Kapag may mga opsyon na nakalatag, gagawa ka ng assistant sa pamamagitan ng pagpasa ng target model (halimbawa gpt-4o) at ang configuration, at pagkatapos ay bubuo ka ng thread ng pag-uusap na may paunang mensahe ng user. Ang unang prompt ay maaaring parang ganito, “Kumusta ang performance ng produkto 113045 noong Pebrero? I-plot ang trend nito sa paglipas ng panahon.” Panghuli, tatawag ka CreateThreadAndRun, na siyang lumilikha ng thread at nagsisimula ng isang pag-usad.

Dahil ang mga run ay likas na asynchronous, karaniwang sinusuri ng console app ang run hanggang sa maging terminal ang status. Pagkatapos nito, kukunin mo ang mga mensahe ng thread sa pataas na pagkakasunud-sunod at uulitin ang mga ito: pag-print ng assistant text, pag-output ng mga anotasyon para sa mga file citation o mga nabuong file, at pag-download ng mga output ng imahe gamit ang file client upang ma-save mo ang mga chart na ginawa ng code interpreter sa disk bilang mga PNG file.

Ang resulta ay isang self-contained na C# console application kung saan ang isang assistant ay maaaring maghanap ng structured sales data, magsagawa ng mga kalkulasyon sa pamamagitan ng code at magbalik ng parehong textual insights at visual graphs sa isang ganap na automated loop. Ang pattern na ito ay maayos na naa-scale sa mga web backend o background services kapag naidagdag mo na ang persistence at authentication.

Pagdidisenyo ng matatag na arkitektura ng ahente sa C#

Kapag lumipat ka mula sa isang demo patungo sa isang totoong aplikasyon, ang paraan ng pagbubuo mo ng iyong mga ahente ay mahalaga rin gaya ng kung aling modelo ang iyong pipiliin. Ang isang mahusay na arkitektura ay ginagawang mas madali ang pagsubok, pagpapalaki, pag-secure, at pagpapaunlad ng iyong solusyon nang hindi nagtatapos sa isang hindi mapapanatiling gusot ng mga prompt at callback.

Isang napatunayang estratehiya ang pagtrato sa mga ahente bilang mga espesyalisadong bahagi sa halip na iisang utak na "gumagawa ng lahat". Halimbawa, maaari mong tukuyin ang isang ahente na nakatuon sa pagkuha at pag-verify ng impormasyon, ang isa pang ahente na nakatuon sa pagsulat at pagbubuod ng nilalaman, at isa pa na ang tanging trabaho ay makipag-ugnayan sa mga panlabas na API o database. Ang paghihiwalay na ito ay nagbibigay-daan sa mga naka-target na unit test, mga independiyenteng pag-deploy at mas pinong mga limitasyon sa seguridad at token.

Mabilis na nagiging hadlang ang estado at memorya kung ituturing mo ang mga ito bilang isang nahuling pag-iisip. Lumalago ang mga kasaysayan ng pag-uusap sa paglipas ng panahon, at ang walang taros na pagpapadala ng buong transcript sa modelo sa bawat pagliko ay nagpapataas ng latency at gastos. Kabilang sa mga praktikal na estratehiya ang pana-panahong pagbubuod ng mga naunang mensahe, paghahati-hati ng mga pag-uusap sa magkakahiwalay na thread bawat user o bawat use case, at pagpapatupad ng mga patakaran sa compaction batay sa semantic importance upang tanging ang mga pinaka-kaugnay na bahagi ng nakaraan ang mapangalagaan nang detalyado.

Sa mga senaryo ng produksyon, gusto mo rin ng isang persistent store para sa memorya upang ang mga pag-uusap ay makaligtas sa mga restart ng proseso, pagkabigo o muling pag-deploy. Ang mga agent framework tulad ng Microsoft Agent Framework ay ginagawang serializable ang mga session sa isang JsonElement, na maaari mong ipasok sa SQL Server, Redis o anumang NoSQL store. Ang parehong kakayahang iyon ay nagbibigay-daan sa mga audit trail at pagsunod sa mga regulasyon dahil maaari mong muling buuin kung ano mismo ang estado ng ahente noong gumawa ito ng desisyon.

Ang mga tool at function call ang siyang lugar kung saan ang mga agent ay hindi na nagiging pasibo at nagsisimulang gumawa ng kapaki-pakinabang na trabaho. Ang paglalantad ng mga native na C# method bilang mga tool ay nagbibigay-daan sa modelo na mag-udyok ng mga gawi tulad ng pag-query sa isang CRM, pagpapatakbo ng analytics sa data o pag-trigger ng mga workflow. Ang bawat tool ay dapat na may anotasyon na may malinaw na metadata (mga paglalarawan at dokumentasyon ng parameter), upang malaman ng LLM kung kailan ito tatawagin at kung aling mga argumento ang gagamitin.

Dahil ang isang tool na hindi gumagana nang maayos ay maaaring makasira sa isang buong interaksyon, kailangan mo ng matibay na engineering para sa mga ito: pagpapatunay ng input, mga timeout, paghawak ng exception at mga guardrail. Huwag ipagpalagay na ang modelo ay laging nakakapasa sa mga perpektong argumento; patunayan ang mga parameter at linisin ang anumang mga panlabas na tawag. Isipin din ang mga quota at limitasyon sa rate bawat tool upang maiwasan ang mga hindi inaasahang gastos o aksidenteng labis na karga ng mga downstream system.

Para sa mga ambisyosong senaryo, maaaring mabuksan ng multi-agent orchestration ang mga kakayahan na mahirap makamit gamit ang iisang monolithic agent. Maaari kang magtalaga ng isang "researcher" agent na mangangalap at susuri ng impormasyon, isang "analyst" na magbibigay-kahulugan sa mga natuklasan, at isang "writer" na gagawing mga ulat ang mga ito, na ang bawat isa ay nakikipag-ugnayan sa pamamagitan ng mga nakabalangkas na mensahe at nagbabahagi ng isang work surface (tulad ng isang nakabahaging dokumento o knowledge store). Pinapataas ng pattern na ito ang espesyalisasyon at ginagawang masusubaybayan ang decision path kapag kailangan mo pang suriin o i-audit ang mga resulta sa ibang pagkakataon.

Mula sa Semantic Kernel at AutoGen hanggang sa Microsoft Agent Framework

Pinagsasama-sama ng Microsoft ang mga agent tooling nito para sa .NET, pinagsasama-sama ang mga ideya mula sa Semantic Kernel at sa proyektong AutoGen sa isang bago at pinag-isang Microsoft Agent Framework (MAF). Nilalayon ng framework na ito na bigyan ka ng enterprise-grade na stability at mga feature habang pinapasimple kung paano ka bubuo ng mga multi-turn agent at graph-based workflow.

Ang MAF ay kasalukuyang nasa pampublikong preview at available para sa parehong .NET at Python sa ilalim ng lisensya ng MIT. Bagama't ang ilang API ay umuunlad pa rin sa pagitan ng mga kandidato para sa paglabas, malinaw ang pangkalahatang direksyon: Mga AIAgent para sa matalinong pag-uugali, AgentSessions para sa pamamahala ng estado, at isang sistema ng daloy ng trabaho batay sa mga graph at executor para sa mas deterministic na mga pipeline.

Sa kaibuturan nito, pinag-iiba ng balangkas ang mga ahente at mga daloy ng trabaho, na bawat isa ay inilaan para sa iba't ibang hugis ng problema. Ang mga ahente ay mga dynamic na sistema na gumagamit ng mga LLM upang bigyang-kahulugan ang input, magpasya kung anong mga tool ang tatawagin at bumuo ng mga tugon. Nagniningning ang mga ito sa mga hindi mahuhulaan na domain tulad ng mga pag-uusap sa teknikal na suporta kung saan maaaring magtanong ang mga gumagamit ng kahit ano. Sa kabilang banda, ang mga daloy ng trabaho ay mga tahasang pagkakasunud-sunod ng hakbang na naka-wire bilang mga graph at ginagamit kapag gusto mo ng deterministic, mahusay na natukoy na pagproseso tulad ng mga pipeline ng data o mga kadena ng pag-apruba.

Ang opisyal na gabay ay maaaring ibuod bilang "kung kaya mong ipatupad ang isang gawain bilang isang karaniwang function, malamang na hindi mo na kailangan ng ahente para dito." Sa madaling salita, magreserba ng mga ahente para sa mga domain kung saan hindi mo talaga maaaring paunang tukuyin ang lahat ng hakbang, at umasa sa mga workflow o klasikong code para sa mauulit at deterministic na daloy. Ang paghahalo ng pareho sa tamang lugar ay susi sa pagbuo ng mga maintainable system.

Para maging konkreto ito, isipin ang isang support chatbot na ginawa bilang isang ASP.NET Core 10 API gamit ang Microsoft Agent Framework. Gumagamit ang agent ng chat client (na sinusuportahan ng Azure OpenAI o OpenAI) bilang reasoning engine nito, at ang pangunahing layunin nito ay sagutin ang mga tanong tungkol sa internal na dokumentasyon na nakaimbak sa mga Markdown file habang pinapanatili ang konteksto sa maraming mensahe mula sa iisang user.

Kapansin-pansin, maaaring sadyang laktawan ng halimbawa ang RAG gamit ang mga embedding at manatiling makatotohanan sa pamamagitan ng paggamit ng keyword search sa ibabaw ng mga flat file bilang panimulang punto. Pinapanatili nito ang pokus sa kung paano binubuo ng MAF ang ahente, mga tool, at mga sesyon sa halip na maligaw sa configuration ng vector database, habang sinusuportahan pa rin ang mga napaka-makatwirang interaksyon sa suporta.

Ang limang pangunahing konsepto sa Microsoft Agent Framework

Ang mga opisyal na tutorial para sa MAF ay nag-oorganisa ng pagkatuto sa limang progresibong ideya na akmang-akma sa kung paano na iniisip ng mga C# developer ang tungkol sa mga serbisyo at estado. Ang pagiging komportable sa mga konseptong ito ay nagbibigay sa iyo ng matibay na pundasyon para sa anumang ahente na iyong itatayo sa .NET.

Una ay ang iyong unang ahente: isang AIAgent binuo mula sa isang chat client, mga tagubilin at isang pangalan. Itinuro mo ang ahente sa isang chat model na ibinibigay ng AzureOpenAIClient o OpenAI, magbibigay ng gabay sa antas ng system (“isa kang matulunging support assistant”) at pagkatapos ay tatawagan RunAsync gamit ang input ng user. Ang mahalagang detalye ay ang agent instance ay stateless at maaaring maghatid ng maraming independiyenteng pag-uusap nang sabay-sabay.

Pangalawa ay ang mga tool, na mga simpleng pamamaraan ng C# na pinalamutian ng mga katangian at na-convert sa mga function na maaaring i-voice sa pamamagitan ng AIFunctionFactory.Create(). Kapag tumakbo ang ahente, ang LLM ay makakatanggap ng isang schema na hango sa mga katangiang iyon at maaaring magdesisyon nang awtomatiko kung kailan at paano tatawagin ang bawat tool, kabilang ang mga argumento. Dito nagiging bahagi ng action space ng ahente ang iyong sariling business logic at mga external integration.

Pangatlo ay ang suporta sa multi-turn conversation, na pinangangasiwaan ng MAF AgentSession mga bagay. dahil sa AIAgent wala itong naaalala, ang bawat patuloy na pag-uusap ay nasa loob ng isang sesyon na nilikha gamit ang CreateSessionAsync()Ibinabalik mo ang sesyon na iyon sa mga kasunod na tawag, na nagbibigay-daan sa ahente na subaybayan ang mga naunang mensahe, kagustuhan ng gumagamit, at mga hindi pa nareresolbang isyu.

Pang-apat ay ang memorya at pagtitiyaga, na pinagana ng katotohanan na ang mga sesyon ay maaaring i-serialize sa isang JsonElement. Ginagawa nitong madali ang pag-iimbak ng mga ito sa memorya, Redis, isang SQL table o anumang iba pang tindahan na gusto mo, at pagkatapos ay muling buuin ang mga ito gamit ang DeserializeSessionAsync()Para sa mga sitwasyon ng suporta, nangangahulugan ito na maaaring isara ng isang user ang kanilang browser at ipagpatuloy ang parehong pag-uusap sa ibang pagkakataon, o maaaring maayos na pumalit ang ibang service instance pagkatapos ng pag-restart.

Panglima ay ang mga daloy ng trabaho, na binuo gamit ang WorkflowBuilder kapag kailangan mong tahasang ayusin ang maraming ahente o magkakasunod na hakbang sa pagproseso. Tinutukoy mo ang mga executor bilang mga processing unit, kinokonekta ang mga ito sa pamamagitan ng mga edge at hinahayaan ang workflow engine na pangasiwaan ang routing at mga transition. Sa maraming mga kaso ng pakikipag-usap, hindi mo kakailanganin ang mga workflow, ngunit nagiging lubhang kapaki-pakinabang ang mga ito kapag gusto mo ng nakabalangkas na routing, klasipikasyon o mga hakbang na human-in-the-loop sa paligid ng iyong mga ahente.

Pagpapatupad ng isang tunay na support bot na may MAF, mga tool at session

Ang isang konkretong halimbawa na naglalarawan sa mga konseptong nabanggit ay isang SupportBot API na sinusuportahan ng isang proyektong ASP.NET Core 10. Inilalantad ng serbisyong ito ang isang HTTP endpoint na tumatanggap ng mga mensahe ng user at isang session identifier, nagdedelegate ng pangangatwiran sa isang AIAgent at pinapanatili ang session upang mapanatili ang konteksto sa lahat ng mga kahilingan.

Ang pangunahing kagamitan sa sitwasyong ito ay isang DocumentationTool na nakakaalam kung paano maghanap sa mga panloob na Markdown file. Ang responsibilidad nito ay hanapin ang mga kaugnay na gabay, FAQ o module manual at magbalik ng mga segment ng teksto na makakatulong sa ahente na bumuo ng sagot. Ang mga katangiang inilalapat sa mga pamamaraan nito ay hindi pandekorasyon; ginagamit ito ng MAF upang buuin ang function schema na binabasa ng LLM, at ang kalinawan ng mga paglalarawang iyon ay malakas na nakakaimpluwensya kung gaano kabisa ang pagpili at pagtawag ng modelo sa tool.

Isang praktikal na pagpipilian sa disenyo sa loob ng tool na ito ay ang pagbabalik sa lahat ng dokumento kung walang anumang bagay na tumutugma sa hiniling na paksa. Sa halip na iwan ang ahente nang walang anumang materyal, mas gugustuhin mong magbigay ng masyadong maraming konteksto at hayaan ang modelo na pumili ng pinakamahusay na mga piraso kaysa sa maghalusinasyon ito nang walang laman. Ang pattern na "ligtas na fallback" na ito ay madalas na lumilitaw sa matatag na mga implementasyon ng ahente.

Pagkatapos ay pinagsasama-sama ng SupportAgentFactory ang lahat sa pamamagitan ng pagkuha ng isang AzureOpenAIClient, pagkuha ng chat client sa pamamagitan ng GetChatClient(), inaangkop ito gamit ang AsIChatClient() at pagkatapos ay gagawin itong isang AIAgent sa AsAIAgent(). Sa huling hakbang na ito, ang mga rehistradong tool at instruksyon ay magiging bahagi ng configuration ng agent na ginagamit para sa bawat pag-uusap. Karaniwan mong nirerehistro ang constructed agent na ito bilang isang singleton sa DI container upang makapaghatid ito ng maraming session nang sabay-sabay.

Ang pamamahala ng sesyon ay nakabalangkas sa likod ng isang InMemorySessionStore habang binubuo, na nagsasagawa ng mga sesyon bilang JsonElement halaga. Isang ligtas na thread ConcurrentDictionary ay sapat na rito upang maiwasan ang manu-manong pag-lock. Sa isang totoong deployment, papalitan mo ang implementasyong ito ng isang Redis-backed o database-backed store, na pinapanatiling buo ang interface ngunit nagkakaroon ng matibay na storage at horizontal scalability.

Ang ibabaw ng API sa Program.cs ay sadyang pinananatiling simple: isang POST /chat endpoint na tumatanggap ng session ID at mensahe ng user. Ang request handler ay naglo-load o lumilikha ng session, isinasagawa ang agent, ini-serialize ang na-update na session nang asynchronous (tandaan na SerializeSessionAsync ay async sa RC1, kahit na iba ang iminungkahi ng mga naunang dokumento), pinapanatili ito at ibinabalik ang tugon ng assistant sa kliyente. Mula sa pananaw ng isang frontend, ang "pananatili sa parehong pag-uusap" ay nangangahulugan lamang ng pagpapadala ng parehong session ID sa bawat tawag.

Kapag pinatakbo mo ang API at nakipag-chat dito, mapapanood mong dinadala ng ahente ang konteksto sa pagitan ng mga turno tulad ng isang kinatawan ng suporta na tao. Ang unang mensahe ay maaaring maglarawan ng isyu sa pag-login; ang pangalawang tanong, na ipinadala gamit ang parehong session ID, ay maaaring tumukoy sa "error na iyon muli" nang hindi muling binabanggit ang buong detalye, at ang ahente ay sumasagot pa rin nang magkakaugnay dahil ang estado ay nakatali sa session store.

Magsisimula lamang itong gumana nang maayos kung magdaragdag ka ng mga feature tulad ng awtomatikong pag-uuri ng intent, pagruruta sa mga espesyalisadong ahente (pagsingil, pag-access, pag-uulat) o pag-escalate sa mga kawani. Pagkatapos, maaari kang magpakilala ng classification executor sa harap ng isang workflow graph at ikonekta ito sa mga ahente na partikular sa paksa, o magdagdag ng human-in-the-loop node na humihinto sa automation at nagbibigay ng konteksto sa isang tao kapag mababa ang kumpiyansa.

Mga daloy ng trabaho, mga mode ng orkestrasyon at kolaborasyon ng maraming ahente

Kahit sa labas ng MAF, nakakatulong na isipin kung paano inaayos ang mga daloy ng trabaho na naglalaman ng mga ahente, dahil ang kanilang istraktura ay nakakaapekto sa latency, gastos, at traceability. Mayroong ilang karaniwang mga pattern na lumilitaw sa mga proyekto at framework.

Ang sequential orchestration ay nangangahulugan na ang mga ahente ay humahawak ng mga gawain nang sunud-sunod, na nagpapasa ng mga output. Halimbawa, ang isang retrieval agent ay unang nangongolekta ng mga kaugnay na dokumentasyon, pagkatapos ay ipinapasa ito sa isang analysis agent, na siya namang nag-aabot ng mga natuklasan nito sa isang reporting agent. Ito ay madaling pag-isipan at madaling i-debug, kapalit ng mas mataas na end-to-end latency.

Ang sabay-sabay na orkestrasyon ay nagpapatakbo ng maraming ahente nang sabay-sabay, bawat isa ay nakatuon sa iba't ibang aspeto ng problema. Maaaring kalkulahin ng isang ahente ang mga sukatan, maaaring maghanap ang isa pa ng mga kamakailang insidente, at maaaring suriin ng pangatlo ang epekto ng pagsunod, lahat nang sabay-sabay. Kapag natapos na nila, pinagsasama-sama ng isang coordinator ang kanilang mga resulta sa isang sagot. Binabawasan ng pattern na ito ang latency ngunit nangangailangan ng maingat na pagkontrol sa mapagkukunan at paglutas ng tunggalian.

Ang mga handoff flow ay tahasang nagpapalit ng pagmamay-ari ng gawain mula sa isang ahente patungo sa isa pa batay sa mga kondisyon o mga intermediate na resulta. Kung matukoy ng isang support agent na ang isang tanong ay talagang may kaugnayan sa pagbebenta, maaari nitong ipasa ang pag-uusap sa isang espesyalisadong sales agent, na opsyonal na pinapanatili ang history ng chat at metadata. Ito ay lalong nakakatulong sa mga kumplikadong customer journey kung saan ang responsibilidad ay lehitimong lumilipat sa pagitan ng mga team.

Ang mga setup na istilo ng group chat ay nagbibigay-daan sa ilang ahente na makipagtulungan sa isang nakabahaging channel ng pag-uusap, na nagpapalitan ng mga mensahe nang real time. Ang bawat ahente ay may kanya-kanyang pananaw o toolset, at maaaring pamahalaan ng isang central orchestrator o LLM moderator ang pag-uusap upang magtagpo ito sa halip na paulit-ulit nang walang katapusan. Malakas ang pattern na ito ngunit nangangailangan ng matibay na guardrails upang maiwasan ang ingay at hindi kinakailangang gastos.

Panghuli, ang magnetic orchestration ay naglalagay sa isang "lider" o konduktor agent na namamahala sa pagdidirekta sa iba. Pinaghihiwalay ng lead agent ang gawain, ipinapadala ang mga sub-task sa mga tamang espesyalista at pagkatapos ay binubuo ang kanilang mga output. Ito ay kahawig ng isang engineering manager na nagko-coordinate ng isang pangkat ng mga developer at maaaring magbunga ng malinaw at nauunawaang daloy sa mga kumplikadong domain.

Pagsubok, kakayahang maobserbahan, pagkontrol sa gastos at seguridad

Ang pagpapadala ng mga AI agent sa produksyon nang walang plano para sa pagsubok, pagsubaybay, gastos, at seguridad ay isang recipe para sa mga hindi magagandang sorpresa. Ang parehong higpit na ilalapat mo sa anumang kritikal na .NET service ay dapat ding umabot sa iyong agent layer, na iniangkop lamang sa probabilistikong katangian ng mga LLM.

Magsimula sa pamamagitan ng pagsubok ng mga tool at orchestration path gamit ang mga klasikong unit at integration test bago mag-alala tungkol sa pag-uugali ng modelo. Ang bawat C# function na maaaring tawagin ng isang ahente ay dapat na masubukan nang nakapag-iisa, na may mga deterministic input at output. Pagkatapos ay magdisenyo ng mga controlled conversation script na nagsasagawa ng mga kumpletong interaction path, na bineberipika hindi lamang ang pangwakas na sagot kundi pati na rin kung aling mga tool ang tinawag at kung paano umunlad ang estado.

Dapat subaybayan ng observability ang latency, pagkonsumo ng token, at mga rate ng tagumpay sa iba't ibang ruta ng pagpapatupad. Lubos na kapaki-pakinabang ang pagsukat ng parehong prompt at completion token sa bawat interaksyon, na hinati-hati ayon sa workflow, tool, o uri ng user, para makita mo ang mga regression at cost spike. Partikular na magastos ang mas mahahabang pag-uusap, kaya mamuhunan sa awtomatikong pagbubuod at matatalinong estratehiya sa truncation upang mapanatiling simple ang mga konteksto.

Hindi na maaaring ipagpalit ang seguridad kapag nahawakan na ng iyong mga ahente ang sensitibong datos o datos ng customer. Dapat mong ipatupad ang mahigpit na kontrol sa pag-access sa kung aling mga tool at dataset ang makikita ng isang ahente, i-log ang bawat pagtawag ng tool para sa mga layunin ng pag-audit at patakbuhin ang lahat ng panlabas na tawag sa pamamagitan ng mga sanitization layer. Ang mga kredensyal ay hindi dapat kailanman i-embed sa code; umasa sa mga pinamamahalaang pagkakakilanlan, mga lihim na tindahan at ang karaniwang mga kasanayan sa seguridad sa cloud na inilalapat mo na sa mga non-AI microservice.

Ang mga kinakailangan sa pagsunod ay nakakaapekto rin sa kung paano mo iniimbak at pinoproseso ang kasaysayan ng pag-uusap. Dahil ang mga sesyon at thread ay maaaring maglaman ng personal na impormasyon o kumpidensyal na nilalaman, tukuyin ang mga patakaran sa pagpapanatili, mga diskarte sa pag-anonymize at mga panuntunan sa pag-minimize ng data nang maaga. Ang kakayahang i-serialize at i-deserialize ang mga sesyon ng ahente ay makapangyarihan, ngunit dapat itong balansehin sa mga legal at regulasyon na obligasyon.

Sa aspeto ng gastos, huwag maliitin ang epekto kahit ng maliliit na kawalan ng kahusayan sa malawakang operasyon. Ang maliliit na pagbabago sa laki ng prompt, dalas ng mga tool call, o bilang ng mga sabay-sabay na ahente ay maaaring magresulta sa malalaking buwanang bayarin. Ang paggamit ng mga instrumento sa sistema, regular na pagsusuri sa telemetry at mga tuning prompt, mga patakaran sa memorya, at mga pagpipilian sa modelo ay mahalaga upang mapanatiling napapanatili ang mga gastos sa paglipas ng panahon.

Mas madali ang pag-deploy at pag-scale kapag pinaghihiwalay mo ang control plane (kung saan mo kino-configure ang mga agent at workflow) mula sa inference plane (kung saan tumatakbo ang mga aktwal na model call). Ang orchestration na nakabatay sa container, mga message queue para sa mga pangmatagalang operasyon, at mga pinamamahalaang cloud service para sa LLM hosting ay pawang nakakatulong sa katatagan. Ang mga resulta ay maaaring dumaloy sa mga dashboard o mga BI tool tulad ng Power BI upang isara ang analytics feedback loop at ipakita ang halaga ng negosyo.

Ang pinagsamang mga tooling tulad ng AI Toolkit at Azure AI Foundry extensions para sa Visual Studio Code ay maaaring magpadali sa halos lahat ng lifecycle na ito. Mula sa loob ng editor, maaari mong tuklasin ang mga katalogo ng modelo, i-deploy ang mga modelong naka-host o lokal sa GitHub sa pamamagitan ng Ollama, paghambingin ang mga output nang magkatabi, bumuo at magpatakbo ng mga evaluator, mag-visualize ng mga resulta sa Data Wrangler, magdisenyo ng mga ahente gamit ang mga system prompt, magkabit ng mga MCP server para sa integrasyon ng tool at mga interaksyon sa debug agent. Nagdaragdag ang Azure AI Foundry ng mga visual designer, YAML synchronization, pagbuo ng code para sa Azure model access at primera klaseng integrasyon ng mga tool tulad ng Bing Search at mga code interpreter.

Kapag pinagsama-sama mo ang mga sangkap na ito—matibay na arkitektura ng ahente, maalalahaning pamamahala ng estado, matatag na mga tool, mga daloy ng trabaho na nakabatay sa graph kung saan kinakailangan, malalim na kakayahang maobserbahan at cloud-native na pag-deploy—makakakuha ka ng mga C# AI agent na hindi lamang matatalinong demo kundi maaasahang mga bahagi rin ng mas malalaking sistema ng enterprise. Sa pamamagitan ng maingat na disenyo at tamang paggamit ng Azure OpenAI Assistants at Microsoft Agent Framework, maaaring masukat na mapabuti ng mga ahente na iyon ang kahusayan, kalidad ng impormasyon, at automation sa iyong organisasyon habang nananatiling napapanatili at ligtas.