Übersicht über die Agentarchitektur

In diesem Artikel werden wichtige Konzepte in der Architektur des Agent-Frameworks behandelt, darunter grundlegende Prinzipien, Designziele und strategische Ziele.

Ziele

Die Agent Framework wurde unter Berücksichtigung der folgenden Wichtigsten Prioritäten entwickelt:

• Das Semantische Kernel-Agent-Framework dient als Kerngrund für die Implementierung von Agentfunktionen.
• Mehrere Agents unterschiedlicher Typen können innerhalb einer einzigen Unterhaltung zusammenarbeiten, wobei jeder seine einzigartigen Funktionen beiträgt und gleichzeitig menschliche Eingaben integriert.
• Ein Agent kann mehrere gleichzeitige Unterhaltungen durchführen und verwalten.

Vertreter

Die abstrakte Agent Klasse dient als Kernstraktion für alle Arten von Agents und stellt eine grundlegende Struktur bereit, die erweitert werden kann, um spezialisiertere Agents zu erstellen. Diese Basisklasse bildet die Basis für spezifischere Agentimplementierungen, die alle die Funktionen des Kernels zum Ausführen ihrer jeweiligen Funktionen nutzen. Alle verfügbaren Agenttypen finden Sie im Abschnitt " Agenttypen ".

Agents können entweder direkt aufgerufen werden, um Aufgaben auszuführen, oder durch verschiedene Muster orchestriert werden. Diese flexible Struktur ermöglicht es Agenten, sich an verschiedene unterhaltungs- oder aufgabengesteuerte Szenarien anzupassen und Entwicklern robuste Tools zum Erstellen intelligenter, multi-agent-Systeme zu bieten.

Agenttypen im semantischen Kernel

• ChatCompletionAgent
• OpenAIAssistantAgent
• AzureAIAgent
• OpenAIResponsesAgent
• CopilotStudioAgent

Agentthread

Die abstrakte AgentThread Klasse dient als Kernabstraktion für Threads oder Gesprächszustand. Es abstrahiert die verschiedenen Möglichkeiten, wie der Gesprächszustand für verschiedene Agenten verwaltet werden kann.

Zustandsbehaftete Agentdienste speichern häufig den Unterhaltungsstatus im Dienst, und Sie können mit diesem über eine ID interagieren. Andere Agents erfordern möglicherweise, dass der gesamte Chatverlauf bei jedem Aufruf an den Agent übergeben wird. In diesem Fall wird der Unterhaltungsstatus lokal in der Anwendung verwaltet.

Zustandsorientierte Agenten funktionieren in der Regel nur mit einer passenden AgentThread Implementierung, während andere Arten von Agenten mit mehr als einem AgentThread Typ arbeiten können. Beispielsweise erfordert AzureAIAgent einen übereinstimmenden AzureAIAgentThread. Dies liegt daran, dass der Azure AI-Agent-Dienst Unterhaltungen im Dienst speichert und bestimmte Dienstaufrufe erfordert, um einen Thread zu erstellen und zu aktualisieren. Wenn ein anderer Agentthreadtyp mit dem AzureAIAgent verwendet wird, versagen wir schnell aufgrund eines unerwarteten Threadtyps und lösen eine Ausnahme aus, die den Aufrufer benachrichtigt.

Agent-Orchestrierung

Das Agent Orchestration Framework im semantischen Kernel ermöglicht die Koordination mehrerer Agents, komplexe Aufgaben gemeinsam zu lösen. Es bietet eine flexible Struktur zum Definieren der Interaktion von Agents, zum Teilen von Informationen und zum Delegieren von Verantwortlichkeiten. Zu den Kernkomponenten und Konzepten gehören:

• Orchestrierungsmuster: Vordefinierte Muster wie "Gleichzeitig", "Sequenzielle", "Übergabe", "Gruppenchat" und "Magentic" ermöglichen Entwicklern die Auswahl des am besten geeigneten Zusammenarbeitsmodells für ihr Szenario. Jedes Muster definiert eine andere Möglichkeit für Agents zum Kommunizieren und Verarbeiten von Aufgaben (details finden Sie in der Tabelle " Orchestrierungsmuster ").
• Datentransformationslogik: Eingabe- und Ausgabetransformationen ermöglichen die Anpassung von Daten zwischen Agenten und externen Systemen und unterstützen sowohl einfache als auch komplexe Datentypen.
• Human-in-the-loop: Einige Muster unterstützen das Konzept "Mensch in der Schleife", sodass menschliche Agenten am Orchestrierungsprozess teilnehmen können. Dies ist besonders nützlich für Szenarien, in denen menschliches Urteil oder Fachwissen erforderlich ist.

