Tutorial zum Vergleich des Agent SDK: Intelligente Anwendungen mit praktischen Beispielen erstellen

Einführung in die Agent SDKs

Der Bereich der künstlichen Intelligenz entwickelt sich schnell weiter, mit einem wachsenden Fokus auf intelligente Agenten, die in der Lage sind, komplexe Aufgaben auszuführen, mit Benutzern zu interagieren und sich an dynamische Umgebungen anzupassen. Solche Agenten von Grund auf neu zu erstellen, kann eine entmutigende Aufgabe sein, die Fachwissen in natürlicher Sprachverarbeitung, maschinellem Lernen, Wissensdarstellung und mehr erfordert. Hier kommen die Agent SDKs (Software Development Kits) ins Spiel. Die Agent SDKs bieten Entwicklern vordefinierte Komponenten, Frameworks und Werkzeuge, um die Entwicklung intelligenter Agenten zu beschleunigen, indem sie einen Großteil der zugrunde liegenden Komplexität abstrahieren.

Ein Agent SDK bietet in der Regel Funktionen zum Definieren des Verhaltens von Agenten, Verwalten von Konversationsflüssen, Integrieren mit externen Tools und APIs, Verwalten von Gedächtnis und Kontext und umfasst oft Funktionen für Bereitstellung und Überwachung. Die Wahl des richtigen Agent SDK ist entscheidend für den Erfolg Ihres Projekts, da verschiedene SDKs unterschiedlichen Anwendungsfällen, Programmiersprachen und Abstraktionsebenen gerecht werden. Dieses Tutorial zielt darauf ab, einen praktischen Vergleich mehrerer beliebter Agent SDKs zu bieten und ihre Stärken und Schwächen anhand konkreter Beispiele zu veranschaulichen.

Wichtige Merkmale, die man bei einem Agent SDK berücksichtigen sollte

• Sprachunterstützung: Unterstützt es Ihre bevorzugte Programmiersprache (Python, JavaScript, Java usw.)?
• Benutzerfreundlichkeit und Lernkurve: Wie schnell kann ein neuer Entwickler mit dem SDK produktiv werden?
• Integrationsmöglichkeiten: Kann es problemlos mit anderen Diensten, APIs, Datenbanken und bestehenden Systemen integriert werden?
• Zustandsverwaltung und Gedächtnis: Wie verwaltet es den Konversationskontext und das langfristige Gedächtnis des Agenten?
• Orchestrierung und Workflow: Bietet es Werkzeuge zur Definition komplexer Verhaltensweisen von Agenten, Entscheidungsfindung und mehrstufigen Prozessen?
• Skalierbarkeit und Leistung: Kann es ein hohes Volumen an Interaktionen und komplexen Berechnungen bewältigen?
• Bereitstellungsoptionen: Welche Bereitstellungsumgebungen werden unterstützt (Cloud, On-Premise, serverlos)?
• Gemeinschaft und Dokumentation: Gibt es eine aktive Gemeinschaft und umfassende Dokumentation, um während der Entwicklung zu helfen?
• Erweiterbarkeit: Wie einfach ist es, die Funktionen des SDK mit benutzerdefinierten Komponenten zu erweitern?

Vergleich der Agent SDKs: LangChain vs. LlamaIndex vs. Microsoft Semantic Kernel

In diesem Tutorial konzentrieren wir uns auf drei herausragende und weit verbreitete Agent SDKs: LangChain, LlamaIndex und Microsoft Semantic Kernel. Jedes dieser SDKs bietet einen einzigartigen Ansatz zur Erstellung intelligenter Agenten, insbesondere solchen, die große Sprachmodelle (LLMs) verwenden.

1. LangChain: Der Orchestrator für LLM-gesteuerte Anwendungen

LangChain hat sich schnell als dominierendes Framework für die Entwicklung von LLM-gesteuerten Anwendungen etabliert. Seine zentrale Philosophie dreht sich um die „Kettengliederung“ verschiedener Komponenten, um komplexe Arbeitsabläufe zu schaffen. Es bietet eine umfassende Reihe von Abstraktionen für die Interaktion mit LLMs, das Management von Prompts, die Verarbeitung des Konversationsgedächtnisses, die Integration mit externen Tools (Agenten) und das Abrufen von Informationen aus verschiedenen Datenquellen (Retrieval).

Wichtige Merkmale von LangChain:

• Ketten: Definieren von Sequenzen von Aufrufen, z. B. Prompt-Modelle + LLM + Ausgabeanalysator.
• Agenten: Ermöglichen den LLMs, eine Sequenz von Aktionen auszuwählen, die ausgeführt werden sollen, häufig unter Verwendung von Tools.
• Gedächtnis: Speichern und Abrufen von Informationen über vorherige Interaktionen.
• Lader: Laden von Daten aus verschiedenen Quellen (PDF, Websites, Datenbanken).
• Vektorstände: Speichern und Abfragen von Embeddings für die semantische Suche.
• Werkzeuge: Externe Funktionen, die ein Agent nutzen kann (z. B. Suchmaschinen, Taschenrechner, benutzerdefinierte APIs).

Praktisches Beispiel für LangChain: Ein einfacher Konversationsagent mit Nutzung von Werkzeugen

Erstellen wir einen LangChain-Agenten, der in der Lage ist, allgemeine Fragen zu beantworten und ein Rechenwerkzeug zu nutzen, wenn eine mathematische Operation erkannt wird.

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub
from langchain_core.tools import Tool
from langchain.chains import LLMMathChain

# 1. Initialisieren des LLM
llm = ChatOpenAI(temperature=0, model="gpt-4o")

# 2. Definieren der Werkzeuge
# Rechenwerkzeug
llm_math_chain = LLMMathChain.from_llm(llm=llm, verbose=True)
calculator = Tool(
 name="Calculator",
 func=llm_math_chain.run,
 description="Nützlich, wenn Sie Fragen zu Mathematik beantworten müssen."
)

tools = [calculator]

# 3. Abrufen der Eingabeaufforderung von LangChain Hub (ReAct-Stil)
# Die ReAct-Eingabeaufforderung leitet den LLM dazu an, zu denken, zu beobachten und zu handeln.
prompt = hub.pull("hwchase17/react")

# 4. Erstellen des ReAct-Agenten
agent = create_react_agent(llm, tools, prompt)

# 5. Erstellen des Agenten-Ausführers
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

# 6. Ausführen des Agenten
print(agent_executor.invoke({"input": "Was ist die Hauptstadt von Frankreich?"}))
print(agent_executor.invoke({"input": "Was ist 1234 * 5678?"}))

Erklärung:

• Wir initialisieren ein Chat OpenAI-Modell.
• Wir definieren ein Werkzeug Calculator unter Verwendung des LLMMathChain von LangChain.
• Wir ziehen eine Standard-ReAct-Eingabeaufforderung von LangChain Hub. ReAct (Reasoning and Action) ist ein Paradigma, das es den LLMs ermöglicht, dynamisches Denken und Aktionsplanung durchzuführen.
• create_react_agent kombiniert den LLM, die Werkzeuge und die Eingabeaufforderung, um einen Agenten zu erstellen.
• AgentExecutor ist verantwortlich für die Ausführung des Agenten, das Management seines Denkprozesses und die Ausführung der Werkzeuge.
• Wenn nach der Hauptstadt von Frankreich gefragt wird, antwortet der LLM direkt. Wenn eine mathematische Frage gestellt wird, erkennt er die Notwendigkeit des Rechners, ruft das Werkzeug auf und liefert das Ergebnis.

2. LlamaIndex: Daten-Framework für LLM-Anwendungen

Während sich LangChain stark auf die Orchestrierung und Verkettung von LLM-Aufrufen konzentriert, spezialisiert sich LlamaIndex (ehemals GPT Index) auf die Datenaufnahme, Indizierung und Retrieval für LLM-Anwendungen. Sein Hauptziel ist es, die Verbindung von LLMs mit benutzerdefinierten Datenquellen zu erleichtern, was mächtige RAG-Anwendungen (Retrieval-Augmented Generation) ermöglicht. LlamaIndex glänzt beim Aufbau von Wissensdatenbanken und deren Abfragemöglichkeiten durch LLMs.

Wichtige Merkmale von LlamaIndex:

• Datenconnectoren: Datenaufnahme aus verschiedenen Quellen (Dokumente, Datenbanken, APIs).
• Datenindizierung: Strukturieren und Speichern von Daten in einer für LLM-Abfragen optimierten Weise (z. B. Vektor-Stores, Wissensgraphen).
• Abfragetools: Abrufen relevanter Informationen aus den Indizes und Synthese von Antworten unter Verwendung von LLMs.
• Agenten: Kombinieren von Abfragetools mit Werkzeugen und LLMs für komplexeres Denken über die Daten.
• Service-Kontext: Verwalten des LLM, des Einbettungsmodells und anderer Servicekonfigurationen.

Praktisches Beispiel für LlamaIndex: Abfragen eines benutzerdefinierten Dokuments

Erstellen wir eine einfache LlamaIndex-Anwendung, die in der Lage ist, Fragen basierend auf einer lokalen Textdatei zu beantworten.

# Zuerst erstellen Sie eine fiktive Datei: 'policy.txt'
# Inhalt:
# "Die Urlaubsrichtlinie unseres Unternehmens gewährt den Mitarbeitern 15 Tage bezahlten Urlaub pro Jahr. 
# Nach 5 Jahren Dienstzeit erhalten die Mitarbeiter 5 zusätzliche Tage. 
# Nicht genutzte Urlaubstage verfallen nicht ins nächste Jahr."

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding
import os

# Definieren Sie den OpenAI-API-Schlüssel (stellen Sie sicher, dass er in Ihren Umgebungsvariablen vorhanden ist)
# os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"

# 1. Konfigurieren Sie das LLM und das Embedding-Modell (optional, aber gute Praxis)
Settings.llm = OpenAI(model="gpt-4o", temperature=0)
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")

# 2. Dokumente aus einem Verzeichnis laden
documents = SimpleDirectoryReader("data").load_data() # Angenommen, 'policy.txt' befindet sich im Verzeichnis 'data'

# 3. Einen Index aus den Dokumenten erstellen (VectorStoreIndex ist gängig)
index = VectorStoreIndex.from_documents(documents)

# 4. Einen Abfrage-Engine erstellen
query_engine = index.as_query_engine()

# 5. Den Engine abfragen
response = query_engine.query("Wie viele Urlaubstage erhalten die Mitarbeiter pro Jahr?")
print(response)

response = query_engine.query("Was passiert mit nicht genutzten Urlaubstagen?")
print(response)

Erklärung:

• Wir erstellen zuerst eine Datei policy.txt in einem Verzeichnis data.
• Wir konfigurieren das LLM und das Embedding-Modell über Settings.
• SimpleDirectoryReader lädt die Textdatei.
• VectorStoreIndex.from_documents verarbeitet die Dokumente, teilt sie in Stücke, bettet sie ein und speichert sie in einer vektorbasierten Datenbank (standardmäßig im Speicher).
• index.as_query_engine() erstellt eine Schnittstelle, um den Index abzufragen.
• Wenn eine Abfrage gemacht wird, ruft die Abfrage-Engine relevante Dokumentstücke basierend auf semantischer Ähnlichkeit ab und verwendet dann das LLM, um eine Antwort aus diesen Teilen zu synthetisieren.

3. Microsoft Semantic Kernel: Der Orchestrator für KI-gestützte Anwendungen mit Plugins

