LlamaIndex: Private Daten zu LLMs hinzufügen

LlamaIndex ist ein Daten-Framework für Anwendungen, die auf Large Language Models (LLMs) basieren. LLMs wie GPT-4 sind vorab auf riesigen öffentlichen Datensätzen trainiert und liefern dadurch starke Fähigkeiten in der Sprachverarbeitung direkt ab Werk. Ohne Zugriff auf deine eigenen privaten Daten bleibt ihr Nutzen jedoch begrenzt.

LlamaIndex ermöglicht es dir, Daten aus APIs, Datenbanken, PDFs und mehr über flexible Datenkonnektoren einzulesen. Diese Daten werden in Zwischenrepräsentationen indexiert, die für LLMs optimiert sind. Anschließend kannst du deine Daten per natürlicher Sprache abfragen und darüber chatten – über Query-Engines, Chat-Oberflächen und LLM-gestützte Data Agents. So können LLMs auf private Daten im großen Stil zugreifen und sie interpretieren, ohne dass das Modell auf neueren Daten neu trainiert werden muss.

Egal, ob du als Einsteiger eine einfache Möglichkeit suchst, deine Daten in natürlicher Sprache zu befragen, oder als fortgeschrittener Nutzer tiefgreifende Anpassungen brauchst: LlamaIndex liefert die passenden Werkzeuge. Die High-Level-API erlaubt den Start in nur fünf Zeilen Code, während Low-Level-APIs volle Kontrolle über Dateneinzug, Indexierung, Retrieval und mehr bieten.

Wie funktioniert LlamaIndex?

LlamaIndex setzt auf Retrieval Augmented Generation (RAG), das große Sprachmodelle mit einer privaten Wissensbasis kombiniert. Im Kern gibt es zwei Phasen: die Indexierungsphase und die Abfragephase.

Grafik aus High-Level Concepts

Indexierungsphase

In der Indexierungsphase bringt LlamaIndex private Daten effizient in einen Vektorindex. So entsteht eine durchsuchbare Wissensbasis, die speziell auf deine Domäne zugeschnitten ist. Du kannst Textdokumente, Datenbanksätze, Knowledge Graphs und weitere Datentypen einbinden.

Im Grunde wandelt die Indexierung Daten in numerische Vektoren bzw. Embeddings um, die ihre semantische Bedeutung abbilden. Dadurch werden schnelle Ähnlichkeitssuchen über den gesamten Inhalt möglich.

Abfragephase

In der Abfragephase sucht die RAG-Pipeline auf Basis der Nutzerfrage nach den relevantesten Informationen. Diese Informationen werden zusammen mit der Frage an das LLM übergeben, um eine präzise Antwort zu erzeugen.

So erhält das LLM Zugriff auf aktuelle und neue Informationen, die beim ursprünglichen Training nicht enthalten waren.

Die zentrale Herausforderung in dieser Phase ist das effiziente Auffinden, Strukturieren und Verknüpfen potenziell mehrerer Wissensbasen.

Erfahre mehr über RAG in unserem Code-along zu Retrieval Augmented Generation mit PineCone.

LlamaIndex einrichten

Bevor wir ins Tutorial und Projekt einsteigen, installieren wir das Python-Paket und richten die API ein.

LlamaIndex lässt sich mit pip ganz einfach installieren.

pip install llama-indexBereitgestellt von

Standardmäßig nutzt LlamaIndex das OpenAI-Modell GPT-3 text-davinci-003. Um dieses Modell zu verwenden, brauchst du einen eingerichteten OPENAI_API_KEY. Du kannst ein kostenloses Konto anlegen und einen API-Schlüssel erhalten, indem du dich bei OpenAI’s new API token einloggst.

import os

os.environ["OPENAI_API_KEY"] = "INSERT OPENAI KEY"Bereitgestellt von

Stelle außerdem sicher, dass das Paket openai installiert ist.

pip install openaiBereitgestellt von

Private Daten mit LlamaIndex zu LLMs hinzufügen

In diesem Abschnitt erstellen wir mit LlamaIndex einen Lebenslauf-Reader. Du kannst deinen Lebenslauf auf deiner LinkedIn-Profilseite herunterladen, über „Mehr“ und dann „Als PDF speichern“.

Hinweis: Wir verwenden DataLab, um den Python-Code auszuführen. Du findest sämtlichen Code und die Ausgaben im Workbook LlamaIndex: Adding Personal Data to LLMs. Du kannst dir ganz einfach eine eigene Kopie erstellen und alles ausführen, ohne etwas lokal installieren zu müssen.

Bevor wir starten, müssen wir llama-index, openai und pypdf installieren. pypdf benötigen wir, um PDF-Dateien zu lesen und zu konvertieren.

