Hallo, Tech-Familie! Nina Torres ist wieder da von agntbox.com. Heute erkunden wir etwas, das in der KI-Community für Aufsehen sorgt, besonders für diejenigen von uns, die an der Schaffung personalisierter, kontextbewusster KI-Erlebnisse arbeiten. Ich spreche über LlamaIndex und insbesondere darüber, wie sich seine Abfrage-Engine weiterentwickelt hat, um zunehmend komplexe Dateninteraktionen zu bewältigen. Vergessen Sie es, einfach ein PDF hinzuwerfen und auf das Beste zu hoffen; wir schauen uns an, wie man es wirklich denken lässt, über mehrere, unterschiedliche Datenquellen hinweg.
Mein Posteingang, wie der vieler von Ihnen, ist mit Fragen überschwemmt worden, wie man über grundlegende RAG (Retrieval-Augmented Generation) Setups hinausgeht. Die Leute bauen unglaubliche Anwendungen, stoßen aber an eine Wand, wenn ihre KI Fragen beantworten muss, die die Synthese von Informationen aus einer Datenbank, einer Reihe von Dokumenten und einer live API erfordern. Das ist kein einfaches „finde diesen Text“ Problem mehr. Es ist ein „herausfinden, was wo zu fragen ist, und dann die Antworten kombinieren“ Problem. Und ehrlich gesagt, das ist ein Problem, mit dem ich an einem persönlichen Projekt für einen Kunden, der eine Nischen-E-Commerce-Seite betreibt, zu kämpfen hatte – stellen Sie sich einen KI-Assistenten vor, der den Produktbestand (Datenbank) überprüfen, Benutzerbewertungen (Dokumente) abrufen und verwandte Artikel basierend auf aktuellen Preisen (API) vorschlagen muss. Mein erstes LlamaIndex-Setup war, obwohl es für den Bewertungsbereich gut war, bei der Synthese aus mehreren Quellen völlig unzureichend.
Heute werden wir also die fortgeschrittenen Abfrage-Engine-Funktionen von LlamaIndex für die Synthese aus mehreren Quellen erkunden. Es geht nicht nur darum, verschiedene Arten von Daten zu indizieren; es geht darum, eine Abfrage-Engine zu bauen, die die Informationsbeschaffung über diese unterschiedlichen Quellen intelligent orchestriert, um komplexe, mehrteilige Fragen zu beantworten. Wir sprechen darüber, von einem einfachen Abruftool zu einem ausgeklügelten Routing- und Planungssystem zu gelangen.
Die Evolution des „Fragens“ in LlamaIndex
Erinnern Sie sich, als LlamaIndex zum ersten Mal auf der Szene erschien? Es war großartig, um unstrukturierte Daten in etwas zu verwandeln, mit dem ein LLM chatten konnte. Sie luden Dokumente hoch, bauten einen Index und fragten drauflos. Einfach, effektiv. Aber das Leben ist nicht immer einfach. Unsere Daten liegen nicht immer in sauberen Textdateien vor. Sie sind über SQL-Datenbanken, NoSQL-Speicher, APIs und eine Menge PDFs verstreut.
Der ursprüngliche Ansatz bestand oft darin, separate Indizes für jede Datenquelle zu erstellen. Sie hatten Ihren Dokumentenindex, Ihren SQL-Index, vielleicht ein API-Tool. Dann mussten Sie manuell entscheiden, welche Sie basierend auf den Eingaben des Benutzers abfragen. Das funktioniert für einfache Fälle, aber was ist mit einer Frage wie: „Was sind die durchschnittlichen Bewertungen für Produkte, die im letzten Quartal auf den Markt gekommen sind, und haben einige davon offene Support-Tickets?“
Diese Frage erfordert:
- Die Abfrage einer Datenbank nach Produktveröffentlichungsdaten und durchschnittlichen Bewertungen.
- Die Abfrage eines anderen Systems (vielleicht eines separaten Dokumentenspeichers oder einer API) nach offenen Support-Tickets, die mit diesen Produkten in Zusammenhang stehen.
- Die Synthese beider Informationsstücke, um eine kohärente Antwort zu liefern.
Hier hat LlamaIndex wirklich seine Leistung gesteigert und sich von isolierten Abrufwerkzeugen zu integrierten Abfrage-Engines entwickelt, die solche facettenreichen Abfragen verstehen und darauf reagieren können.
Über grundlegenden Abruf hinaus: Abfrageplanung und Routing
Die Magie geschieht mit dem, was LlamaIndex „Abfrageplanung“ und „Routing“ nennt. Anstatt einfach Textstücke abzurufen, versucht die Abfrage-Engine, oft selbst von einem LLM betrieben, zuerst, die Absicht des Benutzers zu verstehen, und entscheidet dann über die beste Strategie, um darauf zu antworten. Dies umfasst:
- Identifizierung von Teilfragen: Eine komplexe Frage in kleinere, unabhängige Fragen zu unterteilen.
- Zuordnung von Teilfragen zu Tools/Indizes: Bestimmen, welche spezifische Datenquelle (z.B. eine SQL-Datenbank, einen Vektorindex von Dokumenten, einen API-Endpunkt) am besten geeignet ist, um jede Teilfrage zu beantworten.
- Ausführen von Abfragen: Diese Teilabfragen gegen die ausgewählten Tools auszuführen.
- Synthese der Ergebnisse: Die einzelnen Antworten zu nehmen und sie zu einer einzigen, umfassenden Antwort zu kombinieren.
Das ist kein theoretisches Konzept; es wird praktisch umgesetzt durch Dinge wie LlamaIndex’ `QueryPipeline`, `RouterQueryEngine` und die Fähigkeit, benutzerdefinierte `Tools` zu definieren.
Einrichten zur Synthese aus mehreren Quellen: Ein praktisches Beispiel
Lassen Sie uns durch eine vereinfachte Version des Problems meines E-Commerce-Kunden gehen. Stellen Sie sich vor, wir haben drei Datenquellen:
- Produktdatenbank: Eine SQL-Datenbank mit Produkt-IDs, Namen, Preisen und Veröffentlichungsdaten.
- Bewertungsdokumente: Eine Sammlung von Benutzerbewertungen (PDFs, Textdateien) für jedes Produkt.
- Inventar-API: Eine einfache API, die aktuelle Lagerbestände für eine gegebene Produkt-ID zurückgibt.
Unser Ziel ist es, eine Frage wie: „Erzählen Sie mir von ‚Fancy Widget Pro‘ – wie hoch ist der Preis, was sagen die Benutzer darüber, und ist es derzeit auf Lager?“ zu beantworten.
Schritt 1: Vorbereiten Ihrer Datenquellen und Tools
Zuerst müssen wir sicherstellen, dass jede Datenquelle für LlamaIndex als „Tool“ zugänglich ist.
A. SQL-Datenbank-Tool
Wir werden LlamaIndex’ `SQLTableRetrieverTool` dafür verwenden. Vorausgesetzt, Sie haben eine einfache SQLite-Datenbank namens `products.db` mit einer `products`-Tabelle.
from llama_index.core import SQLDatabase
from sqlalchemy import create_engine, text
from llama_index.core.tools import SQLTableRetrieverTool
# Erstellen Sie eine Dummy-Datenbank und Tabelle zur Demonstration
engine = create_engine("sqlite:///products.db")
with engine.connect() as connection:
connection.execute(text("""
CREATE TABLE IF NOT EXISTS products (
product_id TEXT PRIMARY KEY,
name TEXT,
price REAL,
launch_date TEXT
);
"""))
connection.execute(text("""
INSERT OR IGNORE INTO products (product_id, name, price, launch_date) VALUES
('FWP001', 'Fancy Widget Pro', 129.99, '2025-01-15'),
('MGS002', 'Mega Gadget Super', 249.00, '2024-11-01');
"""))
connection.commit()
sql_database = SQLDatabase(engine=engine)
sql_tool = SQLTableRetrieverTool.from_instances(
sql_database=sql_database,
table_names=["products"],
description=(
"Nützlich für das Abfragen von Produktinformationen wie Name, Preis und Veröffentlichungsdatum. "
"Die Eingabe sollte eine SQL-Abfrage für die 'products'-Tabelle sein."
)
)
Nina’s Take: Dieses `SQLTableRetrieverTool` ist ein Lebensretter. Vorher musste ich benutzerdefinierte Funktionen schreiben, um mit Datenbanken zu interagieren, und es fühlte sich an, als würde ich jedes Mal das Rad neu erfinden. Dieses Tool macht es viel übersichtlicher, obwohl man dennoch auf das Prompt Engineering achten muss, um sicherzustellen, dass das LLM gute SQL-Abfragen erzeugt.
B. Bewertungsdokument-Index-Tool
Für die Bewertungen werden wir einen Vektorindex aus einigen Dummy-Bewertungsdokumenten erstellen.
import os
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.core.tools import QueryEngineTool
# Erstellen Sie ein Dummy-Bewertungsverzeichnis und Dateien
os.makedirs("reviews", exist_ok=True)
with open("reviews/FWP001_reviews.txt", "w") as f:
f.write("Bewertungen für Fancy Widget Pro:\n")
f.write("1. 'Ich liebe den Fancy Widget Pro! So schnell und zuverlässig.' - Benutzer A\n")
f.write("2. 'Ein wenig teuer, aber für die Qualität wert.' - Benutzer B\n")
f.write("3. 'Hat meinen Arbeitsablauf erheblich verbessert.' - Benutzer C\n")
with open("reviews/MGS002_reviews.txt", "w") as f:
f.write("Bewertungen für Mega Gadget Super:\n")
f.write("1. 'Die Akkulaufzeit ist unglaublich!' - Benutzer X\n")
f.write("2. 'Verwirrender Einrichtungsprozess.' - Benutzer Y\n")
# Dokumente laden und einen Index erstellen
documents = SimpleDirectoryReader("reviews").load_data()
review_index = VectorStoreIndex.from_documents(documents)
review_query_engine = review_index.as_query_engine()
review_tool = QueryEngineTool(
query_engine=review_query_engine,
metadata={"name": "review_tool",
"description": "Nützlich für die Beantwortung von Fragen zu Produktbewertungen aus Benutzerfeedback-Dokumenten. "
"Die Eingabe sollte ein spezifischer Produktname oder eine ID sein."}
)
Nina’s Take: Das `QueryEngineTool` ist Ihr bevorzugtes Werkzeug, um jede bestehende LlamaIndex-Abfrage-Engine in ein Tool zu verpacken. Es ist unglaublich flexibel. Stellen Sie nur sicher, dass Ihre `description` super klar ist, damit das LLM weiß, wann es verwendet werden soll.
C. Inventar-API-Tool
Für die API simulieren wir eine einfache Python-Funktion als API-Aufruf mit `FunctionTool`.
from llama_index.core.tools import FunctionTool
# Simulieren einer Inventar-API
def get_stock_level(product_id: str) -> str:
"""
Gibt den aktuellen Lagerbestand für eine gegebene Produkt-ID zurück.
Args:
product_id (str): Die ID des Produkts.
Returns:
str: Eine Zeichenfolge, die den Lagerbestand angibt, z.B. "Auf Lager", "Niedriger Lagerbestand", "Nicht auf Lager".
"""
if product_id == "FWP001":
return "Auf Lager"
elif product_id == "MGS002":
return "Niedriger Lagerbestand"
else:
return "Nicht auf Lager"
inventory_tool = FunctionTool.from_defaults(fn=get_stock_level,
description=(
"Nützlich zur Überprüfung des aktuellen Lagerbestands eines Produkts. "
"Die Eingabe sollte eine Produkt-ID sein (z.B. 'FWP001')."
))
Nina’s Take: `FunctionTool` ist purer Genius. Sie können fast jede Python-Funktion verpacken und sie Ihrem LLM zugänglich machen. So verbinden Sie sich mit tatsächlichen APIs, internen Diensten oder führen lokale Skripte aus. Es ist ein bedeutender Schritt, um externe Aktionen in die Fähigkeiten Ihrer KI zu integrieren.
Schritt 2: Aufbau der Router-Abfrage-Engine
Jetzt, wo wir unsere einzelnen Werkzeuge haben, brauchen wir einen Weg, damit LlamaIndex diese intelligent auswählt und nutzt. Hier kommt der `RouterQueryEngine` ins Spiel. Er verwendet ein LLM, um zu entscheiden, welches Werkzeug (oder welche Werkzeugsequenz) basierend auf der Anfrage des Benutzers verwendet werden soll.
from llama_index.core.query_engine import RouterQueryEngine
from llama_index.core.selectors import LLMSingleSelector
from llama_index.llms.openai import OpenAI # Vorausgesetzt, Sie haben den OpenAI API-Schlüssel konfiguriert
# Initialisieren Sie das LLM (z.B. OpenAI) für Routing und Synthese
llm = OpenAI(model="gpt-3.5-turbo") # Oder gpt-4, je nach Bedarf und Budget
# Kombinieren Sie alle Werkzeuge
all_tools = [sql_tool, review_tool, inventory_tool]
# Erstellen Sie den RouterQueryEngine
router_query_engine = RouterQueryEngine(
selector=LLMSingleSelector.from_defaults(llm=llm),
query_engine_tools=all_tools,
verbose=True # Auf True setzen, um die Routing-Entscheidungen zu sehen
)
Ninas Meinung: Der `LLMSingleSelector` ist die Standardmethode und oft ausreichend, um dem Router zu sagen, welches Werkzeug er verwenden soll. Für komplexere Szenarien bietet LlamaIndex andere Selector oder Sie können sogar einen benutzerdefinierten erstellen. Das `verbose=True` ist während der Entwicklung absolut unerlässlich – es zeigt Ihnen, was das LLM „denkt“, wenn es versucht, Ihre Anfrage zu routen, was für das Debugging sehr wertvoll ist.
Schritt 3: Abfragen der Multi-Source-Engine
Lassen Sie uns unsere komplexe Frage stellen:
response = router_query_engine.query("Erzählen Sie mir von 'Fancy Widget Pro' – wie viel kostet es, was sagen die Benutzer darüber, und ist es derzeit auf Lager?")
print(response)
Wenn Sie dies ausführen, sehen Sie die `verbose`-Ausgabe, die den Denkprozess des LLM zeigt:
- Es wird feststellen, dass für „Preis“ das `sql_tool` benötigt wird.
- „Was Benutzer sagen“ benötigt das `review_tool`.
- „Derzeit auf Lager“ benötigt das `inventory_tool`.
Das LLM wird dann jedes dieser Werkzeuge ausführen, deren jeweilige Antworten erhalten und schließlich in eine einzige, kohärente Antwort synthetisieren. Es ist wie einen Mini-Orchesterleiter für Ihre Daten zu haben!
Eine typische Ausgabe könnte etwa so aussehen:
> Auswahl des Abfrage-Engine-Werkzeugs: sql_tool
> Auswahl des Abfrage-Engine-Werkzeugs: review_tool
> Auswahl des Abfrage-Engine-Werkzeugs: inventory_tool
Das Fancy Widget Pro (Produkt-ID FWP001) kostet 129,99 $. Benutzer lieben es im Allgemeinen und beschreiben es als „schnell und zuverlässig“ und geben an, dass es „ihren Workflow erheblich verbessert“ hat, obwohl einige erwähnen, dass es „ein bisschen teuer“ ist. Es ist derzeit auf Lager.
Dies ist eine erhebliche Verbesserung gegenüber dem manuellen Abfragen jeder Quelle. Das LLM übernimmt die Orchestrierung, was die Interaktion viel natürlicher und leistungsfähiger macht.
Erweiterte Szenarien: Abfrage-Pipelines und rekursives Routing
Der `RouterQueryEngine` ist großartig, um ein einzelnes Werkzeug auszuwählen, um eine Unterfrage zu beantworten. Aber was ist, wenn die Ausgabe eines Werkzeugs als Eingabe für ein anderes benötigt wird? Oder wenn Sie eine spezifische Abfolge von Operationen benötigen, die von einer einfachen Auswahl eines einzigen Werkzeugs nicht gehandhabt werden kann?
Hier wird `QueryPipeline` unglaublich leistungsfähig. Es ermöglicht Ihnen, mehrere Komponenten, einschließlich Werkzeuge, Abrufmechanismen, LLMs und sogar andere Abfrage-Engines, in einer gerichteten azyklischen Graphen (DAG)-Struktur zu verknüpfen.
Stellen Sie sich ein Szenario vor: „Finden Sie alle Produkte, die in den letzten 6 Monaten veröffentlicht wurden, die einen niedrigen Lagerbestand und positive Bewertungen haben.“
- Abfrage der SQL-Datenbank nach Produkten, die in den letzten 6 Monaten veröffentlicht wurden.
- Für jede Produkt-ID aus Schritt 1, überprüfen Sie den Lagerbestand über die API. Filtern Sie nach „Niedriger Lagerbestand“.
- Für die verbleibenden Produkte, Abfrage der Bewertungsdokumente nach Stimmung. Filtern Sie nach „positiven Bewertungen“.
- Synthese der endgültigen Liste.
Dies ist ein mehrstufiger, bedingter Prozess. Sie könnten eine `QueryPipeline` dafür erstellen, wobei die Ausgabe eines Schrittes die Eingabe für den nächsten wird, möglicherweise mit einem LLM dazwischen, um Zwischenresultate zu verarbeiten oder den nächsten Schritt zu entscheiden.
Obwohl wir hier kein vollständiges Beispiel für eine `QueryPipeline` erstellen werden (das ist ein ganz eigener Artikel!), sollten Sie verstehen, dass sie die Flexibilität für wirklich komplexe Workflow-Automatisierung innerhalb Ihrer LlamaIndex-Anwendung bietet. Sie können sogar einen `RouterQueryEngine` innerhalb einer `QueryPipeline` für rekursives Entscheidungsmanagement einbetten.
Umsetzbare Erkenntnisse für Ihr nächstes KI-Projekt
- Kartieren Sie Ihre Datenquellen: Bevor Sie auch nur eine Zeile Code schreiben, identifizieren Sie klar alle Datenquellen, mit denen Ihre KI interagieren muss. Verstehen Sie deren Struktur (strukturiert, unstrukturiert, API-gesteuert).
- Definieren Sie klare Werkzeuge: Erstellen Sie für jede Datenquelle ein spezifisches LlamaIndex `Tool` (z.B. `SQLTableRetrieverTool`, `QueryEngineTool`, `FunctionTool`). Wichtig ist, schreiben Sie klare und beschreibende `metadata` für jedes Werkzeug. Diese Beschreibung ist das, was das LLM verwendet, um zu entscheiden, wann es aufgerufen werden soll. Nehmen Sie sich dafür Zeit; es ist das Prompt-Engineering für Ihre Werkzeuge!
- Beginnen Sie mit `RouterQueryEngine`: Für erste Projekte mit mehreren Quellen ist `RouterQueryEngine` oft der einfachste Einstiegspunkt. Es übernimmt die LLM-basierte Entscheidungsfindung für Sie.
- Verwenden Sie `verbose=True` umfangreich: Ernsthaft, das ist Ihr bester Freund. Es gibt Ihnen Einblick in das Denken des LLM und hilft Ihnen, die Beschreibungen Ihrer Werkzeuge zu verfeinern, wenn der Router unerwartete Entscheidungen trifft.
- Betrachten Sie `QueryPipeline` für Workflows: Wenn Ihre Fragen sequentielle Schritte, bedingte Logik oder dort enthalten, wo die Ausgabe eines Werkzeugs direkt als Eingabe für ein anderes dient, beginnen Sie, über `QueryPipeline` nachzudenken. Es ist komplexer einzurichten, bietet aber unvergleichliche Kontrolle über mehrstufige Interaktionen.
- Iterieren Sie über Werkzeugbeschreibungen: Die Fähigkeit des LLM, das richtige Werkzeug auszuwählen, hängt stark davon ab, wie gut Sie den Zweck und die erwartete Eingabe/Ausgabe jedes Werkzeugs beschrieben haben. Scheuen Sie sich nicht, mit verschiedenen Formulierungen zu experimentieren.
Die Fähigkeit von LlamaIndex, Abfragen intelligent über verschiedene Datenquellen hinweg zu orchestrieren, ist ein großer Fortschritt beim Bau wirklich intelligenter Agenten. Es bringt uns weg von fragiler, fest codierter Logik und hin zu Systemen, die über Informationsbedarfe nachdenken und dynamisch Daten von den geeignetsten Orten abrufen können. Der E-Commerce-Assistent meines Kunden ist jetzt um einiges schlauer, kann Preise aus der Datenbank abrufen, Benutzerstimmungen aus Bewertungen und Bestandsniveaus von der API, alles aus einer einzigen Anfrage in natürlicher Sprache. Es ist wirklich beeindruckend!
Das war’s für heute, Leute! Gehen Sie und bauen Sie einige unglaublich intelligente, multiquellen KIs. Lassen Sie mich in den Kommentaren wissen, was Sie aufbauen!
Verwandte Artikel
- **TITEL: Die CLI-Werkzeuge, die ich liebe und warum Sie sie auch lieben sollten**
- So integrieren Sie KI-SDKs
- Beste Praktiken für die Entwicklung von KI-Agenten
🕒 Published: