¿Qué es un RAG?

RAG significa Retrieval-Augmented Generation, una poderosa técnica diseñada para mejorar el rendimiento de grandes modelos de lenguaje (LLM) proporcionándoles un contexto específico y relevante en forma de documentos. A diferencia de los LLM tradicionales que generan respuestas basadas únicamente en su conocimiento previamente capacitado, RAG le permite alinear el resultado del modelo más estrechamente con los resultados deseados al recuperar y utilizar datos en tiempo real o información específica del dominio.

RAG vs Ajuste Fino

Si bien tanto RAG como el ajuste tienen como objetivo mejorar el rendimiento de los LLM, RAG suele ser un método más eficiente y amigable con los recursos. El ajuste implica volver a entrenar un modelo en un conjunto de datos especializado, lo que requiere importantes recursos computacionales, tiempo y experiencia. RAG, por otro lado, recupera dinámicamente información relevante y la incorpora al proceso de generación, lo que permite una adaptación más flexible y rentable a nuevas tareas sin un reentrenamiento extenso.

Construyendo un agente RAG

Instalación de los requisitos

Instalar Ollama

Ollama proporciona la infraestructura de backend necesaria para ejecutar LLaMA localmente. Para comenzar, dirígete al sitio web de Ollama y descarga la aplicación. Siga las instrucciones para configurarlo en su máquina local.

Instalar los requisitos de LangChain

LangChain es un marco de Python diseñado para funcionar con varios LLM y bases de datos vectoriales, lo que lo hace ideal para crear agentes RAG. Instale LangChain y sus dependencias ejecutando el siguiente comando:

pip install langchain

Codificando el agente RAG

Crear una función API

Primero, necesitarás una función para interactuar con tu instancia LLaMA local. Así es como puedes configurarlo:

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"]

Crear un LLM en LangChain

A continuación, integre esta función en una clase LLM personalizada dentro de 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"

Integración del agente RAG

Configurar el recuperador

El recuperador es responsable de recuperar los documentos relevantes según la consulta del usuario. Aquí se explica cómo configurarlo usando FAISS para el almacenamiento de vectores y las incrustaciones previamente entrenadas de 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)

Crear la plantilla de mensaje

Defina la plantilla de aviso que utilizará el agente RAG para generar respuestas basadas en los 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")
])

Crear cadenas de documentos y recuperadores

Combina la recuperación de documentos y la generación de LLaMA en una cadena cohesiva:

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 su servidor Ollama

Antes de ejecutar su agente RAG, asegúrese de que el servidor Ollama esté en funcionamiento. Inicie el servidor con el siguiente comando:

ollama serve

Informe a su agente RAG

Ahora puedes probar tu agente RAG enviando una consulta:

from langchain.schema import HumanMessage

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

print(response)

Respuesta:
"Lamento mucho saber que recibió un artículo dañado. De acuerdo con nuestra política, si recibe un artículo dañado, comuníquese con nuestro equipo de servicio al cliente de inmediato con fotografías del daño. Organizaremos un reemplazo o un reembolso para usted. ¿Le gustaría que lo ayude a obtener un reembolso? Necesitaré cierta información suya, como su número de pedido y detalles sobre el artículo dañado. ¿Puede proporcionarlos para que pueda ayudarlo a procesar su solicitud?"

Al seguir estos pasos, puede crear un agente RAG local completamente funcional capaz de mejorar el rendimiento de su LLM con contexto en tiempo real. Esta configuración se puede adaptar a diversos dominios y tareas, lo que la convierte en una solución versátil para cualquier aplicación donde la generación consciente del contexto sea crucial.