Microsoft Semantic Kernel (SK) ist ein Open-Source-SDK, das Entwicklern ermöglicht, große Sprachmodelle (LLMs) und andere KI-Funktionen in ihren Anwendungen zu integrieren, indem vorhandene Programmiersprachen (C#, Python, Java) verwendet werden. Es konzentriert sich darauf, Anwendungen zu befähigen, Interaktionen mit LLMs und traditionellem Code zu orchestrieren, wobei der Schwerpunkt auf einer ‘Plugin’-Architektur liegt. SK eignet sich besonders für Entwickler, die bereits im Microsoft-Ökosystem sind oder nach einem soliden, unternehmensgerechten Rahmen suchen.

Schlüsselfunktionen des Semantic Kernel:

• Kernel: Der zentrale Orchestrierungsengine für KI und traditionellen Code.
• Fähigkeiten/Plugins: Sammlungen von semantischen Funktionen (LLM-Prompts) und nativen Funktionen (traditioneller Code), die von der KI aufgerufen werden können.
• Semantische Funktionen: Prompts, die definieren, was das LLM tun soll.
• Native Funktionen: Methoden von traditionellem Code, die der KI zur Verfügung stehen und es ihr ermöglichen, mit externen Systemen zu interagieren.
• Speicher: Informationen für den Kontext zu speichern und abzurufen.
• Planer: Ermöglichen es der KI, eine Sequenz von Fähigkeiten zu planen und auszuführen, um ein Ziel zu erreichen.

Praktisches Beispiel eines semantischen Kernels: Ein einfacher Planer mit einem benutzerdefinierten Plugin

Erstellen wir eine semantische Kernelanwendung, die den Benutzer begrüßen und eine einfache arithmetische Operation mit einer benutzerdefinierten nativen Funktion (Plugin) durchführen kann.

import semantic_kernel as sk
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
from semantic_kernel.functions import kernel_function
import asyncio

# 1. Kernel initialisieren
kernel = sk.Kernel()

# 2. LLM-Dienst konfigurieren
# Stellen Sie sicher, dass Ihr OPENAI_API_KEY als Umgebungsvariable festgelegt ist
kernel.add_service(
 OpenAIChatCompletion(
 service_id="chat_completion",
 ai_model_id="gpt-4o",
 ),
)

# 3. Benutzerdefiniertes natives Plugin (Fähigkeiten in SK) definieren
class MathPlugin:
 @kernel_function(description="Addiert zwei Zahlen.", name="Add")
 def add(self, num1: float, num2: float) -> float:
 return num1 + num2

 @kernel_function(description="Multipliziert zwei Zahlen.", name="Multiply")
 def multiply(self, num1: float, num2: float) -> float:
 return num1 * num2

# 4. Plugin in den Kernel importieren
kernel.add_plugin(MathPlugin(), plugin_name="MyMathPlugin")

# 5. Eine semantische Funktion definieren (für die allgemeine Konversation)
# Das ist ein einfaches Prompt, das direkt aufgerufen oder von einem Planer verwendet werden kann
prompt_template = "{{$input}}"
chat_function = kernel.create_function_from_prompt(
 prompt_template=prompt_template,
 plugin_name="ChatPlugin",
 function_name="Chat"
)

async def main():
 # 6. Direkt die Chatfunktion aufrufen
 result = await kernel.invoke(chat_function, sk.KernelArguments(input="Hallo, was kannst du für mich tun?"))
 print(f"Antwort des Chats: {result}")

 # 7. Einen Planer verwenden, um Aktionen zu orchestrieren, einschließlich unseres MathPlugins
 # Für komplexes Planen würden Sie einen dedizierten Planer wie SequentialPlanner verwenden
 # Für dieses einfache Beispiel werden wir einen direkten Aufruf über ein Prompt mit Funktionalität zeigen
 
 # Das LLM, wenn es mit dem richtigen Prompt aufgerufen wird, erkennt und verwendet die registrierten Plugins.
 # Lassen Sie uns ein Ziel für das LLM festlegen, das mit den verfügbaren Plugins erreicht werden kann.
 
goal = "Ich muss die Summe von 10 und 20 wissen und dann dieses Ergebnis mit 3 multiplizieren."

 # Der Funktionsaufruf-Mechanismus von SK ermöglicht es dem LLM, die richtige Funktion auszuwählen.
 # Wir verwenden direkt einen Chatkomplettierungsdienst, der es ihm ermöglicht, Werkzeuge zu nutzen.
 history = kernel.create_chat_history()
 history.add_user_message(goal)

 response = await kernel.get_service("chat_completion").get_chat_message_content(
 history=history,
 settings=sk.OpenAIChatCompletionSettings(function_call="auto")
 )
 print(f"Antwort des Planers: {response}")

if __name__ == "__main__":
 asyncio.run(main())

Erklärung:

• Wir initialisieren den Kernel und fügen einen OpenAI-Chatkomplettierungsdienst hinzu.
• Wir definieren eine Klasse MathPlugin mit den Dekoratoren @kernel_function, die add und multiply als native Funktionen exponiert.
• Wir importieren dieses Plugin in den Kernel.
• Eine einfache semantische Funktion chat_function wird erstellt, um eine direkte Interaktion mit dem LLM zu ermöglichen.
• In main() rufen wir zuerst die Chatfunktion direkt auf.
• Anschließend, für das Planungsbeispiel, erstellen wir einen Chatverlauf mit einem Ziel. Mit function_call="auto" in den Einstellungen ist das LLM in der Lage zu entscheiden, ob es direkt antworten oder eine der registrierten nativen Funktionen (Plugins) für die Zielerreichung aufrufen soll. SK verwaltet die Übersetzung des Funktionsaufrufs des LLM in echte Methodenausführungen und gibt anschließend das Ergebnis an das LLM zurück.

Die richtige SDK-Agenten wählen

Die Wahl des SDK-Agenten hängt stark von den spezifischen Anforderungen Ihres Projekts und Ihres bestehenden Technologie-Stacks ab:

• Wählen Sie LangChain, wenn:
  • Sie eine umfassende LLM-Orchestrierung, komplexes agentisches Verhalten und eine flexible Komponenten-Kette benötigen.
  • Sie eine große Vielfalt an LLMs, Werkzeugen und Gedächtnistypen integrieren möchten.
  • Sie Anwendungen erstellen, die mehrstufiges Denken, dynamische Werkzeugauswahl und konversationsfähige Agenten erfordern.
  • Sie eine große, aktive Community und viele Beispiele schätzen.
• Wählen Sie LlamaIndex, wenn:
  • Ihr Hauptziel darin besteht, LLMs mit Ihren benutzerdefinierten Daten (Dokumenten, Datenbanken, APIs) für RAG zu verbinden.
  • Sie starke Fähigkeiten zur Datenaufnahme, Indizierung und Abfrage benötigen.
  • Sie Wissensdatenbanksysteme, Dokumentenzusammenfassungen oder datensensible Agenten erstellen.
  • Sie eine effektive und skalierbare Datenverwaltung für LLMs bevorzugen.
• Wählen Sie Microsoft Semantic Kernel, wenn:
  • Sie ein C#, Python oder Java-Entwickler sind, der KI nahtlos in bestehende Anwendungen integrieren möchte.
  • Sie einen soliden und unternehmensbereiten Rahmen von Microsoft wünschen.
  • Sie die Fähigkeiten von LLM (semantische Funktionen) strukturiert mit traditionellem Code (native Funktionen/plugins) kombinieren müssen.
  • Sie Anwendungen erstellen, die erfordern, dass die KI mit Ihren internen Systemen und APIs interagiert.

Fazit

Die SDKs für Agenten sind unverzichtbare Werkzeuge zur Erstellung komplexer KI-Anwendungen. LangChain, LlamaIndex und Microsoft Semantic Kernel bieten jeweils leistungsstarke Funktionen, die auf verschiedene Aspekte der KI-Entwicklung abgestimmt sind. LangChain glänzt in der Orchestrierung komplexer LLM-Workflows und agentenbasiertem Denken. LlamaIndex ist die ideale Wahl für die Integration und generationserweiterte Datenerfassung. Semantic Kernel bietet eine solide Grundlage zur Integration von KI in bestehende Anwendungen mit einer stabilen Plugin-Architektur, insbesondere für unternehmerische Anwendungsfälle. Durch das Verständnis ihrer grundlegenden Stärken und das Erleben ihrer Anwendung durch praktische Beispiele sind Sie nun besser gerüstet, um das richtige SDK auszuwählen, um Ihre Ideen für intelligente Agenten zum Leben zu erwecken.

🕒 Published: March 29, 2026