Microsoft Intro to AI Agent: Erkundung des AI Agent Framework

KI-Agenten-Frameworks sind Softwareplattformen, die die Erstellung, den Einsatz und die Verwaltung von KI-Agenten vereinfachen sollen. Diese Frameworks bieten Entwicklern vorgefertigte Komponenten, Abstraktionen und Werkzeuge, um die Entwicklung komplexer KI-Systeme zu vereinfachen.

Diese Frameworks helfen den Entwicklern, sich auf die einzigartigen Aspekte ihrer Anwendungen zu konzentrieren, indem sie einen standardisierten Ansatz für allgemeine Herausforderungen bei der Entwicklung von KI-Agenten bieten. Sie verbessern die Skalierbarkeit, Zugänglichkeit und Effizienz der Entwicklung von KI-Systemen.

kurz

Dieser Kurs behandelt:

• Was sind KI-Agenten-Frameworks und welche Möglichkeiten bieten sie Entwicklern?
• Wie können Teams diese Frameworks nutzen, um schnell Prototypen zu erstellen, zu iterieren und die Fähigkeiten von Agent zu verbessern?
• Was ist der Unterschied zwischen den von Microsoft AutoGen, Semantic Kernel und Azure AI Agent entwickelten Frameworks und Tools?
• Ist eine direkte Integration in bestehende Azure-Ökosystem-Tools möglich oder benötige ich eine eigenständige Lösung?
• Was ist der Azure AI Agents Service und wie kann er helfen?

Lernziel

Das Ziel dieses Kurses ist es, Ihnen zu helfen, zu verstehen:

• Die Rolle von KI-Agenten-Rahmenwerken in der KI-Entwicklung.
• Wie man mit dem AI Agent Framework intelligente Agenten entwickelt.
• Die wichtigsten Funktionen des AI Agent Frameworks.
• Unterschiede zwischen AutoGen, Semantic Kernel und Azure AI Agent Service.

Was sind KI-Agenten-Frameworks und welche Möglichkeiten bieten sie Entwicklern?

Herkömmliche KI-Frameworks können Ihnen dabei helfen, KI in Ihre Anwendungen zu integrieren und diese Anwendungen dadurch zu verbessern:

• PersonalisierteKI kann das Nutzerverhalten und die Vorlieben analysieren, um personalisierte Empfehlungen, Inhalte und Erlebnisse zu liefern. Streaming-Dienste wie Netflix beispielsweise nutzen KI, um Filme und Serien auf der Grundlage des Nutzungsverhaltens zu empfehlen und so das Engagement und die Zufriedenheit der Nutzer zu steigern.
• Automatisierung und EffizienzKI kann sich wiederholende Aufgaben automatisieren, Arbeitsabläufe rationalisieren und die betriebliche Effizienz verbessern. In Kundendienstanwendungen werden beispielsweise KI-gesteuerte Chatbots eingesetzt, um häufige Anfragen zu bearbeiten, die Antwortzeiten zu verkürzen und es den menschlichen Mitarbeitern zu ermöglichen, komplexere Probleme zu lösen.
• Verbessertes BenutzererlebnisKI: KI kann das Nutzererlebnis insgesamt verbessern, indem sie intelligente Funktionen wie Spracherkennung, Verarbeitung natürlicher Sprache und Textvorhersage bietet. So nutzen beispielsweise virtuelle Assistenten wie Siri und Google Assistant KI, um Sprachbefehle zu verstehen und darauf zu reagieren, was den Nutzern die Interaktion mit ihren Geräten erleichtert.

Das klingt alles großartig, oder? Warum brauchen wir also ein KI-Agenten-Framework?

KI-Agent-Frameworks sind mehr als nur KI-Frameworks. Sie wurden entwickelt, um intelligente Agenten zu schaffen, die mit dem Benutzer, anderen Agenten und der Umgebung interagieren können, um bestimmte Ziele zu erreichen, und die ein autonomes Verhalten zeigen, Entscheidungen treffen und sich an veränderte Bedingungen anpassen können. Werfen wir einen Blick auf einige der wichtigsten Funktionen, die von KI-Agent-Frameworks implementiert werden:

• Agent Zusammenarbeit und KoordinationUnterstützt die Erstellung mehrerer KI-Agenten, die zusammenarbeiten, kommunizieren und koordinieren können, um komplexe Aufgaben zu lösen.
• Automatisierung und Verwaltung von AufgabenBietet Mechanismen zur Automatisierung von mehrstufigen Arbeitsabläufen, zur Aufgabendelegation und zum dynamischen Aufgabenmanagement zwischen Agenten.
• Verständnis des Kontextes und AnpassungErmöglicht es dem Agenten, den Kontext zu verstehen, sich an veränderte Umgebungen anzupassen und Entscheidungen auf der Grundlage von Echtzeitinformationen zu treffen.

Kurz gesagt: Agenten ermöglichen es Ihnen, mehr zu tun, die Automatisierung auf die nächste Stufe zu heben und intelligentere Systeme zu schaffen, die sich an ihre Umgebung anpassen und von ihr lernen können.

