O que é um RAG?

RAG significa Retrieval-Augmented Generation, uma técnica poderosa projetada para melhorar o desempenho de grandes modelos de linguagem (LLMs), fornecendo-lhes um contexto específico e relevante na forma de documentos. Ao contrário dos LLMs tradicionais que geram respostas puramente baseadas em seu conhecimento pré-treinado, o RAG permite alinhar a saída do modelo mais de perto com os resultados desejados, recuperando e utilizando dados em tempo real ou informações específicas do domínio.

RAG vs ajuste fino

Embora tanto o RAG quanto o ajuste fino visem melhorar o desempenho dos LLMs, o RAG é frequentemente um método mais eficiente e de baixo custo. O ajuste fino envolve o retreinamento de um modelo em um conjunto de dados especializado, o que requer recursos computacionais, tempo e experiência significativos. O RAG, por outro lado, recupera dinamicamente informações relevantes e as incorpora no processo de geração, permitindo uma adaptação mais flexível e econômica a novas tarefas sem amplo treinamento.

Construindo um Agente RAG

Instalando os Requisitos

Instalar Ollama

Ollama fornece a infraestrutura de back-end necessária para executar o LLaMA localmente. Para começar, acesse o site da Ollama e baixe o aplicativo. Siga as instruções para configurá-lo em sua máquina local.

Instale os requisitos do LangChain

LangChain é uma estrutura Python projetada para funcionar com vários LLMs e bancos de dados vetoriais, tornando-o ideal para construir agentes RAG. Instale LangChain e suas dependências executando o seguinte comando:

pip install langchain

Codificando o Agente RAG

Crie uma função API

Primeiro, você precisará de uma função para interagir com sua instância local do LLaMA. Veja como você pode configurá-lo:

from requests import post as rpost

def call_llama(prompt):
    headers = {"Content-Type": "application/json"}
    payload = {
        "model": "llama3.1",
        "prompt": prompt,
        "stream": False,
    }

    response = rpost(
        "http://localhost:11434/api/generate",
        headers=headers,
        json=payload
    )
    return response.json()["response"]

Crie um LangChain LLM

Em seguida, integre esta função em uma classe LLM personalizada dentro do LangChain:

from langchain_core.language_models.llms import LLM

class LLaMa(LLM):
    def _call(self, prompt, **kwargs):
        return call_llama(prompt)

    @property
    def _llm_type(self):
        return "llama-3.1-8b"

Integrando o Agente RAG

Configurando o recuperador

O recuperador é responsável por buscar documentos relevantes com base na consulta do usuário. Veja como configurá-lo usando FAISS para armazenamento de vetores e embeddings pré-treinados do HuggingFace:

from langchain.vectorstores import FAISS
from langchain_huggingface import HuggingFaceEmbeddings

documents = [
    {"content": "What is your return policy? ..."},
    {"content": "How long does shipping take? ..."},
    # Add more documents as needed
]

texts = [doc["content"] for doc in documents]

retriever = FAISS.from_texts(
    texts,
    HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
).as_retriever(k=5)

Crie o modelo de prompt

Defina o modelo de prompt que o agente RAG usará para gerar respostas com base nos documentos recuperados:

from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder

faq_template = """
You are a chat agent for my E-Commerce Company. As a chat agent, it is your duty to help the human with their inquiry and make them a happy customer.

Help them, using the following context:

{context}

"""

faq_prompt = ChatPromptTemplate.from_messages([
    ("system", faq_template),
    MessagesPlaceholder("messages")
])

Criar cadeias de documentos e recuperadores

Combine a recuperação de documentos e a geração de LLaMA em uma cadeia coesa:

from langchain.chains.combine_documents import create_stuff_documents_chain

document_chain = create_stuff_documents_chain(LLaMa(), faq_prompt)

def parse_retriever_input(params):
    return params["messages"][-1].content

retrieval_chain = RunnablePassthrough.assign(
    context=parse_retriever_input | retriever
).assign(answer=document_chain)

Inicie seu servidor Ollama

Antes de executar seu agente RAG, certifique-se de que o servidor Ollama esteja instalado e funcionando. Inicie o servidor com o seguinte comando:

ollama serve

Avise seu agente RAG

Agora, você pode testar seu agente RAG enviando uma consulta:

from langchain.schema import HumanMessage

response = retrieval_chain.invoke({
    "messages": [
        HumanMessage("I received a damaged item. I want my money back.")
    ]
})

print(response)

Resposta:
"Lamento saber que você recebeu um item danificado. De acordo com nossa política, se você receber um item danificado, entre em contato imediatamente com nossa equipe de atendimento ao cliente com fotos do dano. Providenciaremos uma substituição ou reembolso para você. Gostaria que eu o ajudasse a obter um reembolso? Precisarei de algumas informações suas, como o número do seu pedido e detalhes sobre o item danificado. Você pode fornecer isso para que eu possa ajudar a processar sua solicitação?

---

Seguindo essas etapas, você pode criar um agente RAG local totalmente funcional, capaz de melhorar o desempenho do seu LLM com contexto em tempo real. Esta configuração pode ser adaptada a vários domínios e tarefas, tornando-a uma solução versátil para qualquer aplicação onde a geração consciente do contexto é crucial.