Selles õppetükis käsitletakse:
Pärast selle õppetüki läbimist oskad:
Koodinäited Microsoft Agent Frameworki (MAF) kohta leiad sellest repositooriumist failides xx-python-agent-framework
ja xx-dotnet-agent-framework
.
Microsoft Agent Framework (MAF) põhineb Semantic Kernel ja AutoGen kogemustel ja õppetundidel. See pakub paindlikkust, et lahendada mitmesuguseid agentlikke kasutusjuhtumeid nii tootmis- kui ka uurimiskeskkondades, sealhulgas:
Tootmiskeskkonnas AI agentide pakkumiseks sisaldab MAF ka järgmisi funktsioone:
Microsoft Agent Framework keskendub ka koostalitlusvõimele:
Vaatame, kuidas neid funktsioone rakendatakse Microsoft Agent Frameworki põhikontseptsioonides.
Agentide loomine
Agentide loomine toimub määratledes järeldusteenuse (LLM Provider), juhiste komplekti, mida AI agent peab järgima, ja määratud name
:
agent = AzureOpenAIChatClient(credential=AzureCliCredential()).create_agent( instructions="You are good at recommending trips to customers based on their preferences.", name="TripRecommender" )
Ülaltoodud näites kasutatakse Azure OpenAI
, kuid agente saab luua mitmesuguste teenuste abil, sealhulgas Azure AI Foundry Agent Service
:
AzureAIAgentClient(async_credential=credential).create_agent( name="HelperAgent", instructions="You are a helpful assistant." ) as agent
OpenAI Responses
, ChatCompletion
API-d
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.", )
või kaugagente, kasutades A2A protokolli:
agent = A2AAgent( name=agent_card.name, description=agent_card.description, agent_card=agent_card, url="https://your-a2a-agent-host" )
Agentide käivitamine
Agente käivitatakse .run
või .run_stream
meetodite abil, et saada kas mittevoogesituse või voogesituse vastuseid.
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)
Iga agendi käivitamisel saab kohandada parameetreid, nagu agendi kasutatavate max_tokens
arv, tools
, mida agent saab kasutada, ja isegi agendi kasutatavat model
.
See on kasulik olukordades, kus konkreetseid mudeleid või tööriistu on vaja kasutaja ülesande täitmiseks.
Tööriistad
Tööriistu saab määratleda nii agendi loomisel:
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."
# When creating a ChatAgent directly
agent = ChatAgent( chat_client=OpenAIChatClient(), instructions="You are a helpful assistant", tools=[get_attractions]
kui ka agendi käivitamisel:
result1 = await agent.run( "What's the best place to visit in Seattle?", tools=[get_attractions] # Tool provided for this run only )
Agendi lõimed
Agendi lõimed võimaldavad mitme pöördega vestlusi. Lõime saab luua kas:
get_new_thread()
, mis võimaldab lõime aja jooksul salvestada.Lõime loomiseks näeb kood välja selline:
# Create a new thread.
thread = agent.get_new_thread() # Run the agent with the thread.
response = await agent.run("Hello, I am here to help you book travel. Where would you like to go?", thread=thread)
Seejärel saab lõime serialiseerida, et seda hiljem kasutada:
# Create a new thread.
thread = agent.get_new_thread()
# Run the agent with the thread.
response = await agent.run("Hello, how are you?", thread=thread)
# Serialize the thread for storage.
serialized_thread = await thread.serialize()
# Deserialize the thread state after loading from storage.
resumed_thread = await agent.deserialize_thread(serialized_thread)
Agendi vahevara
Agendid suhtlevad tööriistade ja LLM-idega, et täita kasutaja ülesandeid. Teatud olukordades soovime nende interaktsioonide vahel midagi täita või jälgida. Agendi vahevara võimaldab meil seda teha:
Funktsiooni vahevara
See vahevara võimaldab meil täita toimingut agendi ja funktsiooni/tööriista vahel, mida ta kutsub. Näiteks võib seda kasutada funktsiooni kutse logimiseks.
Allolevas koodis määratleb next
, kas tuleks kutsuda järgmine vahevara või tegelik funktsioon.
async def logging_function_middleware(
context: FunctionInvocationContext,
next: Callable[[FunctionInvocationContext], Awaitable[None]],
) -> None:
"""Function middleware that logs function execution."""
# Pre-processing: Log before function execution
print(f"[Function] Calling {context.function.name}")
# Continue to next middleware or function execution
await next(context)
# Post-processing: Log after function execution
print(f"[Function] {context.function.name} completed")
Vestluse vahevara
See vahevara võimaldab meil täita või logida toimingut agendi ja LLM-i vaheliste päringute vahel.
See sisaldab olulist teavet, nagu messages
, mis saadetakse AI teenusele.
async def logging_chat_middleware(
context: ChatContext,
next: Callable[[ChatContext], Awaitable[None]],
) -> None:
"""Chat middleware that logs AI interactions."""
# Pre-processing: Log before AI call
print(f"[Chat] Sending {len(context.messages)} messages to AI")
# Continue to next middleware or AI service
await next(context)
# Post-processing: Log after AI response
print("[Chat] AI response received")
Agendi mälu
Nagu käsitletud Agentic Memory
õppetükis, on mälu oluline element, mis võimaldab agendil töötada erinevates kontekstides. MAF pakub mitut tüüpi mälusid:
Mälu rakenduse sees
See on mälu, mis salvestatakse lõimedes rakenduse tööaja jooksul.
# Create a new thread.
thread = agent.get_new_thread() # Run the agent with the thread.
response = await agent.run("Hello, I am here to help you book travel. Where would you like to go?", thread=thread)
Püsivad sõnumid
See mälu kasutatakse vestluste ajaloo salvestamiseks erinevate sessioonide vahel. See määratletakse chat_message_store_factory
abil:
from agent_framework import ChatMessageStore
# Create a custom message store
def create_message_store():
return ChatMessageStore()
agent = ChatAgent(
chat_client=OpenAIChatClient(),
instructions="You are a Travel assistant.",
chat_message_store_factory=create_message_store
)
Dünaamiline mälu
See mälu lisatakse konteksti enne agentide käivitamist. Need mälud saab salvestada välisteenustesse, nagu mem0:
from agent_framework.mem0 import Mem0Provider
# Using Mem0 for advanced memory capabilities
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
)
Agendi jälgitavus
Jälgitavus on oluline usaldusväärsete ja hooldatavate agentlike süsteemide ehitamiseks. MAF integreerub OpenTelemetryga, et pakkuda jälgimist ja mõõdikuid parema jälgitavuse jaoks.
from agent_framework.observability import get_tracer, get_meter
tracer = get_tracer()
meter = get_meter()
with tracer.start_as_current_span("my_custom_span"):
# do something
pass
counter = meter.create_counter("my_custom_counter")
counter.add(1, {"key": "value"})
MAF pakub töövooge, mis on eelnevalt määratletud sammud ülesande täitmiseks ja sisaldavad AI agente komponentidena nendes sammudes.
Töövood koosnevad erinevatest komponentidest, mis võimaldavad paremat juhtimisvoogu. Töövood võimaldavad ka mitme agendi orkestreerimist ja kontrollpunktide loomist, et salvestada töövoo olekuid.
Töövoo põhikomponendid on:
Täitjad
Täitjad võtavad vastu sisendteateid, täidavad neile määratud ülesandeid ja toodavad seejärel väljundteateid. See viib töövoo edasi suurema ülesande täitmise suunas. Täitjad võivad olla kas AI agent või kohandatud loogika.
Servad
Servad määratlevad töövoo teabevoo. Need võivad olla:
Otsesed servad - Lihtsad üks-ühele ühendused täitjate vahel:
from agent_framework import WorkflowBuilder
builder = WorkflowBuilder()
builder.add_edge(source_executor, target_executor)
builder.set_start_executor(source_executor)
workflow = builder.build()
Tingimuslikud servad - Aktiveeritakse pärast teatud tingimuse täitmist. Näiteks kui hotellitoad pole saadaval, võib täitja soovitada muid võimalusi.
Switch-case servad - Suunavad teateid erinevatele täitjatele vastavalt määratletud tingimustele. Näiteks kui reisiklientidel on prioriteetne juurdepääs, käsitletakse nende ülesandeid teises töövoos.
Fan-out servad - Saadavad ühe teate mitmele sihtkohale.
Fan-in servad - Koguvad mitmeid teateid erinevatelt täitjatelt ja saadavad ühe sihtkohale.
Sündmused
Töövoogude parema jälgitavuse tagamiseks pakub MAF sisseehitatud sündmusi, mis hõlmavad:
WorkflowStartedEvent
- Töövoo täitmine algabWorkflowOutputEvent
- Töövoog toodab väljundiWorkflowErrorEvent
- Töövoog kohtab vigaExecutorInvokeEvent
- Täitja alustab töötlemistExecutorCompleteEvent
- Täitja lõpetab töötlemiseRequestInfoEvent
- Esitatakse päringLihtsustatud agentide loomine
Semantic Kernel nõuab iga agendi jaoks Kernel instantsi loomist. MAF kasutab lihtsustatud lähenemist, kasutades laiendusi peamiste teenusepakkujate jaoks.
agent = AzureOpenAIChatClient(credential=AzureCliCredential()).create_agent( instructions="You are good at reccomending trips to customers based on their preferences.", name="TripRecommender" )
Agendi lõime loomine
Semantic Kernel nõuab lõimede käsitsi loomist. MAF-is määratakse agentile otse lõim.
thread = agent.get_new_thread() # Run the agent with the thread.
Tööriistade registreerimine
Semantic Kernelis registreeritakse tööriistad Kernelile ja Kernel edastatakse seejärel agendile. MAF-is registreeritakse tööriistad otse agendi loomise käigus.
agent = ChatAgent( chat_client=OpenAIChatClient(), instructions="You are a helpful assistant", tools=[get_attractions]
Meeskonnad vs töövood
Teams
on sündmuste struktuur sündmustepõhise tegevuse jaoks agentidega AutoGenis. MAF kasutab Workflows
, mis suunavad andmeid täitjatele graafipõhise arhitektuuri kaudu.
Tööriistade loomine
AutoGen kasutab FunctionTool
, et pakkida funktsioone agentide jaoks. MAF kasutab @ai_function, mis toimib sarnaselt, kuid tuvastab automaatselt iga funktsiooni skeemid.
Agendi käitumine
Agendid on AutoGenis vaikimisi ühe pöördega agendid, kui max_tool_iterations
pole määratud kõrgemaks. MAF-is on ChatAgent
vaikimisi mitme pöördega, mis tähendab, et see jätkab tööriistade kutsumist, kuni kasutaja ülesanne on täidetud.
Koodinäited Microsoft Agent Frameworki kohta leiad sellest repositooriumist failides xx-python-agent-framework
ja xx-dotnet-agent-framework
.
Liitu Azure AI Foundry Discordiga, et kohtuda teiste õppijatega, osaleda vastuvõtuaegadel ja saada vastuseid oma AI agentide küsimustele.
Lahtiütlus:
See dokument on tõlgitud AI tõlketeenuse Co-op Translator abil. Kuigi püüame tagada täpsust, palume arvestada, et automaatsed tõlked võivad sisaldada vigu või ebatäpsusi. Algne dokument selle algses keeles tuleks pidada autoriteetseks allikaks. Olulise teabe puhul soovitame kasutada professionaalset inimtõlget. Me ei vastuta selle tõlke kasutamisest tulenevate arusaamatuste või valesti tõlgenduste eest.