Wie kann ich schnell Prototypen erstellen, iterieren und die Fähigkeiten von Agent verbessern?

Es handelt sich um ein sich schnell entwickelndes Feld, aber die meisten KI-Agenten-Frameworks haben ein paar Dinge gemeinsam, die Ihnen helfen können, Prototypen zu erstellen und schnell zu iterieren, nämlich modulare Komponenten, Tools für die Zusammenarbeit und Echtzeitlernen. Lassen Sie uns in diese eintauchen:

• Verwendung modularer KomponentenDas AI Framework bietet vorgefertigte Komponenten wie Hinweise, Parser und Speicherverwaltung.
• Nutzung von Tools zur ZusammenarbeitDesign Agents mit spezifischen Rollen und Aufgaben, damit sie kollaborative Arbeitsabläufe testen und verbessern können.
• Lernen in EchtzeitEs wird eine Rückkopplungsschleife erreicht, in der der Agent aus der Interaktion lernt und sein Verhalten dynamisch anpasst.

Verwendung modularer Komponenten

Frameworks wie LangChain und Microsoft Semantic Kernel bieten vorgefertigte Komponenten wie Hints, Parser und Speicherverwaltung.

Wie nutzen die Teams dieseTeams können diese Komponenten schnell zusammensetzen, um einen funktionalen Prototyp zu erstellen, ohne bei Null anfangen zu müssen, was schnelle Experimente und Iterationen ermöglicht.

Wie es in der Praxis funktioniertSie können vorgefertigte Parser verwenden, um Informationen aus Benutzereingaben zu extrahieren, In-Memory-Module, um Daten zu speichern und abzurufen, und Prompt-Generatoren, um mit Benutzern zu interagieren, ohne dass Sie diese Komponenten von Grund auf neu erstellen müssen.

Beispielcode (Rechnen). Sehen wir uns ein Beispiel dafür an, wie Informationen aus Benutzereingaben mithilfe eines vorgefertigten Parsers extrahiert werden können:

// Semantischer Kernel Beispiel
ChatHistory chatHistory = [];
chatHistory.AddUserMessage("Ich würde gerne nach New York reisen");
// Definieren Sie ein Plugin mit Reisebuchungsfunktionalität.
public class BookTravelPlugin(
IPizzaService pizzaService,
IPizzaService pizzaService, IUserContext userContext, IPaymentService paymentService, IPaymentService paymentService
IPaymentService paymentService)
{
[KernelFunction("book_flight")]
[Beschreibung("Buchen Sie eine Reise für einen bestimmten Ort und ein bestimmtes Datum")]]
public async Task BookFlight(
BookFlight() [Beschreibung("Buchen Sie eine Reise mit Angabe von Ort und Datum")] public async Task
string location, ) public async Task BookFlight(
)
{
// Buchen Sie eine Reise basierend auf Datum und Ort
}
}
IKernelBuilder kernelBuilder = new KernelBuilder();
kernelBuilder..AddAzureOpenAIChatCompletion(
deploymentName: "NAME_IHRER_DEPLOYMENT",
apiKey: "IHR_API_KEY",
endpoint: "IHR_AZURE_ENDPOINT"
);
kernelBuilder.Plugins.AddFromType("BookTravel");
Kernel Kernel = KernelBuilder.Build();
/*
Im Hintergrund werden das aufzurufende Tool, die bereits vorhandenen Parameter (Ort) und die benötigten Parameter (Datum) ermittelt
{
"tool_calls": [
{
"id": "call_abc123",
"type": "function", [ { "function": { "call_abc123", "type": "function", "function": {
"function": {
"name": "BookTravelPlugin-book_flight", "arguments":"{\nbsp "location": {
"arguments":"{\n\"location\": \"New York\",\n\"date\": \"\"\n}"
}
}
]
*/
ChatResponse response = await chatCompletion.GetChatMessageContentAsync(
GetChatMessageContentAsync(
executionSettings: openAIPromptExecutionSettings,
kernel: kernel)
Console.WriteLine(response);
chatHistory.AddAssistantMessage(response);
// KI-Antwort: "Bevor ich Ihren Flug buchen kann, muss ich Ihr Abflugdatum wissen. Wann planen Sie zu reisen?"
// Das bedeutet, dass die KI im vorherigen Code herausfindet, welches Tool sie aufrufen muss, welchen Parameter sie bereits hat (Ort) und welchen Parameter sie aus der Benutzereingabe benötigt (Datum), und schließlich den Benutzer nach den fehlenden Informationen fragt

Anhand dieses Beispiels können Sie sehen, wie ein vorgefertigter Parser verwendet werden kann, um Schlüsselinformationen aus Benutzereingaben zu extrahieren, z. B. den Abflugort, das Ziel und das Datum einer Flugbuchungsanfrage. Dieser modulare Ansatz ermöglicht es Ihnen, sich auf die High-Level-Logik zu konzentrieren.

Nutzung von Tools zur Zusammenarbeit

CrewAI und Microsoft AutoGen Rahmenwerke wie dieses erleichtern die Schaffung von mehreren Agenten, die zusammenarbeiten können.

Wie nutzen die Teams dieseTeams können Agenten mit bestimmten Rollen und Aufgaben ausstatten, um gemeinsame Arbeitsabläufe zu testen und zu verbessern und die Effizienz des Systems insgesamt zu steigern.

Wie es in der Praxis funktioniertAgenten: Sie können ein Team von Agenten bilden, von denen jeder eine spezielle Funktion hat, z. B. Datenabfrage, Analyse oder Entscheidungsfindung. Diese Agenten können kommunizieren und Informationen austauschen, um gemeinsame Ziele zu erreichen, z. B. die Beantwortung von Benutzeranfragen oder die Erledigung von Aufgaben.

Beispielcode (AutoGen)::

# erstellt den Agenten und erstellt dann einen Round-Robin-Zeitplan, damit sie zusammenarbeiten können, in diesem Fall nacheinander
# Datenabruf-Agent
# Datenanalyse-Agent
# Entscheidungsfindungs-Agent
agent_retrieve = AssistantAgent(
name="dataretrieval",
model_client=model_client,
tools=[abrufen_tool],
system_message="Verwenden Sie Werkzeuge zur Lösung von Aufgaben."
)
agent_analyze = AssistantAgent(
name="dataanalysis",
model_client=model_client,
tools=[analyze_tool],
system_message="Verwenden Sie Werkzeuge zur Lösung von Aufgaben."
)
# Der Dialog endet, wenn der Benutzer "APPROVE" sagt
termination = TextMentionTermination("APPROVE")
user_proxy = UserProxyAgent("user_proxy", input_func=input)
team = RoundRobinGroupChat([agent_retrieve, agent_analyze, user_proxy], termination_condition=termination)
stream = team.run_stream(task="Daten analysieren", max_turns=10)
# Ausführung im Skript mit asyncio.run(...) asyncio.run(...)
await Konsole(stream)

Im vorangegangenen Code haben Sie gesehen, wie man eine Aufgabe erstellt, bei der mehrere Agenten zusammenarbeiten, um Daten zu analysieren. Jeder Agent führt eine bestimmte Funktion aus und koordiniert die Agenten, um die Aufgabe auszuführen und die gewünschten Ergebnisse zu erzielen. Durch die Erstellung dedizierter Agenten mit spezialisierten Rollen können Sie die Effizienz und Leistung der Aufgabe verbessern.

Lernen in Echtzeit

Das Advanced Framework bietet kontextbezogenes Verständnis und Anpassung in Echtzeit.

Wie Teams diese Rahmenwerke nutzenTeams können Feedback-Schleifen implementieren, die es den Agenten ermöglichen, aus Interaktionen zu lernen und ihr Verhalten dynamisch anzupassen, was zu einer kontinuierlichen Verbesserung und Verfeinerung der Fähigkeiten führt.

praktische AnwendungAgenten können Benutzerfeedback, Umgebungsdaten und Aufgabenergebnisse analysieren, um ihre Wissensbasis zu aktualisieren, Entscheidungsalgorithmen anzupassen und die Leistung im Laufe der Zeit zu verbessern. Dieser iterative Lernprozess ermöglicht es den Agenten, sich an veränderte Bedingungen und Benutzerpräferenzen anzupassen und so die Effizienz des Systems insgesamt zu verbessern.

Was ist der Unterschied zwischen AutoGen, Semantic Kernel und dem Azure AI Agent Service Framework?

Es gibt viele Möglichkeiten, diese Frameworks zu vergleichen, aber lassen Sie uns einige Hauptunterschiede in Bezug auf ihr Design, ihre Funktionalität und ihre Zielanwendungsfälle betrachten:

AutoGen

Open-Source-Framework, entwickelt vom Microsoft Research's AI Frontiers Lab. Konzentriert sich auf ereignisgesteuerte, verteilte agentisch Anwendungen, die mehrere Large Language Models (LLMs) und SLMs, Tools und fortgeschrittene Multi-Agent-Designmuster unterstützen.

Das Kernkonzept von AutoGen sind Agenten, d. h. autonome Einheiten, die ihre Umgebung wahrnehmen, Entscheidungen treffen und Maßnahmen ergreifen können, um bestimmte Ziele zu erreichen. Agenten kommunizieren über asynchrone Nachrichtenübermittlung, so dass sie unabhängig und parallel arbeiten können, was die Skalierbarkeit und Reaktionsfähigkeit des Systems erhöht.

Agenten basieren auf Akteursmodellen. Laut Wikipedia ist ein Schauspieler Die grundlegenden Bausteine gleichzeitiger Berechnungen. Als Reaktion auf eine eingehende Nachricht kann ein Akteur: lokale Entscheidungen treffen, weitere Akteure erstellen, weitere Nachrichten senden und festlegen, wie er auf die nächste eingehende Nachricht reagieren soll..

AnwendungsfallAutomatisieren Sie die Codegenerierung, Datenanalyseaufgaben und erstellen Sie benutzerdefinierte Intelligenzen (Agenten) für Planungs- und Forschungsfunktionen.

Hier sind einige der wichtigsten Kernkonzepte von AutoGen:

• Agenten. Ein intelligenter Körper (Agent) ist eine Softwareeinheit, die:
  • Kommunikation über NachrichtenDiese Nachrichten können synchron oder asynchron sein.
  • Aufrechterhaltung des eigenen StatusDieser Zustand kann durch eingehende Nachrichten verändert werden.
  • ausführbare Operation als Reaktion auf eine empfangene Nachricht oder eine Änderung seines Zustands. Diese Aktionen können den Zustand des Agenten ändern und externe Auswirkungen haben, wie z. B. das Aktualisieren des Nachrichtenprotokolls, das Senden neuer Nachrichten, das Ausführen von Code oder das Durchführen von API-Aufrufen.

  Nachfolgend finden Sie einen kurzen Codeschnipsel, mit dem Sie einen Agenten mit Chatfunktion erstellen können:

  from autogen_agentchat.agents import AssistantAgent
  from autogen_agentchat.messages import TextMessage
  from autogen_ext.models.openai import OpenAIChatCompletionClient
  class MyAssistant(RoutedAgent).
  def __init__(self, name: str) -> None.
  __init__(name) -> None: super(). __init__(name)
  model_client = OpenAIChatCompletionClient(model="gpt-4o")
  self._delegate = AssistantAgent(name, model_client=model_client)
      @message_handler
  async def handle_my_message_type(self, message: MyMessageType, ctx: MessageContext) -> None:
  print(f"{self.id.type} received message: {message.content}")
  response = await self._delegate.on_messages(
  [TextMessage(content=message.content, source="user")], ctx.cancellation_token
  )
  print(f"{self.id.type} Antwort: {response.chat_message.content}")
  

  Im vorangegangenen Code ist dieMyAssistant wurde erstellt und geerbt von RoutedAgent. Es hat einen Message-Handler, der den Inhalt der Nachricht ausgibt und dann die AssistentinAgentin Delegieren Sie das Senden der Antwort. Achten Sie besonders darauf, wie wir die Übertragung der AssistentinAgentin Die Instanz des selbst._Beauftragter(math.) GattungAssistentinAgentin ist eine vorgefertigte Intelligenz (Agent), die mit Chat-Ergänzungen umgehen kann.
  Als nächstes teilen Sie AutoGen den Agententyp mit und starten das Programm:

  # main.py
  runtime = SingleThreadedAgentRuntime()
  await MyAgent.register(runtime, "my_agent", lambda: MyAgent())
  runtime.start() # Verarbeitung von Nachrichten im Hintergrund starten.
  await runtime.send_message(MyMessageType("Hallo, Welt!"), AgentId("my_agent", "default"))
  

  Im vorangegangenen Code werden Agenten bei der Laufzeitumgebung registriert, und anschließend werden Nachrichten an den Agenten gesendet, der die folgende Ausgabe erzeugt:

  # Ausgabe auf der Konsole.
  my_agent empfängt Nachricht: Hallo, Welt!
  my_assistant empfing Nachricht: Hallo, Welt!
  my_assistant antwortet: Hallo! Wie kann ich Ihnen heute helfen?
  

• MehrfachagentenAutoGen unterstützt die Erstellung mehrerer Agenten, die zusammenarbeiten können, um komplexe Aufgaben zu bewältigen. Agenten können kommunizieren, Informationen austauschen und ihre Aktionen koordinieren, um Probleme effektiver zu lösen. Um ein Multi-Agenten-System zu erstellen, definieren Sie verschiedene Arten von Agenten mit speziellen Funktionen und Rollen, z. B. Datenabfrage, Analyse, Entscheidungsfindung und Benutzerinteraktion. Schauen wir uns an, wie eine solche Kreation aussieht, damit wir sie verstehen können:

editor_description = "Redakteur für die Planung und Überprüfung des Inhalts".
# Beispiel für die Deklaration eines Agenten
editor_agent_type = await EditorAgent.register(
editor_topic_type, # Beispiel für die Deklaration eines Agenten = await EditorAgent.register(
editor_topic_type, # Verwendung des Thementyps als Agententyp.
lambda: EditorAgent(
description=editor_description,
description=editor_description, group_chat_topic_type=group_chat_topic_type, model_client=OpenAgent.register( runtime.
model_client=OpenAIChatCompletionClient(
model="gpt-4o-2024-08-06",
# api_key="YOUR_API_KEY",
),
),
), ), )
# übrige Deklarationen der Kürze halber gekürzt
# Gruppenchat
group_chat_manager_type = await GroupChatManager.register(
runtime, "group_chat_manager_type
"group_chat_manager",
lambda: GroupChatManager(
participant_topic_types=[writer_topic_type, illustrator_topic_type, editor_topic_type, user_topic_type],
model_client=OpenAIChatCompletionClient(
model="gpt-4o-2024-08-06",
# api_key="YOUR_API_KEY",
),
teilnehmer_beschreibungen=[
writer_description,
illustrator_description,
editor_description,
user_description
],
), )
)