Mit dieser Architektur können Entwickler intelligente, multi-agent-Systeme erstellen, die reale Probleme durch Zusammenarbeit, Spezialisierung und dynamische Koordination bewältigen können.

Agentausrichtung mit semantischen Kerner-Funktionen

Dies Agent Framework basiert auf den grundlegenden Konzepten und Features, die viele Entwickler im Semantic Kernel-Ökosystem kennen. Diese Kernprinzipien dienen als Bausteine für den Entwurf des Agent-Frameworks. Durch die Nutzung der vertrauten Struktur und Funktionen des semantischen Kernels erweitert das Agent Framework seine Funktionalität, um erweiterte, autonome Agent-Verhaltensweisen zu ermöglichen und gleichzeitig die Konsistenz mit der breiteren Semantik-Kernelarchitektur aufrechtzuerhalten. Dadurch wird ein reibungsloser Übergang für Entwickler sichergestellt, sodass sie ihr vorhandenes Wissen anwenden können, um intelligente, anpassbare Agenten innerhalb des Frameworks zu erstellen.

Plugins und Funktionsaufrufe

Plugins sind ein grundlegender Aspekt des semantischen Kernels, sodass Entwickler benutzerdefinierte Funktionen integrieren und die Funktionen einer KI-Anwendung erweitern können. Diese Plug-Ins bieten eine flexible Möglichkeit, spezielle Features oder geschäftsspezifische Logik in die kernigen KI-Workflows zu integrieren. Darüber hinaus können Agent-Funktionen innerhalb des Frameworks erheblich verbessert werden, indem Plug-Ins verwendet und Funktionsaufrufe genutzt werden. Auf diese Weise können Agents dynamisch mit externen Diensten interagieren oder komplexe Aufgaben ausführen, um den Umfang und die Vielseitigkeit des KI-Systems in verschiedenen Anwendungen weiter zu erweitern.

Hier erfahren Sie, wie Sie Agenten zur Verwendung von Plug-Ins konfigurieren.

Agentnachrichten

Agent-Messaging, einschließlich Eingabe und Antwort, basiert auf den kernen Inhaltstypen des semantischen Kernels und stellt eine einheitliche Struktur für die Kommunikation bereit. Diese Designauswahl vereinfacht den Übergang von herkömmlichen Chat-Vervollständigungsmustern zu komplexeren agentgesteuerten Mustern in Ihrer Anwendungsentwicklung. Durch die Nutzung vertrauter Semantischer Kernel-Inhaltstypen können Entwickler Agent-Funktionen nahtlos in ihre Anwendungen integrieren, ohne vorhandene Systeme überarbeiten zu müssen. Diese Optimierung stellt sicher, dass das zugrunde liegende Framework konsistent bleibt, wenn Sie sich von grundlegender Konversations-KI zu autonomeren, aufgabenorientierten Agenten entwickeln, wodurch die Entwicklung schneller und effizienter wird.

Anwenden von Vorlagen

Die Rolle eines Agents wird in erster Linie durch die empfangenen Anweisungen geprägt, die sein Verhalten und seine Aktionen diktieren. Ähnlich wie beim Aufrufen einer Eingabeaufforderung können die Anweisungen eines KernelAgents vorlagenbasierte Parameter enthalten , sowohl Werte als auch Funktionen, die während der Ausführung dynamisch ersetzt werden. Dies ermöglicht flexible, kontextabhängige Antworten, sodass der Agent seine Ausgabe basierend auf Echtzeiteingaben anpassen kann.

Darüber hinaus kann ein Agent direkt mithilfe einer Eingabeaufforderungsvorlagenkonfiguration konfiguriert werden, sodass Entwickler eine strukturierte und wiederverwendbare Möglichkeit zum Definieren des Verhaltens erhalten. Dieser Ansatz bietet ein leistungsfähiges Tool zum Standardisieren und Anpassen von Agentenanweisungen, um Konsistenz in verschiedenen Anwendungsfällen zu gewährleisten und gleichzeitig die dynamische Anpassungsfähigkeit aufrechtzuerhalten.

Erfahren Sie hier mehr darüber, wie Sie einen Agent mit semantischer Kernel-Vorlage erstellen.

Deklarative Spezifikation

from semantic_kernel.agents import register_agent_type, Agent, DeclarativeSpecMixin

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

@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

Nächste Schritte