Agent SDK Vergleichstutorial: Intelligente Anwendungen mit praktischen Beispielen erstellen

Einführung in Agent SDKs

Der Bereich der künstlichen Intelligenz entwickelt sich rasant weiter, wobei der Schwerpunkt zunehmend auf intelligenten Agenten liegt, die in der Lage sind, komplexe Aufgaben auszuführen, mit Benutzern zu interagieren und sich dynamischen Umgebungen anzupassen. Solche Agenten von Grund auf zu erstellen, kann eine große Herausforderung darstellen und erfordert Fachwissen in Bereichen wie natürlicher Sprachverarbeitung, maschinellem Lernen, Wissensdarstellung und mehr. Hier kommen Agent SDKs (Software Development Kits) ins Spiel. Agent SDKs bieten Entwicklern vorgefertigte Komponenten, Frameworks und Werkzeuge, um die Entwicklung intelligenter Agenten zu beschleunigen und viele der zugrunde liegenden Komplexitäten zu abstrahieren.

Ein Agent SDK bietet typischerweise Funktionen zur Definition von Agentenverhalten, Verwaltung von Gesprächsabläufen, Integration mit externen Tools und APIs, Handhabung von Gedächtnis und Kontext und enthält oft Funktionen für Bereitstellung und Überwachung. Die Wahl des richtigen Agent SDK ist entscheidend für den Erfolg Ihres Projekts, da verschiedene SDKs unterschiedliche Anwendungsfälle, Programmiersprachen und Abstraktionslevels abdecken. Dieses Tutorial zielt darauf ab, einen praktischen Vergleich mehrerer beliebter Agent SDKs zu bieten und ihre Stärken und Schwächen durch konkrete Beispiele zu verdeutlichen.

Wichtige Funktionen, die bei einem Agent SDK zu berücksichtigen sind