Im vorherigen Code haben wir eine GroupChatManagerEr ist bei der Laufzeitumgebung registriert. Dieser Manager ist für die Koordinierung der Interaktionen zwischen verschiedenen Arten von Agenten, wie Autoren, Illustratoren, Redakteuren und Benutzern, zuständig.

• Agent LaufzeitDas Framework bietet eine Laufzeitumgebung, die die Kommunikation zwischen Agenten unterstützt und Grenzen für Sicherheit und Datenschutz durchsetzt. Das Framework bietet eine Laufzeitumgebung, die die Kommunikation zwischen Agenten unterstützt, ihre Identität und ihren Lebenszyklus verwaltet und Sicherheits- und Datenschutzgrenzen durchsetzt. Dies bedeutet, dass Sie Ihre Agenten in einer sicheren und kontrollierten Umgebung ausführen können, um sicherzustellen, dass sie sicher und effizient interagieren können. Es gibt zwei Laufzeiten, die von Interesse sind:
  • Eigenständige LaufzeitDies ist eine gute Wahl für Einzelprozessanwendungen, bei denen alle Agenten in der gleichen Programmiersprache implementiert sind und im gleichen Prozess ausgeführt werden. Dies ist eine gute Wahl für Einzelprozessanwendungen, bei denen alle Agenten in der gleichen Programmiersprache implementiert sind und im gleichen Prozess ausgeführt werden. Das folgende Diagramm zeigt, wie es funktioniert:
    Eigenständige Laufzeit
    Anwendungsstapel
    Agenten kommunizieren über Nachrichten durch die Laufzeitumgebung, die den Lebenszyklus der Agenten verwaltet.
  • Verteilte AgentenlaufzeitDies gilt für Multiprozess-Anwendungen, bei denen Agenten in verschiedenen Programmiersprachen implementiert werden können und auf verschiedenen Rechnern laufen. Hier ist eine Illustration, wie es funktioniert:
    Verteilte Laufzeit

Semantischer Kernel + Agent Framework

Der Semantic Kernel besteht aus zwei Teilen, dem Semantic Kernel Agent Framework und dem Semantic Kernel selbst.

Lassen Sie uns kurz über den Semantic Kernel sprechen, der die folgenden Kernkonzepte umfasst:

• VerbindungenSchnittstelle zu externen KI-Diensten und Datenquellen.

using Microsoft.SemanticKernel; // Kernel erstellen.
// Kernel erstellen
var builder = Kernel.CreateBuilder(); // Einen Chatvervollständigungsdienst hinzufügen.
// Einen Chatvervollständigungsdienst hinzufügen: builder.Services.AddAzureOpenAIChatCompletion()
builder.Services.AddAzureOpenAIChatCompletion()

"Ihr-Ressourcen-Name", "Ihr-Endpunkt", "Ihr-Ressourcen-Schlüssel",
"Ihr-Ressourcen-Schlüssel",
"deployment-model"); var kernel = builder.
var kernel = builder.Build();

Der Semantic Kernel erstellt eine Verbindung zu einem externen KI-Dienst, in diesem Fall Azure OpenAI Chat Completion.

• PluginsPlugin: Kapselt Funktionen, die eine Anwendung verwenden kann. Es gibt sowohl fertige Plug-ins als auch Plug-ins, die Sie selbst erstellen können. Es gibt ein Konzept namens Semantische Funktionen. Semantisch ist es deshalb, weil Sie es mit semantischen Informationen versehen, damit der Semantische Kernel feststellen kann, dass er die Funktion aufrufen muss. Hier ist ein Beispiel:

var userInput = Console.ReadLine(); // Semantische Funktion inline definieren.
// Semantische Funktion inline definieren.
string skPrompt = @"Fassen Sie die Angaben zusammen unstrukturiert Text in einem Satz, der leicht zu verstehen ist.
Text zum Zusammenfassen: {{$userInput}}"; // Registrieren Sie die Funktion.
// Registrieren Sie die Funktion
kernel.CreateSemanticFunction(
promptTemplate: skPrompt, functionName: "Summarize"; // Registrieren Sie die Funktion kernel.CreateSemanticFunction(

pluginName: "SemantischeFunktionen"
).

Hier beginnen Sie mit einem Vorlagentipp skPromptEs überlässt dem Benutzer die Eingabe von Text $userInput Bereich des Plugins. Sie verwenden dann das Plugin SemantischeFunktionen eingetragene Funktion Text zusammenfassen. Beachten Sie den Namen der Funktion, der dem Semantischen Kernel hilft zu verstehen, was die Funktion tut und wann sie aufgerufen werden soll.

• Einheimische FunktionEs gibt auch native Funktionen, die das Framework direkt aufrufen kann, um Aufgaben zu erfüllen. Nachfolgend ein Beispiel für solche Funktionen, die Inhalte aus einer Datei abrufen:

