Egal ob Sie KI-Anwendungen entwickeln oder komplexe Aufgaben automatisieren – einen KI-Agent mit den richtigen Daten und Tools arbeiten zu lassen, kann herausfordernd sein. Einfache KI-Systeme haben oft Schwierigkeiten, wenn sie Schlussfolgerungen ziehen, Informationen abrufen oder Aufgaben über verschiedene Quellen hinweg bewältigen müssen. LlamaIndex-Agents erleichtern das, indem sie KI-Modelle mit Tools, Daten und Retrieval-Systemen verbinden, um Aufgaben effektiver zu erledigen. Lesen Sie diesen Artikel, um zu erfahren, wie Sie einen LlamaIndex-Agent-Workflow für intelligentere und flexiblere KI-Anwendungen aufbauen und bereitstellen.
Was ist ein LlamaIndex-Agent?
Ein LlamaIndex-Agent ist ein KI-System, das über eine Aufgabe nachdenken und entscheiden kann, welche Schritte zur Erledigung notwendig sind. Er kann eine komplexe Anfrage in kleinere Teilaufgaben zerlegen, Tools auswählen und bei Bedarf externe Daten nutzen. Agents können sich außerdem an vorherige Schritte erinnern und abgerufene Informationen nutzen, um ihre Antworten zu verbessern. Dadurch können sie Aufgaben bewältigen, die über eine einfache Frage-Antwort-Interaktion hinausgehen.
Wie funktionieren LlamaIndex-Agents?
LlamaIndex-Agents ermöglichen es LLM-Anwendungen, über einfache Fragebeantwortung hinauszugehen, indem Modelle über Aufgaben nachdenken, Tools auswählen und mehrstufige Workflows abschließen können. Anstatt einer festen Pipeline zu folgen, entscheidet ein Agent dynamisch, welche Aktionen basierend auf dem Ziel des Nutzers und den verfügbaren Fähigkeiten erforderlich sind.
Ein typischer LlamaIndex-Agent-Workflow folgt diesem Ablauf:
User request
↓
Understand the task
↓
Select tools
↓
Execute actions
↓
Process results
↓
Return final responseZiele der Nutzer verstehen
Wenn ein Agent eine Anfrage erhält, analysiert das zugrunde liegende LLM die Aufgabe, den verfügbaren Kontext und die verbundenen Tools, um den besten Ansatz zu bestimmen.
Bei einfachen Anfragen kann der Agent direkt eine Antwort generieren. Bei komplexen Aufgaben kann er die Anfrage in kleinere Schritte zerlegen und entscheiden, welche Vorgänge erforderlich sind.
Tools auswählen und nutzen
Tools erweitern die Fähigkeiten eines Agents über das LLM selbst hinaus. LlamaIndex-Agents können sich über Tools wie FunctionTool und QueryEngineTool mit benutzerdefinierten Python-Funktionen, Query-Engines, APIs, Datenbanken und Retrieval-Systemen verbinden.
Zum Beispiel kann ein Agent ein Suchtool nutzen, um Informationen zu sammeln, ein Datenbanktool, um Datensätze abzurufen, oder eine eigene Funktion, um Berechnungen durchzuführen.
Aufgaben über eine Agent-Schleife ausführen
Nachdem ein Tool ausgewählt wurde, führt der Agent die Aktion aus, beobachtet das Ergebnis und entscheidet über den nächsten Schritt. Diese Reasoning-Action-Schleife ermöglicht es Agents, komplexe Workflows zu bewältigen, die mehrere Vorgänge erfordern.
Reason → Act → Observe → RepeatIst die Aufgabe noch nicht abgeschlossen, kann der Agent weiterhin Tools aufrufen oder seinen Ansatz verfeinern, bis er eine endgültige Antwort generiert.
Kontext und Workflows verwalten
LlamaIndex-Agents behalten den relevanten Kontext während des gesamten Ausführungsprozesses bei, was ihnen hilft, mehrstufige Aufgaben zu verwalten und Ergebnisse aus früheren Schritten zu nutzen. Für komplexere Anwendungen können Entwickler Workflows und Multi-Agent-Architekturen einsetzen, um mehrere Agents zu koordinieren, wobei jeder Agent eine bestimmte Rolle oder Aufgabe übernimmt.
Zum Beispiel:
Research Agent
↓
Analysis Agent
↓
Writing AgentDadurch eignen sich LlamaIndex-React-Agents für Anwendungen wie KI-Forschungsassistenten, unternehmensinterne Wissenssysteme und automatisierte Datenworkflows.
Kernkomponenten von LlamaIndex-Agents
LlamaIndex-Multi-Agents kombinieren mehrere Komponenten, um aus einem LLM ein System zu machen, das Schlussfolgerungen ziehen, externe Funktionen nutzen und Kontext beibehalten kann. Jede Komponente hat eine andere Rolle, aber sie arbeiten zusammen, um dem Agent zu helfen, Aufgaben effektiver zu erledigen. Hier sind einige seiner Kernkomponenten:
LLM: Die Reasoning-Engine der Agents
Das LLM fungiert als die zentrale Reasoning-Engine, die Nutzeranfragen interpretiert und entscheidet, was als Nächstes zu tun ist. Es kann den verfügbaren Kontext analysieren und bestimmen, ob direkt geantwortet oder ein Tool genutzt werden soll. LlamaIndex unterstützt verschiedene LLM-Anbieter, sodass Entwickler ein Modell je nach den Anforderungen ihrer Anwendung wählen können. Das LLM steuert somit die Entscheidungsfindung und Antwortgenerierung des Agents.
Tools: Erweiterung der Agent-Fähigkeiten
Tools ermöglichen es einem Agent, Aktionen auszuführen, die über die reine Texterzeugung hinausgehen. Sie können einfache Python-Funktionen oder spezialisierte Tools für die Arbeit mit APIs, Query-Engines und anderen externen Diensten sein. Der Agent entscheidet, welches Tool genutzt wird, und liefert die erforderlichen Eingaben basierend auf der Nutzeranfrage. Die Tool-Ergebnisse werden dann der Konversation hinzugefügt, damit der Agent sie im nächsten Schritt nutzen kann.
Speicher: Kontext beibehalten
Speicher ermöglicht es LlamaIndex-Agents, während der Erledigung einer Aufgabe relevante Informationen zu behalten. Standardmäßig nutzen Agents einen ChatMemoryBuffer, der den Konversationsverlauf während der Ausführung verfügbar hält. Entwickler können die Speicherkonfiguration auch anpassen, etwa indem sie ein Token-Limit je nach Anwendung festlegen. Das hilft Agents, den Kontext zu bewahren und Aufgaben zu bewältigen, die mehrere Schritte erfordern.
Arten von LlamaIndex-Agents
LlamaIndex bietet verschiedene Agent-Typen für die Bewältigung von Aufgaben, je nach dem erforderlichen Maß an Reasoning, Tool-Nutzung und Kontrolle. Schauen wir uns die wichtigsten Typen und ihre Unterschiede an:
| Agententyp | Funktionsweise | Hauptmerkmale | Beste Anwendungsfälle |
|---|---|---|---|
| FunctionAgent | Nutzt die Function-Calling-Fähigkeiten moderner LLMs, um vordefinierte Tools basierend auf Nutzeranfragen auszuwählen und auszuführen. | Native Tool-Aufrufe Strukturierte Ein- und Ausgaben Zuverlässige Tool-Ausführung Einfache Implementierung | KI-Assistenten Automatisierte Geschäftsabläufe API-basierte Anwendungen Aufgabenorientierte Agenten |
| ReActAgent | Nutzt den Reasoning-+-Acting-Ansatz, bei dem der Agent iterativ über eine Aufgabe nachdenkt, Aktionen ausführt, Ergebnisse beobachtet und so fortfährt, bis die Aufgabe abgeschlossen ist. | Schrittweises Reasoning Dynamische Tool-Auswahl Bewältigt mehrstufige Aufgaben Flexible Problemlösung | Recherche-Assistenten Beantwortung komplexer Fragen Datenexploration Offene Workflows |
| CodeActAgent | Ermöglicht es Agenten, Aufgaben durch das Generieren und Ausführen von Code zu lösen, wenn codebasiertes Reasoning effektiver ist. | Codegenerierung und -ausführung Programmatische Problemlösung Geeignet für rechnerische Aufgaben | Datenanalyse Wissenschaftliche Workflows Programmier-Assistenten |
| Multi-Agent-Systeme | Nutzt mehrere spezialisierte Agenten, die zusammenarbeiten, Aufgaben delegieren und gemeinsam komplexe Workflows abschließen. | Zusammenarbeit von Agenten Aufgabendelegation Rollenspezialisierung Skalierbare Workflows | Automatisierte Recherchepipelines Unternehmens-Workflows Komplexe Geschäftsprozesse |
Diese Agents geben Entwicklern die Flexibilität, den richtigen Ansatz für unterschiedliche Aufgaben und Workflows zu wählen. Sobald der Agent-Typ ausgewählt ist, besteht der nächste Schritt darin, ihn mit einem leistungsfähigen LLM-Backend zu verbinden, das sein Reasoning und die Tool-Nutzung unterstützt. Sehen wir uns an, wie Sie mit LlamaIndex und der Kimi API KI-Agents erstellen können.
Wie erstellt man KI-Agents mit LlamaIndex und Kimi API?
Die Verbindung von LlamaIndex mit einer LLM-API verleiht dem Agent die Reasoning-Fähigkeit, die er benötigt, um Anfragen zu verstehen und die richtigen Aktionen auszuwählen. Die folgenden Schritte zeigen, wie Sie einen KI-Agent mit LlamaIndex und der Kimi API einrichten, von der Modellkonfiguration bis zur Ausführung des Agents:
Schritt 1: Voraussetzungen
Stellen Sie vor Beginn sicher, dass Folgendes vorhanden ist:
Python 3.9+ installiert
Ein gültiger Kimi API Key von der Moonshot AI Platform
Grundlegende Vertrautheit mit LlamaIndex-Agenten und RAG-Konzepten
Schritt 2: Abhängigkeiten installieren
Das ursprüngliche Beispiel verwendet llama-index-llms-ollama. Ersetzen Sie es durch llama-index-llms-openai, um sich mit Kimis OpenAI-kompatibler API zu verbinden. Behalten Sie das HuggingFace-Embedding-Paket für lokale, kostenlose Embeddings bei.
pip install llama-index llama-index-llms-openai llama-index-embeddings-huggingfaceSchritt 3: Umgebungsvariablen konfigurieren
Speichern Sie Ihren Kimi API Key sicher über eine Umgebungsvariable. Hinterlegen Sie ihn nicht fest im Code Ihrer Skripte.
export KIMI_API_KEY = "your-kimi-api-key-here"Unter Windows (PowerShell):
$env:KIMI_API_KEY = "your-kimi-api-key-here"Schritt 4: Den grundlegenden Agenten mit der Kimi API erstellen
Erstellen Sie eine Datei mit dem Namen starter_kimi.py. Diese ersetzt das Ollama-LLM durch Kimi, während die gleiche Agentenlogik und Tool-Definitionen erhalten bleiben.
from llama_index.core.agent.workflow import FunctionAgent; import os
from llama_index.llms.openai import OpenAI; import asyncio
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.core import Settings
# Configure global settings
Settings.llm = OpenAI(
model="kimi-latest", # Or: kimi-k2, kimi-k2.5, etc.
api_key=os.getenv("KIMI_API_KEY"),
api_base="https://api.moonshot.ai/v1",
temperature=0.3,
request_timeout=120.0,
)
Settings.embed_model = HuggingFaceEmbedding(
model_name="BAAI/bge-base-en-v1.5"
)
# Define a calculator tool
def multiply(a: float, b: float) -> float:
"""Useful for multiplying two numbers."""
return a * b
# Create the agent
agent = FunctionAgent(
tools=[multiply],
llm=Settings.llm,
system_prompt="You are a helpful assistant that can multiply two numbers.",
)
async def main():
response = await agent.run("What is 1234 * 4567?")
print(str(response))
if __name__ == "__main__":
asyncio.run(main())Führen Sie das Skript aus:
python starter_kimi.pyErwartete Ausgabe:
The answer to 1234 * 4567 is 5635678.Schritt 5: Chat-Verlauf (Kontext) hinzufügen
Um Mehrfach-Konversationen zu ermöglichen, übergeben Sie ein Context-Objekt. Der Agent behält so das Gedächtnis über mehrere Aufrufe hinweg.
from llama_index.core.workflow import Context
# Create context
ctx = Context(agent)
# Run agent with context
response = await agent.run("My name is Logan", ctx=ctx)
print(response)
response = await agent.run("What is my name?", ctx=ctx)
print(response)Schritt 6: RAG-Funktionen mit der Kimi API hinzufügen
Erweitern Sie den Agenten um Dokumentenabruf. Der Embedding-Schritt bleibt lokal, während die Generierung über Kimi läuft.
Beispieldaten vorbereiten
mkdir data
wget https://raw.githubusercontent.com/run-llama/llama_index/main/docs/examples/data/paul_graham/paul_graham_essay.txt -O data/paul_graham_essay.txtVollständiges Skript für den RAG-fähigen Agenten
Erstellen Sie starter_kimi_rag.py:
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings; import os
from llama_index.core.agent.workflow import AgentWorkflow; import asyncio
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
# Global settings
Settings.embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-base-en-v1.5")
Settings.llm = OpenAI(
model="kimi-k3",
api_key=os.getenv("KIMI_API_KEY"),
api_base="https://api.moonshot.ai/v1",
temperature=0.3,
)
# Load documents and build index
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()
# Define tools
def multiply(a: float, b: float) -> float:
"""Useful for multiplying two numbers."""
return a * b
async def search_documents(query: str) -> str:
"""Useful for answering natural language questions about Paul Graham's essay."""
response = await query_engine.aquery(query)
return str(response)
# Create enhanced agent
agent = AgentWorkflow.from_tools_or_functions(
[multiply, search_documents],
llm=Settings.llm,
system_prompt="""You are a helpful assistant that can perform calculations
and search through documents to answer questions.""",
)
async def main():
response = await agent.run(
"What did the author do in college? Also, what's 7 * 8?"
)
print(response)
if __name__ == "__main__":
asyncio.run(main())Führen Sie das Skript aus:
python starter_kimi_rag.pypython starter_kimi_rag.pySchritt 7: Den RAG-Index persistieren
Um zu vermeiden, dass Dokumente bei jedem Durchlauf erneut verarbeitet werden, speichern Sie den Vektorindex dauerhaft auf der Festplatte.
# Save the index
index.storage_context.persist("storage")
# Later, load the index
from llama_index.core import StorageContext, load_index_from_storage
storage_context = StorageContext.from_defaults(persist_dir="storage")
index = load_index_from_storage(storage_context)
query_engine = index.as_query_engine()# Save the index
index.storage_context.persist("storage")
# Later, load the index
from llama_index.core import StorageContext, load_index_from_storage
storage_context = StorageContext.from_defaults(persist_dir="storage")
index = load_index_from_storage(storage_context)
query_engine = index.as_query_engine()Fehlerbehebung
Falls beim Einrichten des Agenten Probleme auftreten, können einige häufige Fehler die Authentifizierung, Konnektivität, Paketinstallation oder Embedding-Geschwindigkeit beeinträchtigen. Die folgende Tabelle zeigt die häufigsten Fehler und deren Lösungen, damit Sie Ihr Setup schnell überprüfen können:
| Problem | Ursache | Lösung |
|---|---|---|
AuthenticationError | Ungültiger oder fehlender API-Schlüssel | Prüfen Sie, ob KIMI_API_KEY korrekt exportiert wurde |
Connection timeout | Netzwerklatenz zu api.moonshot.ai | request_timeout auf 300.0 oder höher erhöhen |
ModuleNotFoundError | Fehlendes Paket | pip install llama-index-llms-openai erneut ausführen |
| Embedding läuft auf der CPU langsam | Hugging-Face-Modell läuft auf der CPU | Ein kleineres Modell verwenden oder GPU-Beschleunigung aktivieren |
Vorteile der Nutzung der Kimi API
Sobald der Agent verbunden ist und funktioniert, bietet die Kombination aus LlamaIndex und Kimi API mehrere praktische Vorteile für den Aufbau leistungsfähiger KI-Anwendungen. Hier sind einige zentrale Vorteile der Nutzung der Kimi API mit LlamaIndex-Agenten:
Intelligentere KI-Agenten erstellen: Die Kimi API erweitert LlamaIndex-Agenten mit starkem Sprachverständnis und Denkvermögen und hilft Agenten, Tools auszuwählen, Informationen zu verarbeiten und Aufgaben effektiver zu erledigen.
Datenabruf und -analyse verbessern: In Kombination mit dem Daten-Framework von LlamaIndex kann Kimi mit privaten Dokumenten und Wissensdatenbanken arbeiten, um genauere, kontextbezogene Antworten zu generieren.
Flexible KI-Workflows ermöglichen: LlamaIndex verbindet Agenten mit Tools, APIs und Query-Engines, während Kimi die Intelligenz liefert, um zu entscheiden, wann und wie diese Funktionen genutzt werden.
Komplexe KI-Anwendungen unterstützen: Mit langem Kontextverständnis und Agentenfähigkeiten ist die Kimi API mit LlamaIndex geeignet für den Aufbau von Recherche-Assistenten, Wissens-Agenten und Anwendungen zur Dokumentenanalyse.
Praxisanwendungen von LlamaIndex-Agenten
LlamaIndex-Agenten lassen sich für ein breites Spektrum an Aufgaben einsetzen, bei denen KI schlussfolgern, auf Informationen zugreifen und Aktionen ausführen muss. Ihre Fähigkeit, LLMs mit Tools und Daten zu verbinden, macht sie nützlich für Forschung, Business, Analytik und Kundensupport. Hier einige praktische Anwendungen:
KI-Forschungsassistent
Ein KI-Forschungsassistent kann Dokumente durchsuchen, relevante Informationen abrufen und bei der Beantwortung komplexer Fragen helfen. Er kann eine Forschungsaufgabe in kleinere Schritte unterteilen und bei Bedarf verschiedene Tools einsetzen. Das erleichtert die Analyse großer Informationsmengen und die Erstellung detaillierter Antworten.
Unternehmens-Wissensagent
Ein Unternehmens-Wissensagent kann Mitarbeiter mit internen Dokumenten, Datenbanken und Wissensdatenbanken verbinden. Er kann relevante Unternehmensinformationen abrufen und Antworten auf Basis verfügbarer Geschäftsdaten liefern. Das hilft Mitarbeitern, Informationen schneller zu finden, ohne mehrere Systeme manuell durchsuchen zu müssen.
Datenanalyse-Agent
Ein Datenanalyse-Agent kann mit Datensätzen arbeiten und Tools nutzen, um Informationen zu verarbeiten, zu analysieren und zu interpretieren. Er kann Berechnungen durchführen, Muster erkennen und Ergebnisse verständlich erklären. Das macht ihn nützlich für Aufgaben wie Reporting, Datenexploration und Geschäftsanalyse.
Kundenservice-Agent
Ein Kundenservice-Agent kann auf Produktinformationen, FAQs und Support-Ressourcen zugreifen, um Kundenfragen zu beantworten. Er kann Tools nutzen, um relevante Details abzurufen und Anfragen basierend auf dem verfügbaren Kontext zu bearbeiten. Das kann helfen, routinemäßige Support-Aufgaben zu automatisieren und dabei schnellere und konsistente Antworten zu liefern.
Fazit
LlamaIndex-Agents bieten eine praktische Möglichkeit, KI-Systeme zu entwickeln, die argumentieren, Tools nutzen und mit relevanten Informationen arbeiten können. Ihre Flexibilität macht sie nützlich für die Erstellung von Anwendungen, die über einfache Konversationen hinausgehen. Mit dem richtigen LLM-Backend lassen sich diese Agents an unterschiedliche Aufgaben und Workflows anpassen. Probieren Sie die Kimi API mit LlamaIndex aus, um Ihren eigenen KI-Agenten zu erstellen und zu testen. Entdecken Sie Kimi und sehen Sie, was Sie damit erschaffen können.