Construindo agentes LLM para RAG do zero e além: um guia abrangente

LLMs como GPT-3, GPT-4 e suas contrapartes de código aberto muitas vezes têm dificuldades com a recuperação de informações atualizadas e podem, às vezes, gerar alucinações ou informações incorretas.

Retrieval-Augmented Era (RAG) é uma técnica que combina o poder dos LLMs com a recuperação de conhecimento externo. O RAG nos permite fundamentar respostas de LLM em informações factuais e atualizadas, melhorando significativamente a precisão e a confiabilidade do conteúdo gerado por IA.

Nesta postagem do weblog, exploraremos como construir agentes LLM para RAG do zero, mergulhando fundo na arquitetura, detalhes de implementação e técnicas avançadas. Abordaremos tudo, desde os conceitos básicos do RAG até a criação de agentes sofisticados capazes de raciocínio complexo e execução de tarefas.

Antes de começarmos a construir nosso agente LLM, vamos entender o que é RAG e por que ele é importante.

RAG, ou Retrieval-Augmented Era, é uma abordagem híbrida que combina recuperação de informação com geração de texto. Em um sistema RAG:

• Uma consulta é usada para recuperar documentos relevantes de uma base de conhecimento.
• Esses documentos são então inseridos em um modelo de linguagem junto com a consulta authentic.
• O modelo gera uma resposta com base na consulta e nas informações recuperadas.

Esta abordagem tem várias vantagens:

• Precisão melhorada:Ao basear as respostas em informações recuperadas, o RAG reduz alucinações e melhora a precisão dos fatos.
• Informação atualizada: A base de conhecimento pode ser atualizada regularmente, permitindo que o sistema acesse informações atuais.
• Transparência: O sistema pode fornecer fontes para suas informações, aumentando a confiança e permitindo a verificação de fatos.

Compreendendo os agentes LLM

Quando você enfrenta um problema sem uma resposta simples, geralmente precisa seguir vários passos, pensar cuidadosamente e lembrar o que já tentou. Os agentes LLM são projetados exatamente para esses tipos de situações em aplicações de modelos de linguagem. Eles combinam análise de dados completa, planejamento estratégico, recuperação de dados e a capacidade de aprender com ações passadas para resolver problemas complexos.

O que são agentes LLM?

Os agentes LLM são sistemas avançados de IA projetados para criar textos complexos que exigem raciocínio sequencial. Eles podem pensar à frente, lembrar de conversas passadas e usar diferentes ferramentas para ajustar suas respostas com base na situação e no estilo necessários.

Considere uma questão no campo jurídico, como: “Quais são os potenciais resultados legais de um tipo específico de violação de contrato na Califórnia?” Um LLM básico com um sistema de geração aumentada de recuperação (RAG) pode buscar as informações necessárias de bancos de dados jurídicos.

Para um cenário mais detalhado: “À luz das novas leis de privacidade de dados, quais são os desafios legais comuns que as empresas enfrentam e como os tribunais abordaram essas questões?” Esta questão vai mais fundo do que apenas procurar fatos. É sobre entender novas regras, seu impacto em diferentes empresas e as respostas dos tribunais. Um agente LLM dividiria essa tarefa em subtarefas, como recuperar as leis mais recentes, analisar casos históricos, resumir documentos legais e prever tendências com base em padrões.

Componentes dos agentes LLM

Os agentes LLM geralmente consistem em quatro componentes:

1. Agente/Cérebro: O modelo de linguagem central que processa e entende a linguagem.
2. Planejamento: Capacidade de raciocinar, dividir tarefas e desenvolver planos específicos.
3. Memória: Mantém registros de interações passadas e aprende com elas.
4. Uso de ferramentas: Integra vários recursos para executar tarefas.

Agente/Cérebro

No cerne de um agente LLM está um modelo de linguagem que processa e entende a linguagem com base em grandes quantidades de dados nos quais ele foi treinado. Você começa dando a ele um immediate específico, orientando o agente sobre como responder, quais ferramentas usar e os objetivos a serem alcançados. Você pode personalizar o agente com uma persona adequada para tarefas ou interações específicas, melhorando seu desempenho.

