Dela via

En översikt över agentarkitekturen

Den här artikeln beskriver viktiga begrepp i agentramverkets arkitektur, inklusive grundläggande principer, designmål och strategiska mål.

Mål

Utvecklades Agent Framework med följande huvudprioriteringar i åtanke:

  • Semantic Kernel-agentramverket fungerar som den centrala grunden för att implementera agentfunktioner.
  • Flera agenter av olika typer kan samarbeta i en enda konversation, var och en bidrar med sina unika funktioner, samtidigt som mänskliga indata integreras.
  • En agent kan delta i och hantera flera samtidiga konversationer samtidigt.

Handläggare

Den abstrakta Agent klassen fungerar som kärnabstraktion för alla typer av agenter, vilket ger en grundläggande struktur som kan utökas för att skapa mer specialiserade agenter. Den här basklassen utgör grunden för mer specifika agentimplementeringar, som alla utnyttjar kernelns funktioner för att köra sina respektive funktioner. Se alla tillgängliga agenttyper i avsnittet Agenttyper .

Den underliggande semantiska kernelabstraktionen Agent finns här.

Den underliggande semantiska kernelabstraktionen Agent finns här.

Agenter kan antingen anropas direkt för att utföra uppgifter eller orkestreras av olika mönster. Med den här flexibla strukturen kan agenter anpassa sig till olika konversations- eller uppgiftsdrivna scenarier, vilket ger utvecklare robusta verktyg för att skapa intelligenta system med flera agenter.

Agenttyper i semantisk kernel

Agenttråd

Den abstrakta AgentThread klassen fungerar som kärnabstraktion för trådar eller konversationstillstånd. Den abstraherar bort de olika sätt på vilka konversationstillstånd kan hanteras för olika agenter.

Tillståndskänsliga agenttjänster lagrar ofta konversationstillstånd i tjänsten, och du kan interagera med det via ett ID. Andra agenter kan kräva att hela chatthistoriken skickas till agenten för varje anrop, i vilket fall konversationstillståndet hanteras lokalt i programmet.

Tillståndskänsliga agenter fungerar vanligtvis bara med en matchande AgentThreadimplementation, medan andra typer av agenter kan fungera med mer än en AgentThreadtyp. Till exempel kräver AzureAIAgent en matchande AzureAIAgentThread. Det beror på att Azure AI Agent-tjänsten lagrar konversationer i tjänsten och kräver specifika tjänstanrop för att skapa en tråd och uppdatera den. Om en annan agenttrådstyp används med AzureAIAgent, misslyckas vi snabbt på grund av en oväntad trådtyp och skapar ett undantag för att varna anroparen.

Agentorkestrering

Viktigt!

Agentorkestreringsfunktionerna i Agent Framework är i den experimentella fasen. De är under aktiv utveckling och kan ändras avsevärt innan de går vidare till förhandsversionen eller lanseringsfasen.

Anmärkning

Om du har använt AgentGroupChat orkestreringsmönstret bör du tänka på att det inte längre underhålls. Vi rekommenderar utvecklare att använda det nya GroupChatOrchestration mönstret. En migreringsguide finns här.

Ramverket agentorkestrering i semantisk kernel gör det möjligt att samordna flera agenter för att lösa komplexa uppgifter tillsammans. Det ger en flexibel struktur för att definiera hur agenter interagerar, delar information och delegerar ansvarsområden. De viktigaste komponenterna och begreppen är:

  • Orkestreringsmönster: Fördefinierade mönster som Concurrent, Sequential, Handoff, Group Chat och Magentic gör det möjligt för utvecklare att välja den lämpligaste samarbetsmodellen för sitt scenario. Varje mönster definierar ett annat sätt för agenter att kommunicera och bearbeta uppgifter (se tabellen Orkestreringsmönster för mer information).
  • Datatransformeringslogik: Med indata- och utdatatransformeringar kan orkestreringsflöden anpassa data mellan agenter och externa system, vilket stöder både enkla och komplexa datatyper.
  • Human-in-the-loop: Vissa mönster stöder human-in-the-loop, vilket gör det möjligt för mänskliga agenter att delta i orkestreringsprocessen. Detta är särskilt användbart för scenarier där mänsklig bedömning eller expertis krävs.

Den här arkitekturen ger utvecklare möjlighet att skapa intelligenta system med flera agenter som kan hantera verkliga problem genom samarbete, specialisering och dynamisk samordning.

Agentanpassning med semantiska kärnfunktioner

Agent Framework är byggt på de grundläggande koncept och funktioner som många utvecklare har lärt känna inom Semantic Kernel-ekosystemet. Dessa grundläggande principer fungerar som byggstenar för Agent Frameworks design. Genom att utnyttja den välbekanta strukturen och kapabiliteterna hos Semantic Kernel, utökar Agent Framework dess funktionalitet för att möjliggöra mer avancerade, autonoma agentbeteenden, samtidigt som det bibehåller enhetlighet med den bredare Semantic Kernel-arkitekturen. Detta säkerställer en smidig övergång för utvecklare, så att de kan använda sin befintliga kunskap för att skapa intelligenta, anpassningsbara agenter inom ramverket.

