Erstellen von LLM-Agenten 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 Probleme mit dem Abrufen aktueller Informationen und können manchmal Halluzinationen oder falsche Informationen erzeugen.

Retrieval-Augmented Generation (RAG) ist eine Technik, die die Leistungsfähigkeit von LLMs mit externem Wissensabruf kombiniert. RAG ermöglicht es uns, LLM-Antworten auf sachliche, aktuelle Informationen zu stützen und so die Genauigkeit und Zuverlässigkeit von KI-generierten Inhalten deutlich zu verbessern.

In diesem Blogbeitrag erfahren Sie, wie Sie LLM-Agenten für RAG von Grund auf neu erstellen. Dabei gehen wir detailliert auf die Architektur, Implementierungsdetails und fortgeschrittene Techniken ein. Wir behandeln alles von den Grundlagen von RAG bis hin zur Erstellung anspruchsvoller Agenten, die komplexe Schlussfolgerungen ziehen und Aufgaben ausführen können.

Bevor wir uns in die Erstellung unseres LLM-Agenten stürzen, wollen wir verstehen, was RAG ist und warum es wichtig ist.

RAG (Retrieval-Augmented Generation) ist ein hybrider Ansatz, der Informationsabruf mit Textgenerierung kombiniert. In einem RAG-System:

• Mithilfe einer Abfrage werden relevante Dokumente aus einer Wissensdatenbank abgerufen.
• Diese Dokumente werden dann zusammen mit der ursprünglichen Abfrage in ein Sprachmodell eingespeist.
• Das Modell generiert eine Antwort basierend auf der Abfrage und den abgerufenen Informationen.

RAG

Dieser Ansatz hat mehrere Vorteile:

• Verbesserte Genauigkeit: Indem RAG seine Antworten auf abgerufene Informationen stützt, reduziert es Halluzinationen und verbessert die sachliche Genauigkeit.
• Aktuelle Information: Die Wissensdatenbank kann regelmäßig aktualisiert werden, so dass das System auf aktuelle Informationen zugreifen kann.
• Transparenz: Das System kann Quellen für seine Informationen angeben, was das Vertrauen stärkt und eine Überprüfung der Fakten ermöglicht.

LLM-Agenten verstehen

LLM-gestützte Agenten

Wenn Sie vor einem Problem stehen, für das es keine einfache Antwort gibt, müssen Sie oft mehrere Schritte befolgen, sorgfältig nachdenken und sich daran erinnern, was Sie bereits versucht haben. LLM-Agenten sind genau für solche Situationen in Sprachmodellanwendungen konzipiert. Sie kombinieren gründliche Datenanalyse, strategische Planung, Datenabruf und die Fähigkeit, aus früheren Aktionen zu lernen, um komplexe Probleme zu lösen.

Was sind LLM-Agenten?

LLM-Agenten sind fortschrittliche KI-Systeme, die für die Erstellung komplexer Texte entwickelt wurden, die sequentielles Denken erfordern. Sie können vorausdenken, sich an vergangene Gespräche erinnern und verschiedene Tools verwenden, um ihre Antworten je nach Situation und erforderlichem Stil anzupassen.

Stellen Sie sich eine Frage aus dem juristischen Bereich wie: „Welche rechtlichen Folgen kann eine bestimmte Art von Vertragsbruch in Kalifornien haben?“ Ein grundlegender LLM mit einem Retrieval Augmented Generation (RAG)-System kann die erforderlichen Informationen aus juristischen Datenbanken abrufen.

Ein detaillierteres Szenario: „Welche rechtlichen Herausforderungen stellen sich Unternehmen angesichts neuer Datenschutzgesetze und wie haben Gerichte diese Probleme gelöst?“ Diese Frage geht tiefer als nur Fakten nachzuschlagen. Es geht darum, neue Regeln, ihre Auswirkungen auf verschiedene Unternehmen und die Reaktionen der Gerichte zu verstehen. Ein LLM-Experte würde diese Aufgabe in Unteraufgaben unterteilen, wie z. B. das Abrufen der neuesten Gesetze, die Analyse historischer Fälle, die Zusammenfassung juristischer Dokumente und die Vorhersage von Trends anhand von Mustern.

