Primeros pasos

Guía paso a paso sobre cómo implementar la generación aumentada por recuperación con el framework Neuron.

PRERREQUISITOS

Esta guía supone que ya estás familiarizado con los siguientes conceptos:

• Agente

• Llamada de herramienta y función

La Generación Aumentada por Recuperación (RAG) es el proceso de proporcionar referencias a una base de conocimientos externa a las fuentes de datos de entrenamiento del LLM antes de generar una respuesta.

Los Modelos de Lenguaje Grandes (LLMs) se entrenan con vastos volúmenes de datos para poder generar resultados originales en tareas como responder preguntas, traducir idiomas y completar frases. RAG amplía las ya potentes capacidades de los LLMs a dominios específicos o a la base de conocimientos interna de una organización, todo ello sin necesidad de reentrenar el modelo.

Es un enfoque rentable para mejorar la salida del LLM, de modo que siga siendo relevante, precisa y útil, trabajando también con tus propios datos privados.

Por qué son relevantes los sistemas RAG

Construir un sistema RAG es la forma de usar las potentes capacidades de los LLM con tus propios datos privados. Puedes crear aplicaciones capaces de responder con precisión preguntas sobre la documentación interna de la empresa. O un chatbot para atender a clientes externos sobre las normas internas de una organización.

Si no se trata del uso de datos privados, puedes pensar en RAG como una forma de proporcionar a los modelos generativos las últimas investigaciones, estadísticas o noticias.

Cómo crear un sistema RAG

Sin RAG, el LLM toma la entrada del usuario y crea una respuesta basada en la información con la que fue entrenado (lo que ya sabe).

Con RAG, se introduce un componente de recuperación de información. Utiliza la entrada del usuario para extraer primero información de una nueva fuente de datos. La consulta del usuario y la información relevante recuperada se proporcionan ambas al LLM. El LLM usa el nuevo conocimiento y sus datos de entrenamiento para crear respuestas precisas. Las siguientes secciones ofrecen una visión general del proceso.

Aunque pueda parecer un poco complicado, no te preocupes, esto solo es para que conozcas el proceso. La mayoría de estas cosas se gestionan automáticamente mediante el agente RAG de Neuron.

Hay tres pasos más importantes para crear un sistema RAG.

Procesar datos externos

Los datos externos que quieres usar para ampliar el conocimiento predeterminado del LLM pueden existir en varios formatos, como archivos, registros de bases de datos o texto extenso.

Antes de poder enviar estos datos al LLM, debes convertirlos en un formato específico llamado "Incrustaciones".

Recuperación

Las incrustaciones que has generado al procesar documentos y datos deben almacenarse en bases de datos específicas capaces de manejar este formato particular. Estas bases de datos se llaman "Almacén vectorial".

Los almacenes vectoriales no solo son capaces de almacenar estos datos, sino también de realizar una forma particular de búsqueda: la "búsqueda por similitud" entre los datos existentes en la base de datos y una consulta que proporcionamos.

Ampliar el prompt del LLM

A continuación, el agente RAG amplía tu entrada (o prompt) añadiendo los datos relevantes recuperados en el contexto para que el LLM tenga en cuenta los datos personalizados antes de generar la respuesta.

Solo necesitas ocuparte del primer paso, "Procesar datos externos", y Neuron te proporciona las herramientas para hacerlo sencillo. Los demás pasos son gestionados automáticamente por el agente RAG de Neuron.

Monitorización y depuración

Muchas de las aplicaciones que construyas con Neuron contendrán varios pasos con múltiples invocaciones de llamadas a LLM. A medida que estas aplicaciones se vuelven cada vez más complejas, resulta crucial poder inspeccionar exactamente qué está ocurriendo dentro de tu sistema agéntico. La mejor manera de hacerlo es con Inspector.

Neuron AI | Inspectordocs.inspector.dev

Crear un agente RAG

Para crear un RAG, necesitas conectar algunos componentes adicionales aparte del proveedor de IA, como un almacén vectorial, y un proveedor de incrustaciones.

Primero, vamos a crear la clase RAG:

Unix

vendor/bin/neuron make:rag App\\Neuron\\MyChatBot

Windows

.\vendor\bin\neuron make:rag App\Neuron\MyChatBot

Aquí tienes un ejemplo de implementación de RAG:

namespace App\Neuron;

use NeuronAI\Providers\AIProviderInterface;
use NeuronAI\Providers\Anthropic\Anthropic;
use NeuronAI\RAG\Embeddings\EmbeddingsProviderInterface;
use NeuronAI\RAG\Embeddings\OpenAIEmbeddingsProvider;
use NeuronAI\RAG\RAG;
use NeuronAI\RAG\VectorStore\FileVectorStore;
use NeuronAI\RAG\VectorStore\VectorStoreInterface;

class MyChatBot extends RAG
{
    protected function provider(): AIProviderInterface
    {
        return new Anthropic(
            key: 'ANTHROPIC_API_KEY',
            model: 'ANTHROPIC_MODEL',
        );
    }
    
    protected function embeddings(): EmbeddingsProviderInterface
    {
        return new OpenAIEmbeddingsProvider(
            key: 'OPENAI_API_KEY',
            model: 'OPENAI_MODEL'
        );
    }
    