Plugin-program och funktionsanrop

Plugin-program är en grundläggande aspekt av semantisk kernel, vilket gör det möjligt för utvecklare att integrera anpassade funktioner och utöka funktionerna i ett AI-program. Dessa plugin-program erbjuder ett flexibelt sätt att införliva specialiserade funktioner eller affärsspecifik logik i ai-kärnarbetsflödena. Dessutom kan agentfunktioner inom ramverket förbättras avsevärt genom att använda plugin-program och använda funktionsanrop. Detta gör det möjligt för agenter att dynamiskt interagera med externa tjänster eller utföra komplexa uppgifter, vilket ytterligare utökar AI-systemets omfång och mångsidighet i olika program.

Lär dig hur du konfigurerar agenter för att använda plugin-program här.

Agentmeddelanden

Agentmeddelanden, inklusive både inmatning och svar, bygger på de grundläggande innehållstyperna i det Semantiska Kärnan och ger en enhetlig struktur för kommunikation. Det här designvalet förenklar övergången från traditionella chatt-kompletteringsmönster till mer avancerade agentdrivna mönster i din programutveckling. Genom att utnyttja välbekanta innehållstyper inom Semantic Kernel kan utvecklare sömlöst integrera agentfunktioner i sina applikationer utan att behöva göra om befintliga system. Den här effektiveringen säkerställer att när du utvecklas från grundläggande konversations-AI till mer autonoma, uppgiftsorienterade agenter förblir det underliggande ramverket konsekvent, vilket gör utvecklingen snabbare och effektivare.

Tips/Råd

API-referens:

Tips/Råd

API-referens:

Tips/Råd

API-referens:

Mallskapande

En agent roll formas främst av de instruktioner den tar emot, som dikterar dess beteende och åtgärder. På samma sätt som när en Kerneluppmaning anropas kan en agents instruktioner innehålla mallparametrar – både värden och funktioner – som ersätts dynamiskt under körningen. Detta möjliggör flexibla, sammanhangsmedvetna svar så att agenten kan justera sina utdata baserat på realtidsindata.

En agent kan även konfigureras direkt med hjälp av en promptmallskonfiguration, vilket ger utvecklare ett strukturerat och återanvändbart sätt att definiera dess beteende. Den här metoden erbjuder ett kraftfullt verktyg för att standardisera och anpassa agentinstruktioner, säkerställa konsekvens i olika användningsfall samtidigt som dynamisk anpassningsbarhet bibehålls.

Läs mer om hur du skapar en agent med semantisk kernelmall här.

Deklarativ specifikation

Dokumentationen om hur du använder deklarativa specifikationer kommer snart.

Viktigt!

Den här funktionen är i den experimentella fasen. Funktioner i det här skedet är under utveckling och kan komma att ändras innan de går vidare till förhandsversionen eller lanseringsfasen.

Registrera anpassade agenttyper

Om du vill använda en anpassad agent med det deklarativa YAML-specifikationssystemet måste du först registrera agentklassen med agentregistret. Detta krävs för att AgentRegistry kunna identifiera och konstruera din agent när du parsar type: fältet i YAML-specifikationen.

Om du vill registrera en anpassad agenttyp använder du dekoratören @register_agent_type :

from semantic_kernel.agents import register_agent_type, Agent, DeclarativeSpecMixin

@register_agent_type("custom_agent")
class CustomAgent(DeclarativeSpecMixin, Agent):
    ...

Strängen som tillhandahålls till dekoratören (till exempel "custom_agent") måste matcha fältet type: i YAML-specifikationen.

När den har registrerats kan din anpassade agent instansieras med hjälp av deklarativt mönster, till exempel via AgentRegistry.create_from_yaml(...).

DeclarativeSpecMixin Lägger till stöd för metoder som from_yaml, from_dictoch resolve_placeholders, som gör att agenten kan konstrueras från en YAML- eller ordlistespecifikation:

@classmethod
async def from_yaml(cls, yaml_str: str, *, kernel=None, plugins=None, prompt_template_config=None, settings=None, extras=None, **kwargs):
    # Resolves placeholders and loads YAML, then delegates to from_dict.
    ...

@classmethod
async def from_dict(cls, data: dict, *, kernel=None, plugins=None, prompt_template_config=None, settings=None, **kwargs):
    # Normalizes and passes spec fields to _from_dict.
    ...

@classmethod
@abstractmethod
async def _from_dict(cls, data: dict, *, kernel, prompt_template_config=None, **kwargs):
    # Subclasses implement this to create the agent from a dict.
    ...

@classmethod
def resolve_placeholders(cls, yaml_str: str, settings=None, extras=None) -> str:
    # Optional: override this to customize how environment or runtime placeholders are resolved in YAML.
    return yaml_str

Tips/Råd

Alla anpassade agenter måste ärva från DeclarativeSpecMixin för att aktivera YAML-baserad konstruktion och måste registreras med registret med hjälp av @register_agent_type.

Den här funktionen är inte tillgänglig.

Nästa steg

Utforska Common Agent Invocation API