Memória

O componente de memória ajuda os agentes LLM a lidar com tarefas complexas mantendo um registro de ações passadas. Existem dois tipos principais de memória:

• Memória de curto prazo: Funciona como um bloco de notas, monitorando as discussões em andamento.
• Memória de longo prazo: Funciona como um diário, armazenando informações de interações passadas para aprender padrões e tomar melhores decisões.

Ao combinar esses tipos de memória, o agente pode oferecer respostas mais personalizadas e lembrar das preferências do usuário ao longo do tempo, criando uma interação mais conectada e relevante.

Planejamento

O planejamento permite que agentes LLM raciocinem, decomponham tarefas em partes gerenciáveis ​​e adaptem planos conforme as tarefas evoluem. O planejamento envolve dois estágios principais:

• Formulação do Plano: Dividir uma tarefa em subtarefas menores.
• Reflexão do Plano: Revisar e avaliar a eficácia do plano, incorporando suggestions para refinar estratégias.

Métodos como a Cadeia de Pensamento (CoT) e a Árvore de Pensamento (ToT) auxiliam nesse processo de decomposição, permitindo que os agentes explorem diferentes caminhos para resolver um problema.

Para se aprofundar no mundo dos agentes de IA, incluindo suas capacidades e potencial atuais, considere ler “Auto-GPT & GPT-Engineer: Um guia aprofundado para os principais agentes de IA de hoje”

Configurando o ambiente

Para construir nosso agente RAG, precisaremos configurar nosso ambiente de desenvolvimento. Usaremos Python e várias bibliotecas-chave:

• Cadeia Lang: Para orquestrar nossos componentes de LLM e recuperação
• Croma: Como nossa loja de vetores para incorporação de documentos
• Modelos GPT da OpenAI: Como nosso LLM base (você pode substituí-lo por um modelo de código aberto, se preferir)
• API rápida: Para criar uma API simples para interagir com nosso agente

Vamos começar configurando nosso ambiente:

# Create a brand new digital surroundings
python -m venv rag_agent_env
supply rag_agent_env/bin/activate # On Home windows, use `rag_agent_envScriptsactivate`
# Set up required packages
pip set up langchain chromadb openai fastapi uvicorn
Now, let's create a brand new Python file known as rag_agent.py and import the mandatory libraries:
(code language="PYTHON")
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"

Construindo um sistema RAG simples

Agora que configuramos nosso ambiente, vamos construir um sistema RAG básico. Começaremos criando uma base de conhecimento a partir de um conjunto de documentos e, em seguida, usaremos isso para responder a consultas.

Etapa 1: Put together os documentos

Primeiro, precisamos carregar e preparar nossos documentos. Para este exemplo, vamos supor que temos um arquivo de texto chamado knowledge_base.txt com algumas informações sobre IA e machine studying.

# Load the doc
loader = TextLoader("knowledge_base.txt")
paperwork = loader.load()
# Break up the paperwork into chunks
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(paperwork)
# Create embeddings
embeddings = OpenAIEmbeddings()
# Create a vector retailer
vectorstore = Chroma.from_documents(texts, embeddings)

Etapa 2: Crie uma cadeia de controle de qualidade baseada em recuperação

Agora que temos nosso armazenamento de vetores, podemos criar uma cadeia de controle de qualidade baseada em recuperação:

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

Etapa 3: Consultar o sistema

Agora podemos consultar nosso sistema RAG:

question = "What are the primary functions of machine studying?"
outcome = qa.run(question)
print(outcome)
This primary RAG system demonstrates the core idea: we retrieve related data from our information base and use it to tell the LLM's response.
Creating an LLM Agent
Whereas our easy RAG system is helpful, it is fairly restricted. Let's improve it by creating an LLM agent that may carry out extra complicated duties and purpose in regards to the data it retrieves.
An LLM agent is an AI system that may use instruments and make selections about which actions to take. We'll create an agent that may not solely reply questions but additionally carry out internet searches and primary calculations.
First, let's outline some instruments for our agent:
(code language="PYTHON")
from langchain.brokers import Instrument
from langchain.instruments import DuckDuckGoSearchRun
from langchain.instruments import BaseTool
from langchain.brokers import initialize_agent
from langchain.brokers import AgentType
# Outline a calculator device
class CalculatorTool(BaseTool):
title = "Calculator"
description = "Helpful for when it's essential reply questions on math"
def _run(self, question: str) -> str:
attempt:
return str(eval(question))
besides:
return "I could not calculate that. Please be sure that your enter is a legitimate mathematical expression."
# Create device situations
search = DuckDuckGoSearchRun()
calculator = CalculatorTool()
# Outline the instruments
instruments = (
Instrument(
title="Search",
func=search.run,
description="Helpful for when it's essential reply questions on present occasions"
),
Instrument(
title="RAG-QA",
func=qa.run,
description="Helpful for when it's essential reply questions on AI and machine studying"
),
Instrument(
title="Calculator",
func=calculator._run,
description="Helpful for when it's essential carry out mathematical calculations"
)
)
# Initialize the agent
agent = initialize_agent(
instruments,
OpenAI(temperature=0),
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True
)

Agora temos um agente que pode usar nosso sistema RAG, executar pesquisas na internet e fazer cálculos. Vamos testá-lo:

outcome = agent.run(“Qual é a diferença entre aprendizado supervisionado e não supervisionado? Além disso, o que é 15% de 80?”)
imprimir(resultado)

(/código)
Este agente demonstra uma vantagem elementary dos agentes LLM: eles podem combinar diversas ferramentas e etapas de raciocínio para responder a consultas complexas.

Aprimorando o agente com técnicas avançadas de RAG
Embora nosso sistema RAG atual funcione bem, existem diversas técnicas avançadas que podemos usar para melhorar seu desempenho:

a) Busca Semântica com Recuperação de Passagem Densa (DPR)

Em vez de usar recuperação simples baseada em incorporação, podemos implementar DPR para uma pesquisa semântica mais precisa:

from transformers import DPRQuestionEncoder, DPRContextEncoder
question_encoder = DPRQuestionEncoder.from_pretrained("fb/dpr-question_encoder-single-nq-base")
context_encoder = DPRContextEncoder.from_pretrained("fb/dpr-ctx_encoder-single-nq-base")
# Operate to encode passages
def encode_passages(passages):
return context_encoder(passages, max_length=512, return_tensors="pt").pooler_output
# Operate to encode question
def encode_query(question):
return question_encoder(question, max_length=512, return_tensors="pt").pooler_output

b) Expansão de consulta

Podemos usar a expansão de consulta para melhorar o desempenho da recuperação:

de transformadores importar T5ForConditionalGeneration, T5Tokenizer

modelo = T5ForConditionalGeneration.from_pretrained(“t5-small”)
tokenizador = T5Tokenizer.from_pretrained(“t5-pequeno”)

def expand_query(consulta):
input_text = f”expandir consulta: {consulta}”
input_ids = tokenizer.encode(input_text, return_tensors=”pt”)
saídas = modelo.generate(id_de_entrada, comprimento_máximo=50, num_sequências_de_retorno=3)
expanded_queries = (tokenizer.decode(output, skip_special_tokens=True) para saída em outputs)
retornar consultas_expandidas

# Use isso no seu processo de recuperação
c) Refinamento Iterativo

Podemos implementar um processo de refinamento iterativo onde o agente pode fazer perguntas de acompanhamento para esclarecer ou expandir sua recuperação inicial:

def iterative_retrieval(consulta_inicial, max_iterations=3):
consulta = consulta_inicial
para _ em intervalo(máx_iterações):
resultado = qa.run(consulta)
esclarecimento = agent.run(f”Com base neste resultado: '{outcome}', que pergunta complementar devo fazer para obter informações mais específicas?”)
se esclarecimento.decrease().strip() == “nenhum”:
quebrar
consulta = esclarecimento
retornar resultado

# Use isso no processo do seu agente
Implementando um Sistema Multiagente
Para lidar com tarefas mais complexas, podemos implementar um sistema multiagente onde diferentes agentes se especializam em diferentes áreas. Aqui está um exemplo simples:

classe Agente Especialista:
def __init__(self, nome, ferramentas):
self.title = nome
self.agent = initialize_agent(ferramentas, OpenAI(temperatura=0), agente=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

def run(self, consulta):
retornar self.agent.run(consulta)

# Crie agentes especialistas
research_agent = SpecialistAgent(“Pesquisa”, (Ferramenta(nome=”RAG-QA”, func=qa.run, descrição=”Para perguntas de IA e ML”)))
math_agent = SpecialistAgent(“Math”, (Ferramenta(nome=”Calculadora”, func=calculator._run, descrição=”Para cálculos”)))
general_agent = SpecialistAgent(“Geral”, (Ferramenta(nome=”Pesquisar”, func=search.run, descrição=”Para consultas gerais”)))

Coordenador de turma:
def __init__(self, agentes):
self.brokers = agentes

def run(self, consulta):
# Decide qual agente usar
se “calcular” em question.decrease() ou any(op em question para op em ('+', '-', '*', '/')):
retornar self.brokers('Math').run(consulta)
elif any(termo em consulta.decrease() para termo em ('ai', 'aprendizado de máquina', 'aprendizado profundo')):
retornar self.brokers('Pesquisa').run(consulta)
outro:
retornar self.brokers('Geral').run(consulta)

coordenador = Coordenador({
'Pesquisa': research_agent,
'Matemática': math_agent,
'Geral': general_agent
})

# Teste o sistema multiagente
outcome = coordinate.run(“Qual é a diferença entre CNN e RNN? Além disso, calcule 25% de 120.”)
imprimir(resultado)

(/código)

Este sistema multiagente permite especialização e pode lidar com uma gama maior de consultas de forma mais eficaz.

Avaliação e otimização de agentes RAG

Para garantir que nosso agente RAG esteja tendo um bom desempenho, precisamos implementar métricas de avaliação e técnicas de otimização:

a) Avaliação de Relevância

Podemos usar métricas como BLEU, ROUGE ou BERTScore para avaliar a relevância dos documentos recuperados:

from bert_score import rating
def evaluate_relevance(question, retrieved_doc, generated_answer):
P, R, F1 = rating((generated_answer), (retrieved_doc), lang="en")
return F1.imply().merchandise()

b) Avaliação da Qualidade da Resposta

Podemos usar avaliação humana ou métricas automatizadas para avaliar a qualidade da resposta:

from nltk.translate.bleu_score import sentence_bleu
def evaluate_answer_quality(reference_answer, generated_answer):
return sentence_bleu((reference_answer.break up()), generated_answer.break up())
# Use this to guage your agent's responses
c) Latency Optimization
To optimize latency, we will implement caching and parallel processing:
import functools
from concurrent.futures import ThreadPoolExecutor
@functools.lru_cache(maxsize=1000)
def cached_retrieval(question):
return vectorstore.similarity_search(question)
def parallel_retrieval(queries):
with ThreadPoolExecutor() as executor:
outcomes = listing(executor.map(cached_retrieval, queries))
return outcomes
# Use these in your retrieval course of

Direções e desafios futuros

Ao olharmos para o futuro dos agentes RAG, surgem diversas direções e desafios interessantes:

a) RAG multimodal: Estendendo o RAG para incorporar dados de imagem, áudio e vídeo.

b) RAG federado: Implementando RAG em bases de conhecimento distribuídas e que preservam a privacidade.

c) Aprendizagem Contínua: Desenvolver métodos para que agentes RAG atualizem suas bases de conhecimento e modelos ao longo do tempo.

e) Considerações éticas: Abordando preconceito, justiça e transparência em sistemas RAG.

e) Escalabilidade: Otimizando o RAG para aplicações em larga escala e em tempo actual.

Conclusão

Construir agentes LLM para RAG do zero é um processo complexo, mas gratificante. Cobrimos os conceitos básicos de RAG, implementamos um sistema simples, criamos um agente LLM, o aprimoramos com técnicas avançadas, exploramos sistemas multiagentes e discutimos estratégias de avaliação e otimização.