public class NativeFunctions {
[SKFunction, Description("Inhalt aus lokaler Datei abrufen")]
public async Task RetrieveLocalFile(string fileName, int maxSize = 5000)
{
string content = await File.ReadAllTextAsync(fileName); if (content.Length = max = 5000, int maxSize = 5000); if (content.
if (content.Length <= maxSize) return content; return content.
return content.Substring(0, maxSize); return content.
}
}
//Native Funktion importieren
string plugInName = "NativeFunction"; string functionName = "RetrieveLocalFile"; //Importiere native Funktion.
string functionName = "RetrieveLocalFile"; var nativeFunctions = new NativeFunctions(); //Importiere native Funktion.
var nativeFunctions = new NativeFunctions(); kernel.
kernel.ImportFunctions(nativeFunctions, plugInName); var nativeFunctions = new NativeFunctions(); kernel.

• PlanerPlaner: Der Planer orchestriert Ausführungspläne und Richtlinien auf der Grundlage von Benutzereingaben. Die Idee besteht darin, auszudrücken, wie die Ausführung erfolgen soll, und dies dann zu einer Anweisung für den Semantic Kernel zu machen. Dieser ruft dann die notwendigen Funktionen auf, um die Aufgaben auszuführen. Im Folgenden finden Sie ein Beispiel für einen solchen Plan:

string planDefinition = "Inhalt aus einer lokalen Datei lesen und zusammenfassen.";
SequentialPlanner sequentialPlanner = new SequentialPlanner(kernel); string assetsFolder = @"....
string assetsFolder = @"... /... /assets"; string fileName = Path.
string fileName = Path.Combine(assetsFolder, "docs", "06_SemanticKernel", "aci_documentation.txt");
ContextVariables contextVariables = new ContextVariables();
contextVariables.Add("fileName", fileName); var customPlan = await sequentialPlan(); var customPlan = await sequentialPlan()
var customPlan = await sequentialPlanner.CreatePlanAsync(planDefinition); // Führen Sie den Plan aus.
// Ausführen des Plans
KernelResult kernelResult = await kernel.RunAsync(contextVariables, customPlan); // Ausführen des Plans.
Console.WriteLine($ "Zusammenfassung: {kernelResult.GetValue()}");

besondere Aufmerksamkeit planDefinitiondas ist die einfache Anweisung, der der Planer folgt. Die entsprechende Funktion wird dann gemäß diesem Plan aufgerufen, in diesem Fall unsere semantische Funktion Text zusammenfassen und einheimische Funktionen RetrieveLocalFile.

• SpeicherAbstraktion und Vereinfachung der Kontextverwaltung für KI-Anwendungen. Die Idee des Speichers ist, dass dies etwas ist, das das Large Language Model (LLM) wissen sollte. Sie können diese Informationen in einem Vektorspeicher speichern, der schließlich zu einer In-Memory-Datenbank oder einer Vektordatenbank oder etwas Ähnlichem wird. Hier ist ein sehr vereinfachtes Beispiel für ein Szenario, in dem die Fakten wird dem Speicher hinzugefügt:

var facts = new Dictionary();
facts.Add(
"Azure Machine Learning; https://learn.microsoft.com/azure/machine-learning/", @"Azure Machine Learning ist ein Cloud-Dienst zur Beschleunigung und
@"Azure Machine Learning ist ein Cloud-Dienst zur Beschleunigung und
Fachleute für maschinelles Lernen, Datenwissenschaftler und Ingenieure können ihn nutzen, um den Lebenszyklus von maschinellen Lernprojekten zu beschleunigen und zu verwalten.
Fachleute für maschinelles Lernen, Datenwissenschaftler und Ingenieure können ihn in ihren täglichen Arbeitsabläufen nutzen"
);
facts.Add(
"Azure SQL Service; https://learn.microsoft.com/azure/azure-sql/", @"Azure SQL ist ein neuer Dienst;"; facts.Add(
@"Azure SQL ist eine Familie von verwalteten, sicheren und intelligenten Produkten
die die SQL Server-Datenbank-Engine in der Azure-Cloud nutzen."
); string memoryCollectionName = "Azure SQL Service; ".
string memoryCollectionName = "SummarisedAzureDocs"; foreach (var fact in facts)
foreach (var fact in facts) {
await memoryBuilder.SaveReferenceAsync(
Sammlung: memoryCollectionName,
description: fact.Key.Split(";")[1].Trim(),
text: fact.Value, externalId: fact.Key.

externalSourceName: "Azure Dokumentation"
);
}

Die Fakten werden dann in der Speichersammlung gespeichert ZusammengefassteAzureDocs im Speicher. Dies ist ein sehr vereinfachtes Beispiel, aber Sie können sehen, wie Informationen im Speicher zur Verwendung im Large Language Model (LLM) gespeichert werden können.

Das sind die Grundlagen des Semantic Kernel Frameworks, was ist mit dem Agent Framework?

Azure AI Agent Service

Der Azure AI Agent Service ist ein neueres Mitglied, das auf der Microsoft Ignite 2024 vorgestellt wurde. Er ermöglicht die Entwicklung und Bereitstellung von KI-Agenten mit flexibleren Modellen, wie z. B. den direkten Aufruf von Open-Source-LLMs (Large Language Models) wie Llama 3, Mistral und Cohere.

Azure AI Agent Service bietet stärkere Sicherheitsmechanismen für Unternehmen und Methoden zur Datenspeicherung, die ihn für Unternehmensanwendungen geeignet machen.

Es funktioniert sofort mit Multi-Agent-Orchestrierungs-Frameworks wie AutoGen und Semantic Kernel.

Dieser Dienst befindet sich derzeit in der öffentlichen Vorschau und unterstützt Python und C# für die Erstellung von Agenten.

Grundlegende Konzepte

Der Azure AI Agent Service umfasst die folgenden Kernkonzepte:

• AgentDer Azure AI Agent Service ist mit Azure AI Foundry integriert. In AI Foundry agieren KI-Intelligenzen (Agenten) als "intelligente" Microservices, die zur Beantwortung von Fragen verwendet werden können (RAG), Operationen durchzuführen oder Arbeitsabläufe vollständig zu automatisieren. Dies geschieht durch die Kombination der Fähigkeiten generativer KI-Modelle mit Tools, die ihnen den Zugriff auf und die Interaktion mit realen Datenquellen ermöglichen. Unten sehen Sie ein Beispiel für einen Agenten:

agent = project_client.agents.create_agent(
model="gpt-4o-mini",
name="mein-agent",
instructions="Sie sind hilfreicher Agent",
tools=code_interpreter.definitions,
tool_resources=code_interpreter.resources, )
)

In diesem Beispiel wird ein Modell erstellt mit dem Modell gpt-4o-miniName mein-agent und Weisungen Sie sind ein hilfreicher Agent Der Agent ist mit Werkzeugen und Ressourcen zur Durchführung von Code-Interpretationsaufgaben ausgestattet. Der Agent ist mit Werkzeugen und Ressourcen zur Durchführung von Code-Interpretationsaufgaben ausgestattet.

• Thema und Meldungen. Thread ist ein weiteres wichtiges Konzept. Er stellt einen Dialog oder eine Interaktion zwischen einem Agenten und einem Benutzer dar. Threads können verwendet werden, um den Fortschritt eines Dialogs zu verfolgen, Kontextinformationen zu speichern und den Zustand einer Interaktion zu verwalten. Hier ist ein Beispiel für einen Thread:

thread = projekt_client.agents.create_thread()
message = projekt_client.agents.create_message(
message = projekt_client.agents.create_message(
role="user", content="Können Sie bitte ein Balkendiagramm für den Thread erstellen?
message = project_client.agents.create_message( thread_id=thread.id, role="user", content="Könnten Sie bitte ein Balkendiagramm für den Betriebsgewinn mit den folgenden Daten erstellen und mir die Datei zur Verfügung stellen? Unternehmen B: $2,5 Millionen, Unternehmen C: $3,0 Millionen, Unternehmen D: $1,8 Millionen",)
)
# Aufforderung an den Agenten, die Arbeit an dem Thread auszuführen
run = project_client.agents.create_and_process_run(thread_id=thread.id, agent_id=agent.id)
# Abrufen und Protokollieren aller Nachrichten, um die Antwort des Agenten zu sehen
messages = project_client.agents.list_messages(thread_id=thread.id)
print(f "Meldungen: {Meldungen}")

Im vorherigen Code wurde ein Thread erstellt. Danach wird eine Nachricht an den Thread gesendet. Die Nachricht wird an den Thread gesendet, indem die Funktion erstellen_und_verarbeiten_laufenDer Agent wird dann aufgefordert, die Arbeit an dem Thread auszuführen. Schließlich werden Nachrichten erfasst und protokolliert, um die Reaktion des Agenten zu sehen. Nachrichten zeigen den Fortschritt des Dialogs zwischen dem Benutzer und dem Agenten an. Es ist auch wichtig zu verstehen, dass Nachrichten von verschiedenen Typen sein können, wie z. B. Text, Bilder oder Dateien, bei denen die Arbeit der Agenten z. B. zu einer Bild- oder Textantwort führt. Als Entwickler können Sie diese Informationen nutzen, um die Antwort weiter zu verarbeiten oder sie dem Benutzer zu präsentieren.

• Integration mit anderen KI-FrameworksDer Azure AI Agent Service kann mit anderen Frameworks wie AutoGen und Semantic Kernel interagieren. Das bedeutet, dass Sie einen Teil Ihrer Anwendung in einem der Frameworks erstellen können, z. B. indem Sie den Agent Service als Orchestrator verwenden, oder Sie können alles im Agent Service erstellen.

AnwendungsfallAzure AI Agent Service: Azure AI Agent Service ist für Unternehmensanwendungen konzipiert, die eine sichere, skalierbare und flexible Bereitstellung von KI-Intelligenzen (Agenten) erfordern.

Worin besteht der Unterschied zwischen diesen Rahmenwerken?

Es klingt, als gäbe es eine Menge Überschneidungen zwischen diesen Frameworks, aber es gibt einige wichtige Unterschiede in ihrem Design, ihrer Funktionalität und ihren Zielanwendungsfällen:

• AutoGenSchwerpunkt auf ereignisgesteuerten, verteilten agentenbasierten Anwendungen mit Unterstützung für mehrere Large Language Models (LLMs) und SLMs, Tools und fortgeschrittene Multi-Agent Design Patterns.
• Semantischer KernSchwerpunkt: Verstehen und Generieren von menschenähnlichen Textinhalten durch Erfassen tieferer semantischer Bedeutungen. Es wurde entwickelt, um komplexe Arbeitsabläufe zu automatisieren und Aufgaben auf der Grundlage von Projektzielen zu initiieren.
• Azure AI Agent ServiceBietet flexiblere Modelle, wie z. B. direkte Aufrufe von Open-Source-LLMs (Large Language Models) wie Llama 3, Mistral und Cohere. Bietet robustere Sicherheitsmechanismen und Datenspeichermethoden für Unternehmen, wodurch es für Unternehmensanwendungen geeignet ist.

Sie sind sich noch nicht sicher, welche Sie wählen sollen?

Anwendungsfall

Lassen Sie uns einige häufige Anwendungsfälle durchgehen, um zu sehen, ob wir Ihnen helfen können:

F: Mein Team entwickelt ein Projekt mit automatischer Codegenerierung und Datenanalyseaufgaben. Welches Framework sollten wir verwenden?

A: AutoGen ist in diesem Fall eine gute Wahl, da es sich auf ereignisgesteuerte, verteilte agentenbasierte Anwendungen konzentriert und fortgeschrittene Multi-Agent-Designmuster unterstützt.

F: Was macht AutoGen besser als Semantic Kernel und Azure AI Agent Service für diesen Anwendungsfall?

A: AutoGen wurde für ereignisgesteuerte, verteilte agentenbasierte Anwendungen entwickelt und ist daher ideal für die Automatisierung von Codegenerierung und Datenanalyse geeignet. Es bietet die Werkzeuge und Funktionen, die für den effizienten Aufbau komplexer Multi-Agentensysteme erforderlich sind.

F: Es klingt so, als ob der Azure AI Agent Service auch hier funktioniert und über Tools für die Codegenerierung und ähnliches verfügt?

A: Ja, Azure AI Agent Service unterstützt auch Codegenerierung und Datenanalyseaufgaben, ist aber möglicherweise besser für Unternehmensanwendungen geeignet, die sichere, skalierbare und flexible KI-Agenten-Implementierungen erfordern. autoGen konzentriert sich mehr auf ereignisgesteuerte, verteilte agentenbasierte Anwendungen und fortgeschrittene Multi-Agenten-Designmuster. AutoGen ist mehr auf ereignisgesteuerte, verteilte agentenbasierte Anwendungen und fortgeschrittene Multi-Agenten-Designmuster ausgerichtet.

F: Sie meinen also, wenn ich in den Unternehmensbereich einsteigen möchte, sollte ich Azure AI Agent Service verwenden?

A: Ja, Azure AI Agent Service wurde für Unternehmensanwendungen entwickelt, die eine sichere, skalierbare und flexible Bereitstellung von KI-Intelligenz (Agent) erfordern. Er bietet stärkere Sicherheitsmechanismen für Unternehmen und Methoden zur Datenspeicherung, die ihn für Unternehmensanwendungen geeignet machen.

Fassen wir die wichtigsten Unterschiede in einer Tabelle zusammen:

Was ist der ideale Anwendungsfall für jedes dieser Frameworks?

• AutoGenEreignisgesteuerte, verteilte agentenbasierte Anwendungen, fortgeschrittenes Multi-Agenten-Designmuster. Ideal für automatisierte Code-Generierung, Datenanalyseaufgaben.
• Semantischer KernVerstehen und Erstellen von menschenähnlichen Textinhalten, Automatisieren komplexer Arbeitsabläufe und Auslösen von Aufgaben auf der Grundlage von Projektzielen. Ideal für das Verstehen natürlicher Sprache und die Generierung von Inhalten.
• Azure AI Agent ServiceFlexible Modelle, Sicherheitsmechanismen für Unternehmen und Methoden zur Datenspeicherung. Ideal für den sicheren, skalierbaren und flexiblen Einsatz von KI-Intelligenz (Agenten) in Unternehmensanwendungen.

Kann ich die Tools direkt in mein bestehendes Azure-Ökosystem integrieren oder benötige ich eine eigenständige Lösung?

Die Antwort lautet: Ja, Sie können Ihre bestehenden Azure-Ökosystem-Tools direkt in den Azure AI Agent Service integrieren, zumal dieser so konzipiert ist, dass er nahtlos mit anderen Azure-Diensten zusammenarbeitet. Sie können zum Beispiel Bing, Azure AI Search und Azure Functions integrieren. Es gibt auch eine tiefe Integration mit Azure AI Foundry.

Für AutoGen und Semantic Kernel können Sie auch Azure-Dienste integrieren, aber dazu müssen Sie möglicherweise Azure-Dienste vom Code aus aufrufen. Eine weitere Integrationsmethode ist die Verwendung des Azure SDK, um von Ihren Agenten aus mit Azure-Diensten zu interagieren. Darüber hinaus können Sie, wie bereits erwähnt, den Azure AI Agent Service als Orchestrator für Agenten verwenden, die in AutoGen oder Semantic Kernel erstellt wurden, wodurch Sie einfachen Zugang zum Azure-Ökosystem erhalten.