Bygga LLM-agenter för RAG från grunden och bortom: En omfattande guide

LLM som GPT-3, GPT-4 och deras motsvarighet med öppen källkod kämpar ofta med uppdaterad informationssökning och kan ibland generera hallucinationer eller felaktig information.

Retrieval-Augmented Generation (RAG) är en teknik som kombinerar kraften hos LLM med extern kunskapsinhämtning. RAG tillåter oss att grunda LLM-svar i saklig, uppdaterad information, vilket avsevärt förbättrar noggrannheten och tillförlitligheten hos AI-genererat innehåll.

I det här blogginlägget utforskar vi hur man bygger LLM-agenter för RAG från grunden, och fördjupar sig i arkitekturen, implementeringsdetaljerna och avancerade tekniker. Vi täcker allt från grunderna i RAG till att skapa sofistikerade agenter som kan utföra komplexa resonemang och uppgifter.

Innan vi börjar bygga vår LLM-agent, låt oss förstå vad RAG är och varför det är viktigt.

RAG, eller Retrieval-Augmented Generation, är en hybrid metod som kombinerar informationshämtning med textgenerering. I ett RAG-system:

• En fråga används för att hämta relevanta dokument från en kunskapsbas.
• Dessa dokument matas sedan in i en språkmodell tillsammans med den ursprungliga frågan.
• Modellen genererar ett svar baserat på både frågan och den hämtade informationen.

RAG

Detta tillvägagångssätt har flera fördelar:

• Förbättrad noggrannhet: Genom att jorda svar i hämtad information minskar RAG hallucinationer och förbättrar faktaprecisionen.
• Uppdaterad information: Kunskapsbasen kan uppdateras regelbundet, vilket gör att systemet kan komma åt aktuell information.
• Öppenhet: Systemet kan tillhandahålla källor för sin information, öka förtroendet och möjliggöra faktakontroll.

Förstå LLM-agenter

LLM Powered Agents

När du står inför ett problem utan ett enkelt svar behöver du ofta följa flera steg, tänka noga och komma ihåg vad du redan har provat. LLM-agenter är designade för exakt den här typen av situationer i språkmodellapplikationer. De kombinerar grundlig dataanalys, strategisk planering, datahämtning och förmågan att lära av tidigare åtgärder för att lösa komplexa problem.

Vad är LLM-agenter?

LLM-agenter är avancerade AI-system designade för att skapa komplex text som kräver sekventiellt resonemang. De kan tänka framåt, komma ihåg tidigare konversationer och använda olika verktyg för att justera sina svar baserat på situationen och stilen som behövs.

Överväg en fråga inom det juridiska området som: "Vilka är de potentiella rättsliga resultaten av en specifik typ av kontraktsbrott i Kalifornien?" En grundläggande LLM med ett RAG-system (Retrieval Augmented Generation) kan hämta nödvändig information från juridiska databaser.

För ett mer detaljerat scenario: ”Vilka är de vanligaste juridiska utmaningarna som företag står inför med tanke på nya dataskyddslagar, och hur har domstolarna hanterat dessa frågor?” Denna fråga går djupare än att bara slå upp fakta. Det handlar om att förstå nya regler, deras inverkan på olika företag och domstolarnas svar. En jurist skulle dela upp denna uppgift i deluppgifter, såsom att hämta de senaste lagarna, analysera historiska fall, sammanfatta juridiska dokument och prognostisera trender baserat på mönster.

Komponenter i LLM-agenter

LLM-agenter består i allmänhet av fyra komponenter:

1. Agent/hjärna: Kärnspråksmodellen som bearbetar och förstår språk.
2. Planering: Förmågan att resonera, bryta ner uppgifter och utveckla specifika planer.
3. Minne: Upprätthåller register över tidigare interaktioner och lär sig av dem.
4. Användning av verktyg: Integrerar olika resurser för att utföra uppgifter.

Agent/hjärna

Kärnan i en LLM-agent är en språkmodell som bearbetar och förstår språk baserat på stora mängder data som den har tränats på. Du börjar med att ge den en specifik uppmaning, vägleda agenten om hur den ska svara, vilka verktyg som ska användas och målen att sikta mot. Du kan anpassa agenten med en persona som lämpar sig för särskilda uppgifter eller interaktioner, vilket förbättrar dess prestanda.

Minne

Minneskomponenten hjälper LLM-agenter att hantera komplexa uppgifter genom att föra register över tidigare åtgärder. Det finns två huvudtyper av minne:

• Korttidsminne: Fungerar som ett anteckningsblock och håller reda på pågående diskussioner.
• Långtids minne: Fungerar som en dagbok, lagrar information från tidigare interaktioner för att lära sig mönster och fatta bättre beslut.

Genom att blanda dessa typer av minne kan agenten erbjuda mer skräddarsydda svar och komma ihåg användarpreferenser över tid, vilket skapar en mer sammankopplad och relevant interaktion.

Planering

Planering gör det möjligt för LLM-agenter att resonera, bryta upp uppgifter i hanterbara delar och anpassa planer allteftersom uppgifterna utvecklas. Planeringen omfattar två huvudsteg:

• Planformulering: Dela upp en uppgift i mindre deluppgifter.
• Planreflektion: Granska och utvärdera planens effektivitet, inkludera feedback för att förfina strategier.