Komponenten von LLM-Agenten

LLM-Agenten bestehen im Allgemeinen aus vier Komponenten:

1. Agent/Gehirn: Das zentrale Sprachmodell, das Sprache verarbeitet und versteht.
2. Planung: Die Fähigkeit, zu schlussfolgern, Aufgaben aufzuteilen und konkrete Pläne zu entwickeln.
3. Memory: Führt Aufzeichnungen vergangener Interaktionen und lernt daraus.
4. Werkzeugverwendung: Integriert verschiedene Ressourcen zur Ausführung von Aufgaben.

Agent/Gehirn

Der Kern eines LLM-Agenten ist ein Sprachmodell, das Sprache auf der Grundlage riesiger Datenmengen verarbeitet und versteht, mit denen es trainiert wurde. Sie beginnen damit, ihm eine bestimmte Eingabeaufforderung zu geben und dem Agenten Anweisungen zu geben, wie er reagieren, welche Tools er verwenden und welche Ziele er anstreben soll. Sie können dem Agenten eine Persona zuweisen, die für bestimmte Aufgaben oder Interaktionen geeignet ist, und so seine Leistung verbessern.

Memory

Die Speicherkomponente unterstützt LLM-Agenten bei der Bewältigung komplexer Aufgaben, indem sie eine Aufzeichnung vergangener Aktionen verwaltet. Es gibt zwei Haupttypen von Speicher:

• Kurzzeitgedächtnis: Funktioniert wie ein Notizblock und hält den Überblick über laufende Diskussionen.
• Langzeitgedächtnis: Funktioniert wie ein Tagebuch und speichert Informationen aus vergangenen Interaktionen, um Muster zu erkennen und bessere Entscheidungen zu treffen.

Durch die Kombination dieser Gedächtnistypen kann der Agent maßgeschneiderte Antworten geben und sich die Benutzereinstellungen im Laufe der Zeit merken, wodurch eine vernetztere und relevantere Interaktion entsteht.

Planung

Durch die Planung können LLM-Agenten überlegen, Aufgaben in überschaubare Teile zerlegen und Pläne an die Entwicklung der Aufgaben anpassen. Die Planung umfasst zwei Hauptphasen:

• Planformulierung: Aufteilen einer Aufgabe in kleinere Unteraufgaben.
• Planreflexion: Überprüfen und Bewerten der Wirksamkeit des Plans, Einbeziehen von Feedback zur Verfeinerung der Strategien.

Methoden wie die Chain of Thought (CoT) und der Tree of Thought (ToT) unterstützen diesen Zerlegungsprozess und ermöglichen es Agenten, verschiedene Wege zur Lösung eines Problems zu erkunden.

Um tiefer in die Welt der KI-Agenten einzutauchen, einschließlich ihrer aktuellen Fähigkeiten und ihres Potenzials, lesen Sie bitte „Auto-GPT & GPT-Engineer: Ein ausführlicher Leitfaden zu den führenden KI-Agenten von heute“

Einrichten der Umgebung

Um unseren RAG-Agenten zu erstellen, müssen wir unsere Entwicklungsumgebung einrichten. Wir verwenden Python und mehrere wichtige Bibliotheken:

• LangChain: Zur Orchestrierung unserer LLM- und Abrufkomponenten
• Chroma: Als unser Vektorspeicher für Dokumenteinbettungen
• Die GPT-Modelle von OpenAI: Als unser Basis-LLM (Sie können dies bei Bedarf durch ein Open-Source-Modell ersetzen)
• FastAPI: Zum Erstellen einer einfachen API zur Interaktion mit unserem Agenten

Beginnen wir mit der Einrichtung unserer Umgebung:

# Create a new virtual environment
python -m venv rag_agent_env
source rag_agent_env/bin/activate # On Windows, use `rag_agent_env\Scripts\activate`

# Install required packages
pip install langchain chromadb openai fastapi uvicorn

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

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

# Set your OpenAI API key
os.environ["OPENAI_API_KEY"] = "your-api-key-here"

Aufbau eines einfachen RAG-Systems

Nachdem wir unsere Umgebung eingerichtet haben, erstellen wir ein grundlegendes RAG-System. Wir beginnen mit der Erstellung einer Wissensdatenbank aus Dokumenten und verwenden diese dann zur Beantwortung von Anfragen.

Schritt 1: Bereiten Sie die Dokumente vor

Zuerst müssen wir unsere Dokumente laden und vorbereiten. Nehmen wir für dieses Beispiel an, wir haben eine Textdatei namens knowledge_base.txt mit einigen Informationen zu KI und maschinellem Lernen.

# Load the document
loader = TextLoader("knowledge_base.txt")
documents = loader.load()

# Split the documents into chunks
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

# Create embeddings
embeddings = OpenAIEmbeddings()

# Create a vector store
vectorstore = Chroma.from_documents(texts, embeddings)

Schritt 2: Erstellen Sie eine abrufbasierte QA-Kette

Da wir nun unseren Vektorspeicher haben, können wir eine abrufbasierte QA-Kette erstellen:

# Create a retrieval-based QA chain
qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=vectorstore.as_retriever())

Schritt 3: Abfrage des Systems

Wir können jetzt unser RAG-System abfragen:

query = "What are the main applications of machine learning?"
result = qa.run(query)
print(result)

Schritt 4: Erstellen eines LLM-Agenten

Unser einfaches RAG-System ist zwar nützlich, aber recht begrenzt. Wir erweitern es, indem wir einen LLM-Agenten erstellen, der komplexere Aufgaben ausführen und die abgerufenen Informationen analysieren kann.

Ein LLM-Agent ist ein KI-System, das Tools nutzen und Entscheidungen über die zu ergreifenden Maßnahmen treffen kann. Wir erstellen einen Agenten, der nicht nur Fragen beantworten, sondern auch Websuchen und einfache Berechnungen durchführen kann.

Definieren wir zunächst einige Tools für unseren Agenten:

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

# Define a calculator tool
class CalculatorTool(BaseTool):
name = "Calculator"
description = "Useful for when you need to answer questions about math"

def _run(self, query: str) 
    try:
        return str(eval(query))
    except:
        return "I couldn't calculate that. Please make sure your input is a valid mathematical expression."

# Create tool instances
search = DuckDuckGoSearchRun()
calculator = CalculatorTool()

# Define the tools
tools = [Tool(name="Search",func=search.run,description="Useful for when you need to answer questions about current events"),
Tool(name="RAG-QA",func=qa.run,description="Useful for when you need to answer questions about AI and machine learning"),
Tool(name="Calculator",func=calculator._run,description="Useful for when you need to perform mathematical calculations")
]

# Initialize the agent
agent = initialize_agent(tools, OpenAI(temperature=0), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)

Jetzt haben wir einen Agenten, der unser RAG-System nutzen, Websuchen durchführen und Berechnungen durchführen kann. Testen wir ihn:

result = agent.run("What's the difference between supervised and unsupervised learning? Also, what's 15% of 80?")
print(result)

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

Verbesserung des Agenten mit erweiterten RAG-Techniken

Obwohl unser aktuelles RAG-System gut funktioniert, können wir seine Leistung mit mehreren fortschrittlichen Techniken verbessern:

a) Semantische Suche mit Dense Passage Retrieval (DPR)

Anstatt eine einfache, auf Einbettung basierende Abfrage zu verwenden, können wir DPR für eine genauere semantische Suche implementieren:

from transformers import DPRQuestionEncoder, DPRContextEncoder

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

# Function to encode passages
def encode_passages(passages):
return context_encoder(passages, max_length=512, return_tensors="pt").pooler_output