• Sprachunterstützung: Unterstützt es Ihre bevorzugte Programmiersprache (Python, JavaScript, Java usw.)?
• Benutzerfreundlichkeit und Lernkurve: Wie schnell kann ein neuer Entwickler produktiv mit dem SDK werden?
• Integrationsfähigkeiten: Kann es sich einfach mit anderen Diensten, APIs, Datenbanken und bestehenden Systemen integrieren?
• Zustandsmanagement und Gedächtnis: Wie gut behandelt es den Gesprächskontext und das Langzeitgedächtnis für den Agenten?
• Orchestrierung und Workflow: Bietet es Werkzeuge zur Definition komplexer Agentenverhalten, Entscheidungsfindung und mehrstufiger Prozesse?
• Skalierbarkeit und Leistung: Kann es eine hohe Anzahl von Interaktionen und komplexen Berechnungen bewältigen?
• Bereitstellungsoptionen: Welche Bereitstellungsumgebungen werden unterstützt (Cloud, lokal, 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 SDKs mit benutzerdefinierten Komponenten zu erweitern?

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

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

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

LangChain hat sich schnell als dominierendes Framework zur Entwicklung von Anwendungen etabliert, die von großen Sprachmodellen unterstützt werden. Seine Kernphilosophie dreht sich um das ‘Verketten’ verschiedener Komponenten, um komplexe Workflows zu erstellen. Es bietet ein umfassendes Set von Abstraktionen für die Interaktion mit LLMs, das Management von Eingabeaufforderungen, die Handhabung von Gesprächsgedächtnis, die Integration mit externen Tools (Agenten) und die Informationsbeschaffung aus verschiedenen Datenquellen (Retrieval).

LangChain Hauptmerkmale:

• Ketten: Definieren Sie Sequenzen von Aufrufen, z.B. Eingabemuster + LLM + Ausgabeverarbeitung.
• Agenten: Erlauben LLMs die Auswahl einer Sequenz von Aktionen, die oft unter Verwendung von Tools erfolgen.
• Gedächtnis: Speichern und Abrufen von Informationen über frühere Interaktionen.
• Ladeprogramme: Daten aus verschiedenen Quellen (PDFs, Websites, Datenbanken) laden.
• Vektorspeicher: Speichern und Abfragen von Einbettungen für die semantische Suche.
• Tools: Externe Funktionen, die ein Agent verwenden kann (z.B. Suchmaschinen, Taschenrechner, benutzerdefinierte APIs).

LangChain Praktisches Beispiel: Ein einfacher Gesprächsagent mit Toolverwendung

Lass uns einen LangChain-Agenten erstellen, der allgemeine Fragen beantworten und auch ein Taschenrechner-Tool nutzen kann, 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. Das LLM initialisieren
llm = ChatOpenAI(temperature=0, model="gpt-4o")

# 2. Werkzeuge definieren
# Taschenrechner-Werkzeug
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. Die Eingabeaufforderung vom LangChain Hub abrufen (ReAct-Stil)
# Die ReAct-Eingabeaufforderung leitet das LLM dazu an, zu denken, zu beobachten und zu handeln.
prompt = hub.pull("hwchase17/react")

# 4. Den ReAct-Agenten erstellen
agent = create_react_agent(llm, tools, prompt)

# 5. Den Agenten-Executor erstellen
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

# 6. Den Agenten ausführen
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 OpenAI Chat-Modell.
• Wir definieren ein Calculator-Werkzeug mithilfe von LangChains LLMMathChain.
• Wir ziehen eine Standard-ReAct-Eingabeaufforderung vom LangChain Hub. ReAct (Reasoning and Acting) ist ein Paradigma, das es LLMs ermöglicht, dynamisches Denken und Aktionsplanung durchzuführen.
• create_react_agent kombiniert das LLM, die Werkzeuge und die Eingabeaufforderung, um einen Agenten zu erstellen.
• AgentExecutor ist verantwortlich für die Ausführung des Agenten, das Management seiner Denkprozesse und die Ausführung der Werkzeuge.
• Wenn nach der Hauptstadt von Frankreich gefragt wird, antwortet das LLM direkt. Wenn eine Mathematikfrage gestellt wird, erkennt es die Notwendigkeit des Taschenrechners, ruft das Werkzeug auf und liefert das Ergebnis.

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

Während LangChain stark auf Orchestrierung und das Verketten von LLM-Aufrufen fokussiert ist, spezialisiert sich LlamaIndex (früher GPT Index) auf die Datenaufnahme, Indizierung und Abfrage für LLM-Anwendungen. Sein Hauptziel ist es, die Verbindung von LLMs mit benutzerdefinierten Datenquellen zu erleichtern und leistungsstarke RAG (Retrieval-Augmented Generation)-Anwendungen zu ermöglichen. LlamaIndex glänzt beim Aufbau von Wissensdatenbanken und deren Abfragbarkeit durch LLMs.

LlamaIndex Hauptmerkmale:

• Datenkonnektoren: Daten aus verschiedenen Quellen (Dokumente, Datenbanken, APIs) aufnehmen.
• Datenindizierung: Daten strukturiert und gespeichert, um für LLM-Abfragen zu optimieren (z.B. Vektorspeicher, Wissensgraphen).
• Abfrage-Engines: Relevante Informationen aus Indizes abrufen und Antworten unter Verwendung von LLMs synthetisieren.
• Agenten: Abfrage-Engines mit Werkzeugen und LLMs kombinieren, um komplexere, mehrstufige Schlussfolgerungen über Daten hinweg zu ermöglichen.
• Service-Kontext: Verwaltung von LLM, Einbettungsmodell und anderen Service-Konfigurationen.

LlamaIndex Praktisches Beispiel: Abfrage eines benutzerdefinierten Dokuments

Lass uns eine einfache LlamaIndex-Anwendung erstellen, die Fragen basierend auf einer lokalen Textdatei beantworten kann.

# Zuerst eine Dummy-Datei erstellen: 'policy.txt'
# Inhalt:
# "Die Urlaubsrichtlinie unseres Unternehmens gewährt den Mitarbeitern 15 Tage bezahlten Urlaub pro Jahr. 
# Nach 5 Jahren Betriebszugehörigkeit erhalten die Mitarbeiter zusätzlich 5 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

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

# 1. LLM und Einbettungsmodell konfigurieren (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 'data'-Verzeichnis

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

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

# 5. Die 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 policy.txt-Datei in einem data-Verzeichnis.
• Wir konfigurieren das LLM und das Einbettungsmodell über Settings.
• SimpleDirectoryReader lädt die Textdatei.
• VectorStoreIndex.from_documents verarbeitet die Dokumente, teilt sie in Abschnitte, bettet sie ein und speichert sie in einer Vektordatenbank (standardmäßig im Speicher).
• index.as_query_engine() erstellt eine Schnittstelle zur Abfrage des Index.
• Bei einer Abfrage ruft die Abfrage-Engine die relevanten Dokumentabschnitte basierend auf semantischer Ähnlichkeit ab und verwendet dann das LLM, um eine Antwort aus diesen Abschnitten zu synthetisieren.

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

Microsoft Semantic Kernel (SK) ist ein Open-Source-SDK, das Entwicklern ermöglicht, große Sprachmodelle (LLMs) und andere KI-Fähigkeiten in ihren Anwendungen unter Verwendung bestehender Programmiersprachen (C#, Python, Java) zu integrieren. Es konzentriert sich darauf, Anwendungen zu ermöglichen, Interaktionen mit LLMs und traditionellem Code zu orchestrieren und legt den Schwerpunkt auf eine ‘Plugin’-Architektur. SK ist besonders stark für Entwickler, die bereits im Microsoft-Ökosystem tätig sind oder die nach einem soliden, unternehmensgerechten Framework suchen.

Semantic Kernel Hauptmerkmale:

• Kern: Die zentrale Orchestrierungsmaschine für KI und traditionellen Code.
• Fähigkeiten/Plugins: Sammlungen von semantischen Funktionen (LLM-Prompts) und nativen Funktionen (traditioneller Code), die die KI aufrufen kann.
• Semantische Funktionen: Prompts, die definieren, was das LLM tun soll.
• Native Funktionen: Methoden des traditionellen Codes, die der KI zur Verfügung stehen und ihr ermöglichen, mit externen Systemen zu interagieren.
• Speicher: Informationen für den Gesprächskontext speichern und abrufen.
• Planer: Ermöglichen es der KI, eine Abfolge von Fähigkeiten zu planen und auszuführen, um ein Ziel zu erreichen.

Praktisches Beispiel für den Semantischen Kern: Ein einfacher Planer mit benutzerdefiniertem Plugin

Lasst uns eine Anwendung für den Semantischen Kern erstellen, die den Benutzer begrüßen und auch eine einfache arithmetische Operation mit einer benutzerdefinierten nativen Funktion (Plugin) ausfü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. Den Kern initialisieren
kernel = sk.Kernel()

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

# 3. Ein 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. Das Plugin in den Kern importieren
kernel.add_plugin(MathPlugin(), plugin_name="MyMathPlugin")

# 5. Eine semantische Funktion definieren (für allgemeine Konversation)
# Dies 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. Die Chat-Funktion direkt aufrufen
 result = await kernel.invoke(chat_function, sk.KernelArguments(input="Hallo, was kannst du für mich tun?"))
 print(f"Chat-Antwort: {result}")

 # 7. Einen Planer verwenden, um Aktionen zu orchestrieren, einschließlich unseres MathPlugin
 # Für komplexe Planungen würden Sie einen speziellen Planer wie SequentialPlanner verwenden
 # Für dieses einfache Beispiel zeigen wir einen direkten Aufruf über ein Prompt mit Funktionen

 # Das LLM erkennt und verwendet die registrierten Plugins, wenn es mit dem richtigen Prompt aufgerufen wird.
 # Lassen Sie uns ein Ziel für das LLM erstellen, um es mit den verfügbaren Plugins zu erreichen.

goal = "Ich muss die Summe von 10 und 20 wissen und dann dieses Ergebnis mit 3 multiplizieren."

 # Die Funktionsaufruf-Mechanik von SK ermöglicht es dem LLM, die richtige Funktion auszuwählen.
 # Wir verwenden direkt einen Chat-Vervollständigungsdienst, 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"Planer-Antwort: {response}")

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

Erklärung:

• Wir initialisieren den Kern und fügen einen OpenAI-Chat-Vervollständigungsdienst hinzu.
• Wir definieren eine MathPlugin-Klasse mit @kernel_function-Dekoratoren, die add und multiply als native Funktionen offenlegt.
• Wir importieren dieses Plugin in den Kern.
• Eine einfache semantische Funktion chat_function wird für die direkte Interaktion mit dem LLM erstellt.
• In main() rufen wir zunächst die Chat-Funktion direkt auf.
• Für das Planungsbeispiel erstellen wir dann eine Chat-Historie mit einem Ziel. Durch die Verwendung von function_call="auto" in den Einstellungen wird das LLM befähigt, zu entscheiden, ob es direkt antworten oder eine der registrierten nativen Funktionen (Plugins) aufrufen soll, um das Ziel zu erreichen. SK kümmert sich um die Übersetzung des Funktionsaufrufs des LLM in tatsächliche Methodenaufrufe und gibt das Ergebnis dann an das LLM zurück.

Die richtige Agent SDK wählen

Die Wahl des Agent SDK hängt stark von den spezifischen Bedürfnissen Ihres Projekts und Ihrem bestehenden Technologie-Stack ab:

• Wählen Sie LangChain, wenn:
  • Sie umfangreiche LLM-Orchestrierung, komplexes agentisches Verhalten und flexible Verkettung von Komponenten benötigen.
  • Sie eine breite Palette von LLMs, Werkzeugen und Speichertypen integrieren möchten.
  • Sie Anwendungen entwickeln, die mehrstufiges Denken, dynamische Werkzeugauswahl und konversationale Agenten beinhalten.
  • Sie eine große, aktive Gemeinschaft und umfangreiche Beispiele schätzen.
• Wählen Sie LlamaIndex, wenn:
  • Ihr Hauptaugenmerk auf der Verbindung von LLMs mit Ihren benutzerdefinierten Daten (Dokumenten, Datenbanken, APIs) für RAG liegt.
  • Sie solide Datenaufnahme-, Indexierungs- und Abruffähigkeiten benötigen.
  • Sie Wissensdatenbank-Q&A-Systeme, Dokumentenzusammenfassungen oder datenbewusste Agenten entwickeln.
  • Sie effizientes und skalierbares Datenmanagement für LLMs priorisieren.
• Wählen Sie Microsoft Semantic Kernel, wenn:
  • Sie ein C#, Python- oder Java-Entwickler sind und KI nahtlos in bestehende Anwendungen integrieren möchten.
  • Sie ein solides, unternehmensbereites Framework von Microsoft wünschen.
  • Sie LLM-Funktionen (semantische Funktionen) mit traditionellem Code (nativen Funktionen/plugins) strukturiert kombinieren müssen.
  • Sie Anwendungen entwickeln, die erfordern, dass KI mit Ihren internen Systemen und APIs interagiert.

Fazit

Agent SDKs sind unverzichtbare Werkzeuge für den Aufbau anspruchsvoller KI-Anwendungen. LangChain, LlamaIndex und Microsoft Semantic Kernel bieten jeweils leistungsstarke Funktionen, die auf verschiedene Aspekte der KI-Entwicklung zugeschnitten sind. LangChain ist hervorragend geeignet für die Orchestrierung komplexer LLM-Workflows und agentisches Denken. LlamaIndex ist die erste Wahl für Datenintegration und abrufoptimierte Generation. Semantic Kernel bietet eine solide Grundlage für die Integration von KI in bestehende Anwendungen mit einer stabilen Plugin-Architektur, insbesondere für Unternehmensanwendungsfälle. Indem Sie deren Kernstärken verstehen und sie durch praktische Beispiele in Aktion sehen, sind Sie jetzt besser gerüstet, das richtige SDK auszuwählen, um Ihre Ideen für intelligente Agenten zum Leben zu erwecken.

🕒 Published: March 28, 2026