Aufbau von LLM-Agents für RAG von Grund auf und darüber hinaus: Ein umfassender Leitfaden

LLMs wie GPT-3, GPT-4 und ihre Open-Source-Gegenstücke haben oft Schwierigkeiten, auf dem neuesten Stand der Informationsbeschaffung zu bleiben, und können manchmal Halluzinationen oder falsche Informationen generieren.

Retrieval-Augmented Generation (RAG) ist eine Technik, die die Leistung von LLMs mit externer Wissensbeschaffung kombiniert. RAG ermöglicht es uns, LLM-Antworten auf tatsächliche, aktuelle Informationen zu gründen, was die Genauigkeit und Zuverlässigkeit von künstlich generiertem Inhalt erheblich verbessert.

In diesem Blogbeitrag werden wir uns damit befassen, wie man LLM-Agents für RAG von Grund auf aufbaut, indem wir tief in die Architektur, Implementierungsdetails und fortgeschrittene Techniken eintauchen. Wir werden alles von den Grundlagen von RAG bis hin zum Erstellen von komplexen Agents, die in der Lage sind, komplexe Aufgaben und Denkprozesse auszuführen, abdecken.

Bevor wir mit dem Aufbau unseres LLM-Agents beginnen, sollten wir verstehen, was RAG ist und warum es wichtig ist.

RAG, oder Retrieval-Augmented Generation, ist ein hybrider Ansatz, der Informationsbeschaffung mit Textgenerierung kombiniert. In einem RAG-System:

• Wird eine Abfrage verwendet, um relevante Dokumente aus einer Wissensbasis abzurufen.
• Werden diese Dokumente dann zusammen mit der ursprünglichen Abfrage in ein Sprachmodell eingegeben.
• Generiert das Modell eine Antwort basierend auf der Abfrage und den abgerufenen Informationen.

RAG

Dieser Ansatz hat mehrere Vorteile:

• Verbesserte Genauigkeit: Durch die Grundierung von Antworten auf abgerufene Informationen reduziert RAG Halluzinationen und verbessert die faktische Genauigkeit.
• Aktuelle Informationen: Die Wissensbasis kann regelmäßig aktualisiert werden, sodass das System auf aktuelle Informationen zugreifen kann.
• Transparenz: Das System kann Quellen für seine Informationen bereitstellen, was das Vertrauen erhöht und eine Überprüfung ermöglicht.

Verständnis von LLM-Agents

LLM-Powered Agents

Wenn Sie ein Problem ohne einfache Antwort haben, müssen Sie oft mehrere Schritte ausführen, sorgfältig nachdenken und sich daran erinnern, was Sie bereits versucht haben. LLM-Agents sind für genau diese Arten von Situationen in Sprachmodell-Anwendungen konzipiert. Sie kombinieren gründliche Datenanalyse, strategische Planung, Datenabruf und die Fähigkeit, aus vergangenen Aktionen zu lernen, um komplexe Probleme zu lösen.

Was sind LLM-Agents?

LLM-Agents sind fortschrittliche KI-Systeme, die für die Erstellung komplexer Texte konzipiert sind, die sequenzielles Denken erfordern. Sie können vorausdenken, vergangene Gespräche in Erinnerung rufen und verschiedene Werkzeuge verwenden, um ihre Antworten basierend auf der Situation und dem benötigten Stil anzupassen.

Ein Beispiel für eine Frage im Rechtsbereich könnte lauten: “Was sind die möglichen rechtlichen Konsequenzen einer bestimmten Art von Vertragsbruch in Kalifornien?” Ein grundlegender LLM mit einem RAG-System kann die erforderlichen Informationen aus Rechtsdatenbanken abrufen.

Für ein detaillierteres Szenario: “Im Lichte neuer Datenschutzgesetze, welche rechtlichen Herausforderungen stellen Unternehmen und wie haben Gerichte diese Fragen behandelt?” Diese Frage geht tiefer als nur die Suche nach Fakten. Es geht darum, neue Regeln zu verstehen, ihre Auswirkungen auf verschiedene Unternehmen und die Reaktionen der Gerichte. Ein LLM-Agent würde diese Aufgabe in UnterAufgaben aufteilen, wie z.B. das Abrufen der neuesten Gesetze, die Analyse historischer Fälle, die Zusammenfassung von Rechtsdokumenten und die Vorhersage von Trends basierend auf Mustern.

Bestandteile von LLM-Agents

LLM-Agents bestehen in der Regel aus vier Komponenten:

1. Agent/Hirn: Das Kern-Sprachmodell, das Sprache verarbeitet und versteht.
2. Planung: Die Fähigkeit, zu denken, Aufgaben zu unterteilen und spezifische Pläne zu entwickeln.
3. Speicher: Bewahrt Aufzeichnungen von vergangenen Interaktionen und lernt daraus.
4. Werkzeugverwendung: Integriert verschiedene Ressourcen, um Aufgaben auszuführen.

Agent/Hirn

Im Kern eines LLM-Agents befindet sich ein Sprachmodell, das Sprache basierend auf großen Mengen an Trainingsdaten verarbeitet und versteht. Sie beginnen, indem Sie ihm einen bestimmten Prompt geben, der den Agenten anweist, wie er antworten, welche Werkzeuge er verwenden und welche Ziele er anstreben soll. Sie können den Agenten mit einer Persona anpassen, die für bestimmte Aufgaben oder Interaktionen geeignet ist, was seine Leistung verbessert.

Speicher

Die Speicher-Komponente hilft LLM-Agents, komplexe Aufgaben zu bewältigen, indem sie eine Aufzeichnung von vergangenen Aktionen bewahrt. Es gibt zwei Haupttypen von Speicher:

• Kurzzeit-Speicher: Funktioniert wie ein Notizblock, der laufende Gespräche verfolgt.
• Langzeit-Speicher: Funktioniert wie ein Tagebuch, das Informationen aus vergangenen Interaktionen speichert, um Muster zu lernen und bessere Entscheidungen zu treffen.

Durch die Kombination dieser Speichertypen kann der Agent maßgeschneiderte Antworten liefern und Benutzervorlieben über die Zeit hinweg in Erinnerung rufen, was zu einer angemesseneren und relevanten Interaktion führt.

Planung

Die Planung ermöglicht es LLM-Agents, zu denken, Aufgaben in handhabbare Teile zu unterteilen und Pläne anzupassen, wenn sich die Aufgaben entwickeln. Die Planung umfasst zwei Hauptstadien:

• Plan-Formulierung: Die Aufteilung einer Aufgabe in kleinere Unter-Aufgaben.
• Plan-Reflektion: Die Überprüfung und Bewertung der Plan-Effektivität, mit der Einbeziehung von Feedback, um Strategien zu verfeinern.

Methoden wie die Chain of Thought (CoT) und Tree of Thought (ToT) helfen bei diesem Dekompositionsprozess, indem sie es dem Agenten ermöglichen, verschiedene Pfade zu erkunden, um ein Problem zu lösen.

Um tiefer in die Welt der KI-Agents einzutauchen, einschließlich ihrer aktuellen Fähigkeiten und ihres Potenzials, sollten Sie den Artikel “Auto-GPT & GPT-Engineer: Ein umfassender Leitfaden zu den führenden KI-Agents von heute” lesen.

Einrichtung der Umgebung

Um unseren RAG-Agenten aufzubauen, müssen wir unsere Entwicklungsumgebung einrichten. Wir werden Python und mehrere Schlüsselbibliotheken verwenden:

• LangChain: Für die Orchestrierung unserer LLM- und Abruf-Komponenten
• Chroma: Als unsere Vektor-Speicher für Dokument-Embeddings
• OpenAI’s GPT-Modelle: Als unsere Basis-LLM (Sie können dies durch ein Open-Source-Modell ersetzen, wenn bevorzugt)
• FastAPI: Für die Erstellung einer einfachen API, um mit unserem Agenten zu interagieren

Lassen Sie uns beginnen, indem wir unsere Umgebung einrichten:

<p># Erstellen Sie eine neue virtuelle Umgebung
python -m venv rag_agent_env
source rag_agent_env/bin/activate # Auf Windows verwenden Sie `rag_agent_env\Scripts\activate`</p>

<p># Installieren Sie die erforderlichen Pakete
pip install langchain chromadb openai fastapi uvicorn

Jetzt erstellen wir eine neue Python-Datei namens rag_agent.py und importieren die erforderlichen Bibliotheken:

<p>from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import CharacterTextSplitter
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA
from langchain.document_loaders import TextLoader
import os</p>

<p># Setzen Sie Ihren OpenAI-API-Schlüssel
os.environ["OPENAI_API_KEY"] = "Ihr-API-Schlüssel-hier"</p>

Aufbau eines einfachen RAG-Systems

Jetzt, da wir unsere Umgebung eingerichtet haben, können wir ein grundlegendes RAG-System aufbauen. Wir beginnen damit, eine Wissensbasis aus einer Reihe von Dokumenten zu erstellen, und verwenden diese dann, um Abfragen zu beantworten.

Schritt 1: Vorbereitung der Dokumente

Zuerst müssen wir unsere Dokumente laden und vorbereiten. Nehmen wir an, wir haben eine Textdatei namens knowledge_base.txt mit einigen Informationen über KI und maschinelles Lernen.

<p># Laden Sie das Dokument
loader = TextLoader("knowledge_base.txt")
documents = loader.load()</p>

<p># Teilen Sie die Dokumente in Abschnitte auf
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)</p>

<p># Erstellen Sie Embeddings
embeddings = OpenAIEmbeddings()</p>

<p># Erstellen Sie einen Vektor-Speicher
vectorstore = Chroma.from_documents(texts, embeddings)</p>

Schritt 2: Erstellung einer Abruf-basierten QA-Kette

Jetzt, da wir unseren Vektor-Speicher haben, können wir eine Abruf-basierte QA-Kette erstellen:

<p># Erstellen Sie eine Abruf-basierte QA-Kette
qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=vectorstore.as_retriever())</p>

Schritt 3: Abfrage des Systems

Wir können jetzt unser RAG-System abfragen:

<p>query = "Was sind die Hauptanwendungen von maschinellem Lernen?"
result = qa.run(query)
print(result)

Schritt 4: Erstellung eines LLM-Agents

Während unser einfaches RAG-System nützlich ist, ist es ziemlich begrenzt. Lassen Sie uns es durch die Erstellung eines LLM-Agents verbessern, der komplexere Aufgaben ausführen und über die abgerufenen Informationen nachdenken kann.

Ein LLM-Agent ist ein KI-System, das Werkzeuge verwenden und Entscheidungen über die Ausführung von Aktionen treffen kann. Wir werden einen Agenten erstellen, der nicht nur Fragen beantworten, sondern auch Web-Suchen und grundlegende Berechnungen durchführen kann.

Zuerst definieren wir einige Werkzeuge für unseren Agenten:

<p>from langchain.agents import Tool
from langchain.tools import DuckDuckGoSearchRun
from langchain.tools import BaseTool
from langchain.agents import initialize_agent
from langchain.agents import AgentType</p>

<p># Definieren Sie ein Rechenwerkzeug
class CalculatorTool(BaseTool):
name = "Rechner"
description = "Nützlich, wenn Sie mathematische Fragen beantworten müssen"</p>

<p>def _run(self, query: str)
try:
return str(eval(query))
except:
return "Ich konnte das nicht berechnen. Bitte stellen Sie sicher, dass Ihre Eingabe ein gültiger mathematischer Ausdruck ist."</p>

<p># Erstellen Sie Werkzeug-Instanzen
search = DuckDuckGoSearchRun()
calculator = CalculatorTool()</p>

<p># Definieren Sie die Werkzeuge
tools = [Tool(name="Suche", func=search.run, description="Nützlich, wenn Sie Fragen zu aktuellen Ereignissen beantworten müssen"),
Tool(name="RAG-QA", func=qa.run, description="Nützlich, wenn Sie Fragen zu KI und maschinellem Lernen beantworten müssen"),
Tool(name="Rechner", func=calculator._run, description="Nützlich, wenn Sie mathematische Berechnungen durchführen müssen")
]</p>

<p># Initialisieren Sie den Agenten
agent = initialize_agent(tools, OpenAI(temperature=0), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)</p>

Jetzt haben wir einen Agenten, der unser RAG-System verwenden, Web-Suchen durchführen und Berechnungen ausführen kann. Lassen Sie uns ihn testen:

<p>result = agent.run("Was ist der Unterschied zwischen überwachtem und unüberwachtem Lernen? Außerdem, was ist 15% von 80?")
print(result)</p>

Dieser Agent demonstriert einen wichtigen Vorteil von LLM-Agents: Sie können mehrere Werkzeuge und Denkschritte kombinieren, um komplexe Abfragen zu beantworten.

Verbesserung des Agenten mit fortgeschrittenen RAG-Techniken

Während unser aktuelles RAG-System gut funktioniert, gibt es mehrere fortgeschrittene Techniken, die wir verwenden können, um seine Leistung zu verbessern:

a) Semantische Suche mit Dense Passage Retrieval (DPR)

Anstatt einfache Embedding-basierte Abrufe zu verwenden, können wir DPR für genauere semantische Suche implementieren:

<p>from transformers import DPRQuestionEncoder, DPRContextEncoder</p>

<p>question_encoder = DPRQuestionEncoder.from_pretrained("facebook/dpr-question_encoder-single-nq-base")
context_encoder = DPRContextEncoder.from_pretrained("facebook/dpr-ctx_encoder-single-nq-base")</p>

<p># Funktion, um Passagen zu codieren
def encode_passages(passages):
return context_encoder(passages, max_length=512, return_tensors="pt").pooler_output</p>

<p># Funktion, um Abfrage zu codieren
def encode_query(query):
return question_encoder(query, max_length=512, return_tensors="pt").pooler_output</p>

b) Abfrage-Erweiterung

Wir können Abfrage-Erweiterung verwenden, um die Abruf-Leistung zu verbessern:

<p>from transformers import T5ForConditionalGeneration, T5Tokenizer</p>

<p>model = T5ForConditionalGeneration.from_pretrained("t5-small")
tokenizer = T5Tokenizer.from_pretrained("t5-small")</p>

<p>def expand_query(query):
input_text = f"expand query: {query}"
input_ids = tokenizer.encode(input_text, return_tensors="pt")
outputs = model.generate(input_ids, max_length=50, num_return_sequences=3)
expanded_queries = [tokenizer.decode(output, skip_special_tokens=True) for output in outputs]
return expanded_queries</p>

c) Iterative Verfeinerung

Wir können einen iterativen Verfeinerungsprozess implementieren, bei dem der Agent Follow-up-Fragen stellen kann, um seine anfängliche Abrufung zu klären oder zu erweitern:

<p>def iterative_retrieval(initial_query, max_iterations=3):
query = initial_query
for _ in range(max_iterations):
result = qa.run(query)
clarification = agent.run(f"Basierend auf diesem Ergebnis: '{result}', welche Follow-up-Frage sollte ich stellen, um mehr spezifische Informationen zu erhalten?")
if clarification.lower().strip() == "none":
break
query = clarification
return result</p>

# Verwenden Sie dies in Ihrem Agenten-Prozess

Implementierung eines Multi-Agenten-Systems

Um komplexere Aufgaben zu bewältigen, können wir ein Multi-Agenten-System implementieren, bei dem verschiedene Agenten sich auf unterschiedliche Bereiche spezialisieren. Hier ist ein einfaches Beispiel:

<p>class SpecialistAgent:
def __init__(self, name, tools):
self.name = name
self.agent = initialize_agent(tools, OpenAI(temperature=0), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)</p>

<p>def run(self, query):
return self.agent.run(query)</p>

<p># Erstellen Sie Spezialisten-Agents
research_agent = SpecialistAgent("Forschung", [Tool(name="RAG-QA", func=qa.run, description="Für KI- und ML-Fragen")])
math_agent = SpecialistAgent("Mathematik", [Tool(name="Rechner", func=calculator._run, description="Für mathematische Berechnungen")])
general_agent = SpecialistAgent("Allgemein", [Tool(name="Suche", func=search.run, description="Für allgemeine Abfragen")])</p>

<p>class Coordinator:
def __init__(self, agents):
self.agents = agents</p>

<p>def run(self, query):
# Bestimmen Sie, welcher Agent verwendet werden soll
if "berechnen" in query.lower() or any(op in query for op in ['+', '-', '*', '/']):
return self.agents['Mathematik'].run(query)
elif any(term in query.lower() for term in ['KI', 'maschinelles Lernen', 'tiefes Lernen']):
return self.agents['Forschung'].run(query)
else:
return self.agents['Allgemein'].run(query)</p>

<p>coordinator = Coordinator({'Forschung': research_agent, 'Mathematik': math_agent, 'Allgemein': general_agent})</p>

<p># Testen Sie das Multi-Agenten-System
result = coordinator.run("Was ist der Unterschied zwischen CNN und RNN? Außerdem berechnen Sie 25% von 120.")
print(result)</p>

Dieses Multi-Agenten-System ermöglicht es, sich auf unterschiedliche Bereiche zu spezialisieren und kann eine breitere Palette von Abfragen effektiver bewältigen.

Bewertung und Optimierung von RAG-Agents

Um sicherzustellen, dass unser RAG-Agent gut funktioniert, müssen wir Bewertungsmetriken und Optimierungstechniken implementieren:

a) Relevanz-Bewertung

Wir können Metriken wie BLEU, ROUGE oder BERTScore verwenden, um die Relevanz abgerufener Dokumente zu bewerten:

<p>from bert_score import score</p>

<p>def evaluate_relevance(query, retrieved_doc, generated_answer):
P, R, F1 = score([generated_answer], [retrieved_doc], lang="de")
return F1.mean().item()</p>

b) Antwort-Qualitäts-Bewertung

Wir können menschliche Bewertung oder automatisierte Metriken verwenden, um die Antwort-Qualität zu bewerten:

<p>from nltk.translate.bleu_score import sentence_bleu</p>

<p>def evaluate_answer_quality(reference_answer, generated_answer):
return sentence_bleu([reference_answer.split()], generated_answer.split())</p>

<p># Verwenden Sie dies, um die Antworten Ihres Agenten zu bewerten

Zukünftige Richtungen und Herausforderungen

Wenn wir in die Zukunft von RAG-Agents blicken, ergeben sich mehrere spannende Richtungen und Herausforderungen:

a) Multimodale RAG: Erweiterung von RAG, um Bild-, Audio- und Video-Daten zu integrieren.

b) Föderale RAG: Implementierung von RAG über verteilte, datenschutzfreundliche Wissensbasen.

c) Fortlaufendes Lernen: Entwicklung von Methoden, um RAG-Agents zu ermöglichen, ihre Wissensbasen und Modelle über die Zeit zu aktualisieren.

d) Ethische Überlegungen: Bewältigung von Voreingenommenheit, Fairness und Transparenz in RAG-Systemen.

e) Skalierbarkeit: Optimierung von RAG für groß angelegte, Echtzeit-Anwendungen.

Schlussfolgerung

Der Aufbau von LLM-Agents für RAG von Grund auf ist ein komplexer, aber lohnender Prozess. Wir haben die Grundlagen von RAG, die Implementierung eines einfachen Systems, die Erstellung eines LLM-Agents, die Verbesserung mit fortgeschrittenen Techniken, die Erforschung von Multi-Agenten-Systemen und die Diskussion von Bewertungs- und Optimierungsmethoden abgedeckt.