# Function to encode query
def encode_query(query):
return question_encoder(query, max_length=512, return_tensors="pt").pooler_output

b) Abfrageerweiterung

Wir können die Abfrageerweiterung verwenden, um die Abrufleistung zu verbessern:

from transformers import T5ForConditionalGeneration, T5Tokenizer

model = T5ForConditionalGeneration.from_pretrained("t5-small")
tokenizer = T5Tokenizer.from_pretrained("t5-small")

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

c) Iterative Verfeinerung

Wir können einen iterativen Verfeinerungsprozess implementieren, bei dem der Agent Folgefragen stellen kann, um seine anfänglichen Abfragen zu klären oder zu erweitern:

def iterative_retrieval(initial_query, max_iterations=3):
query = initial_query
for _ in range(max_iterations):
result = qa.run(query)
clarification = agent.run(f"Based on this result: '{result}', what follow-up question should I ask to get more specific information?")
if clarification.lower().strip() == "none":
break
query = clarification
return result

# Use this in your agent's process

Implementierung eines Multi-Agenten-Systems

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

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)

def run(self, query):
return self.agent.run(query)

# Create specialist agents
research_agent = SpecialistAgent("Research", [Tool(name="RAG-QA", func=qa.run, description="For AI and ML questions")])
math_agent = SpecialistAgent("Math", [Tool(name="Calculator", func=calculator._run, description="For calculations")])
general_agent = SpecialistAgent("General", [Tool(name="Search", func=search.run, description="For general queries")])

class Coordinator:
def __init__(self, agents):
self.agents = agents

def run(self, query):
# Determine which agent to use
if "calculate" in query.lower() or any(op in query for op in ['+', '-', '*', '/']):
return self.agents['Math'].run(query)
elif any(term in query.lower() for term in ['ai', 'machine learning', 'deep learning']):
return self.agents['Research'].run(query)
else:
return self.agents['General'].run(query)

coordinator = Coordinator({'Research': research_agent, 'Math': math_agent, 'General': general_agent})

# Test the multi-agent system
result = coordinator.run("What's the difference between CNN and RNN? Also, calculate 25% of 120.")
print(result)

Dieses Multiagentensystem ermöglicht Spezialisierung und kann ein breiteres Spektrum an Abfragen effektiver verarbeiten.

Evaluieren und Optimieren von RAG-Agenten

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

a) Relevanzbewertung

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

from bert_score import score

def evaluate_relevance(query, retrieved_doc, generated_answer):
P, R, F1 = score([generated_answer], [retrieved_doc], lang="en")
return F1.mean().item()

b) Bewertung der Antwortqualität

Zur Beurteilung der Antwortqualität können wir eine menschliche Bewertung oder automatisierte Messgrößen verwenden:

from nltk.translate.bleu_score import sentence_bleu

def evaluate_answer_quality(reference_answer, generated_answer):
return sentence_bleu([reference_answer.split()], generated_answer.split())

# Use this to evaluate your agent's responses

Zukünftige Richtungen und Herausforderungen

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

a) Multimodale RAG: Erweiterung von RAG zur Einbindung von Bild-, Audio- und Videodaten.

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

c) Kontinuierliches Lernen: Entwicklung von Methoden für RAG-Agenten, um ihre Wissensbasen und Modelle im Laufe der Zeit zu aktualisieren.

d) Ethische Überlegungen: Umgang mit Voreingenommenheit, Fairness und Transparenz in RAG-Systemen.

e) Skalierbarkeit: Optimierung von RAG für große Echtzeitanwendungen.

Fazit

Die Entwicklung von LLM-Agenten für RAG von Grund auf ist ein komplexer, aber lohnender Prozess. Wir haben die Grundlagen von RAG behandelt, ein einfaches System implementiert, einen LLM-Agenten erstellt, ihn mit fortgeschrittenen Techniken erweitert, Multi-Agenten-Systeme untersucht und Evaluierungs- und Optimierungsstrategien diskutiert.