    protected function vectorStore(): VectorStoreInterface
    {
        return new FileVectorStore(
            directory: __DIR__,
            name: 'demo'
        );
    }
}

Explorar Cargadores de datos para aprender cómo poblar el almacén vectorial con incrustaciones que representen el conocimiento que quieres integrar como conocimiento adicional.

Habla con el chatbot

Imagina que ya has poblado previamente el almacén vectorial con la base de conocimientos que quieres conectar al agente RAG, y ahora quieres hacer preguntas. Consulta Cargadores de datos para aprender sobre la población de datos en RAG.

Para iniciar la ejecución de un RAG, llamas al chat() método:

use App\Neuron\MyChatBot;
use NeuronAI\Chat\Messages\UserMessage;

$message = MyChatBot::make()
    ->chat(
        new UserMessage('Quiero saber más sobre Inspector AI Bug Fix.')
    )
    ->getMessage();
    
echo $message->getContent();

// Claro, Inspector AI Bug Fix es una herramienta de monitorización agentica 
// que proporciona propuestas de corrección de errores en tiempo real a medida que se produce un error 
// en tu aplicación.

Alimenta tu RAG con documentos

Una vez que hayas definido los componentes de tu sistema RAG, es hora de alimentar la base de datos vectorial con fragmentos de texto incrustados.

Neuron te proporciona Cargadores de datos para ayudarte a configurar una canalización de carga de datos con solo unas pocas líneas de código. Puedes ver un ejemplo a continuación. Para saber más sobre el cargador de datos, deberías consultar la documentación dedicada:

use App\Neuron\MyChatBot;
use NeuronAI\RAG\DataLoader\FileDataLoader;

MyChatBot::make()->addDocuments(
    // Usa el componente cargador de archivos para cargar un archivo de texto en el almacén vectorial
    FileDataLoader::for(__DIR__.'/my-article.md')->getDocuments()
);

RAG + Herramientas

La clase RAG de Neuron extiende la clase básica \NeuronAI\Agent class. Esto significa que tu RAG es siempre un agente y también puedes adjuntar herramientas y definir instrucciones del sistema en tu implementación.

Imagina que queremos implementar un agente capaz de dar consejos de entrenamiento basados en los datos del usuario. Aquí tienes un ejemplo de implementación completa:

namespace App\Neuron;

use NeuronAI\Providers\AIProviderInterface;
use NeuronAI\Providers\Anthropic\Anthropic;
use NeuronAI\RAG\Embeddings\EmbeddingsProviderInterface;
use NeuronAI\RAG\Embeddings\OpenAIEmbeddingsProvider;
use NeuronAI\RAG\RAG;
use NeuronAI\RAG\VectorStore\FileVectorStore;
use NeuronAI\RAG\VectorStore\VectorStoreInterface;
use NeuronAI\Tools\Toolkits\Calculator\CalculatorToolkit;

class WorkoutTipsAgent extends RAG
{
    protected function provider(): AIProviderInterface
    {
        return new Anthropic(
            key: 'ANTHROPIC_API_KEY',
            model: 'ANTHROPIC_MODEL',
        );
    }
    
    public function instructions(): string
    {
        return (string) new SystemPrompt(
            background: ["Eres un agente de IA especializado en dar consejos de entrenamiento."],
        );
    }
    
    protected function embeddings(): EmbeddingsProviderInterface
    {
        return new OpenAIEmbeddingsProvider(
            key: 'OPENAI_API_KEY',
            model: 'OPENAI_MODEL'
        );
    }
    
    protected function vectorStore(): VectorStoreInterface
    {
        return new FileVectorStore(
            directory: __DIR__,
            name: 'demo'
        );
    }
    
    protected function tools(): array
    {
        return [
            CalculatorToolkit::make(),
        ];
    }
}

En el ejemplo anterior creamos un agente RAG capaz de dar consejos de entrenamiento al usuario. Podemos cargar en el almacén vectorial el conocimiento sobre los entrenamientos específicos que proporcionas, de modo que el agente tenga el conocimiento para ofrecer consejos basados en el estado actual del entrenamiento del usuario recuperado de la base de datos con la herramienta que hemos adjuntado.

Flujo de trabajo de RAG

En la siguiente imagen puedes ver la representación completa del flujo de trabajo que ejecuta Neuron para una aplicación RAG. Aprender esta estructura puede ayudarte a comprender mejor el proceso de ejecución subyacente para conectar el sistema mediante middleware:

Una vez que el UserMessage entra en el sistema, se ejecuta en orden:

• PreProcessQueryNode: Ejecuta la preprocesadores pipeline como QueryTransformationPreProcessor para reforzar el prompt de entrada.

• RetrieveDocumentsNode: Ejecuta la estrategia de recuperación desde el almacén vectorial o fuentes de datos externas

• PostProcessDocumentsNode: Ejecuta la postprocesadores pipeline como reranking

• EnrichInstructionsNode: Añade los documentos finales al prompt del sistema del agente

• ChatNode: Ejecuta la inferencia y recoge la respuesta del LLM

• ToolNode: Si el agente tiene una herramienta adjunta, el modelo puede solicitar eventualmente su ejecución.

Finalmente, el RAG te devolverá el mensaje del LLM.