%pip install llama-index openai pypdfBereitgestellt von

Daten laden und Index erstellen

Wir haben ein Verzeichnis namens "Private-Data" mit genau einer PDF-Datei. Diese lesen wir mit dem SimpleDirectoryReader ein und wandeln sie mit dem TreeIndex in einen Index um.

from llama_index import TreeIndex, SimpleDirectoryReader

resume = SimpleDirectoryReader("Private-Data").load_data()
new_index = TreeIndex.from_documents(resume)Bereitgestellt von

Eine Abfrage ausführen

Sobald die Daten indexiert sind, kannst du mit as_query_engine() Fragen stellen. Diese Funktion ermöglicht es dir, gezielt Informationen im Dokument abzufragen und mithilfe des OpenAI-Modells GPT-3 text-davinci-003 passende Antworten zu erhalten.

Hinweis: Du kannst die OpenAI API in DataLab gemäß dem Tutorial Using GPT-3.5 and GPT-4 via the OpenAI API in Python einrichten.

Wie zu sehen ist, hat das LLM die Anfrage korrekt beantwortet. Es hat den Index durchsucht und die relevanten Informationen gefunden.

query_engine = new_index.as_query_engine()
response = query_engine.query("When did Abid graduated?")
print(response)Bereitgestellt von

Abid graduated in February 2014.Bereitgestellt von

Wir können weiter zu Zertifizierungen nachfragen. Offenbar hat LlamaIndex ein vollständiges Bild des Kandidaten gewonnen – ein Vorteil für Unternehmen, die gezielt nach bestimmten Profilen suchen.

response = query_engine.query("What is the name of certification that Abid received?")
print(response)Bereitgestellt von

Data Scientist ProfessionalBereitgestellt von

Kontext speichern und laden

Das Erstellen eines Index ist zeitaufwendig. Um das erneute Erstellen zu vermeiden, können wir den Kontext speichern. Standardmäßig legt der folgende Befehl den Index-Store im Verzeichnis ./storage ab.

new_index.storage_context.persist()Bereitgestellt von

Anschließend können wir den Storage-Kontext schnell laden und daraus einen Index erstellen.

from llama_index import StorageContext, load_index_from_storage

storage_context = StorageContext.from_defaults(persist_dir="./storage")
index = load_index_from_storage(storage_context)Bereitgestellt von

Zur Kontrolle stellen wir dem Query-Engine die Frage aus dem Lebenslauf. Es sieht so aus, als hätten wir den Kontext erfolgreich geladen.

query_engine = index.as_query_engine()
response = query_engine.query("What is Abid's job title?")
print(response)Bereitgestellt von

Abid's job title is Technical Writer.Bereitgestellt von

Chatbot

Statt klassischem Q&A können wir mit LlamaIndex auch einen persönlichen Chatbot erstellen. Dafür initialisieren wir den Index mit der Funktion as_chat_engine().

Wir starten mit einer einfachen Frage.

query_engine = index.as_chat_engine()
response = query_engine.chat("What is the job title of Abid in 2021?")
print(response)Bereitgestellt von

Abid's job title in 2021 is Data Science Consultant.Bereitgestellt von

Ohne zusätzlichen Kontext stellen wir Anschlussfragen.

response = query_engine.chat("What else did he do during that time?")
print(response)Bereitgestellt von

In 2021, Abid worked as a Data Science Consultant for Guidepoint, a Writer for Towards Data Science and Towards AI, a Technical Writer for Machine Learning Mastery, an Ambassador for Deepnote, and a Technical Writer for Start It Up.Bereitgestellt von

Es ist klar erkennbar, dass die Chat-Engine einwandfrei funktioniert.

Nachdem du deine Sprach-Anwendung gebaut hast, solltest du dich als Nächstes mit Vor- und Nachteilen von LLMs in der Cloud gegenüber lokalem Betrieb beschäftigen. So findest du heraus, welcher Ansatz für dich am besten passt.

Wiki-Text-zu-Sprache mit LlamaIndex bauen

Im nächsten Projekt entwickeln wir eine Anwendung, die Fragen mit Inhalten aus Wikipedia beantwortet und die Antworten anschließend vertont.

Quellcode und weitere Informationen findest du in diesem DataLab-Workbook.

Wikipedia-Seite scrapen

Zuerst scrapen wir die Daten von der Seite Italy - Wikipedia und speichern sie als Datei italy_text.txt im Ordner data.

from pathlib import Path

import requests

response = requests.get(
    "https://en.wikipedia.org/w/api.php",
    params={
        "action": "query",
        "format": "json",
        "titles": "Italy",
        "prop": "extracts",
        # 'exintro': True,
        "explaintext": True,
    },
).json()
page = next(iter(response["query"]["pages"].values()))
italy_text = page["extract"]