Metoder som Chain of Thought (CoT) och Tree of Thought (ToT) hjälper till i denna nedbrytningsprocess, vilket gör att agenter kan utforska olika vägar för att lösa ett problem.

För att gräva djupare in i AI-agenternas värld, inklusive deras nuvarande kapacitet och potential, överväg att läsa "Auto-GPT & GPT-Engineer: En djupgående guide till dagens ledande AI-agenter"

Ställa in miljön

För att bygga vår RAG-agent behöver vi konfigurera vår utvecklingsmiljö. Vi kommer att använda Python och flera viktiga bibliotek:

• Langkedja: För orkestrering av våra LLM- och hämtningskomponenter
• Chroma: Som vår vektorbutik för dokumentinbäddningar
• OpenAI:s GPT-modeller: Som vår bas LLM (du kan ersätta detta med en öppen källkodsmodell om så önskas)
• FastAPI: För att skapa ett enkelt API för att interagera med vår agent

Låt oss börja med att ställa in vår miljö:

# 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

Nu ska vi skapa en ny Python-fil som heter rag_agent.py och importera de nödvändiga biblioteken:

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"

Att bygga ett enkelt RAG-system

Nu när vi har konfigurerat vår miljö, låt oss bygga ett grundläggande RAG-system. Vi börjar med att skapa en kunskapsbas från en uppsättning dokument och använder sedan detta för att besvara frågor.

Steg 1: Förbered dokumenten

Först måste vi ladda och förbereda våra dokument. I det här exemplet antar vi att vi har en textfil som heter knowledge_base.txt med information om AI och maskininlärning.

# 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)

Steg 2: Skapa en hämtningsbaserad QA-kedja

Nu när vi har vår vektorbutik kan vi skapa en hämtningsbaserad QA-kedja:

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

Steg 3: Fråga systemet

Vi kan nu fråga vårt RAG-system:

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

Steg 4: Skapa en LLM-agent

Även om vårt enkla RAG-system är användbart, är det ganska begränsat. Låt oss förbättra det genom att skapa en LLM-agent som kan utföra mer komplexa uppgifter och resonera kring informationen den hämtar.

En LLM-agent är ett AI-system som kan använda verktyg och fatta beslut om vilka åtgärder som ska vidtas. Vi skapar en agent som inte bara kan svara på frågor utan även utföra webbsökningar och grundläggande beräkningar.

Låt oss först definiera några verktyg för vår agent:

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
)

Nu har vi en agent som kan använda vårt RAG-system, utföra webbsökningar och göra beräkningar. Låt oss testa det:

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

Denna agent visar en viktig fördel med LLM-agenter: de kan kombinera flera verktyg och resonemangssteg för att svara på komplexa frågor.

Förbättra agenten med avancerade RAG-tekniker

Även om vårt nuvarande RAG-system fungerar bra, finns det flera avancerade tekniker vi kan använda för att förbättra dess prestanda:

a) Semantisk sökning med tätpassagehämtning (DPR)

Istället för att använda enkel inbäddningsbaserad hämtning kan vi implementera DPR för mer exakt semantisk sökning:

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) Frågeexpansion

Vi kan använda frågeexpansion för att förbättra hämtningsprestandan:

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) Iterativ förfining

Vi kan implementera en iterativ förfiningsprocess där agenten kan ställa uppföljningsfrågor för att förtydliga eller utöka dess initiala hämtning:

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

Implementering av ett Multi-Agent-system

För att hantera mer komplexa uppgifter kan vi implementera ett system med flera agenter där olika agenter specialiserar sig på olika områden. Här är ett enkelt exempel:

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)

Detta multiagentsystem möjliggör specialisering och kan hantera ett bredare utbud av frågor mer effektivt.

Utvärdera och optimera RAG-agenter

För att säkerställa att vår RAG-agent presterar bra måste vi implementera utvärderingsmått och optimeringstekniker:

a) Relevansbedömning

Vi kan använda mätvärden som BLEU, ROUGE eller BERTScore för att utvärdera relevansen av hämtade dokument:

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) Utvärdering av svarskvalitet

Vi kan använda mänsklig utvärdering eller automatiserade mätvärden för att bedöma svarens kvalitet:

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

Framtida riktningar och utmaningar

När vi ser på framtiden för RAG-agenter dyker flera spännande riktningar och utmaningar upp:

a) Multimodal RAG: Utökar RAG för att införliva bild-, ljud- och videodata.

b) Federerad RAG: Implementering av RAG över distribuerade, integritetsbevarande kunskapsbaser.

c) Kontinuerligt lärande: Utveckla metoder för RAG-agenter för att uppdatera sina kunskapsbaser och modeller över tid.

d) Etiska betänkligheter: Ta itu med partiskhet, rättvisa och transparens i RAG-system.

e) Skalbarhet: Optimering av RAG för storskaliga realtidsapplikationer.

Slutsats

Att bygga LLM-agenter för RAG från grunden är en komplex men givande process. Vi har gått igenom grunderna i RAG, implementerat ett enkelt system, skapat en LLM-agent, förbättrat den med avancerade tekniker, utforskat system med flera agenter och diskuterat utvärderings- och optimeringsstrategier.