data_path = Path("data")

if not data_path.exists():
    Path.mkdir(data_path)

with open("data/italy_text.txt", "w") as fp:
    fp.write(italy_text)Bereitgestellt von

Daten laden und Index aufbauen

Als Nächstes installieren wir die benötigten Pakete. Mit dem Paket elevenlabs können wir Text bequem per API in Sprache umwandeln.

%pip install llama-index openai elevenlabsBereitgestellt von

Mit dem SimpleDirectoryReader laden wir die Daten und überführen die TXT-Datei mit VectorStoreIndex in einen Vektorspeicher.

from llama_index import VectorStoreIndex, SimpleDirectoryReader
from IPython.display import Markdown, display
from llama_index.tts import ElevenLabsTTS
from IPython.display import Audio

documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)Bereitgestellt von

Abfrage

Unser Plan: Wir stellen eine allgemeine Frage zum Land und erhalten eine Antwort vom LLM-query_engine.

query = "Tell me an interesting fact about the country?"
query_engine = index.as_query_engine()
response = query_engine.query(query)

display(Markdown(f"<b>{query}</b>"))
display(Markdown(f"<p>{response}</p>"))Bereitgestellt von

Text zu Sprache

Danach nutzen wir das Modul llama_index.tts, um auf die ElevenLabsTTS-API zuzugreifen. Für die Audiogenerierung brauchst du einen ElevenLabs-API-Schlüssel. Einen kostenlosen Schlüssel erhältst du auf der Website von ElevenLabs.

import os

elevenlabs_key = os.environ["ElevenLabs_key"]
tts = ElevenLabsTTS(api_key=elevenlabs_key)Bereitgestellt von

Wir übergeben die Antwort an die Funktion generate_audio, um eine natürliche Stimme zu erzeugen. Zum Anhören verwenden wir die Audio-Funktion aus IPython.display.

audio = tts.generate_audio(str(response))
Audio(audio)Bereitgestellt von

Dies ist ein einfaches Beispiel. Du kannst mehrere Module kombinieren und deinen Assistenten – ähnlich wie Siri – bauen, der Fragen beantwortet, indem er deine privaten Daten interpretiert. Weitere Informationen findest du in der LlamaIndex-Dokumentation.

Neben LlamaIndex kannst du mit LangChain ebenfalls LLM-basierte Anwendungen entwickeln. Lies außerdem die Introduction to LangChain for Data Engineering & Data Applications, um einen Überblick darüber zu bekommen, was mit LangChain möglich ist – inklusive der Probleme, die LangChain löst, und praxisnaher Daten-Use-Cases.

LlamaIndex: Einsatzszenarien

LlamaIndex stellt einen vollständigen Werkzeugkasten für sprachbasierte Anwendungen bereit. Zusätzlich kannst du über den Llama Hub verschiedene Data Loader und Agent-Tools nutzen, um komplexe Anwendungen mit mehreren Funktionen zu entwickeln.

Du kannst eigene Datenquellen über einen oder mehrere Plugin-Data-Loader an dein LLM anbinden.

Data Loader aus dem Llama Hub

Außerdem stehen Agent-Tools zur Verfügung, um Drittanbieter-Tools und -APIs zu integrieren.

Agent Tools aus dem Llama Hub

Kurz gesagt, mit LlamaIndex kannst du Folgendes bauen:

• Q&A über Dokumente
• Chatbots
• Agents
• Strukturierte Daten
• Vollständige Webanwendungen
• Private Setups

Details zu diesen Use Cases findest du in der LlamaIndex-Dokumentation.

Fazit

LlamaIndex bietet einen leistungsstarken Werkzeugkasten für Retrieval-Augmented-Generation-Systeme, die die Stärken großer Sprachmodelle mit individuellen Wissensbasen verbinden. Du kannst domänenspezifische Daten indexieren und sie bei der Inferenz als kontextgebende Grundlage für das LLM nutzen, um hochwertige Antworten zu erzeugen.

In diesem Tutorial haben wir LlamaIndex und seine Funktionsweise kennengelernt. Außerdem haben wir einen Lebenslauf-Reader sowie ein Text-zu-Sprache-Projekt mit nur wenigen Zeilen Python-Code umgesetzt. Das Bauen von LLM-Anwendungen mit LlamaIndex ist unkompliziert und bietet eine große Bibliothek an Plugins, Data Loadern und Agents.

Wenn du ein echter LLM-Profi werden willst, ist der nächste Schritt der Kurs Master Large Language Models Concepts. Er vermittelt dir ein umfassendes Verständnis von LLMs – von Einsatzszenarien über Trainingsmethoden und ethische Fragen bis hin zu aktuellen Forschungsergebnissen.