> For the complete documentation index, see [llms.txt](https://docs.neuron-ai.dev/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.neuron-ai.dev/neuron-v3-es/rag/pre-post-processor.md).

# Pre/Postprocesador

Mejora la salida de RAG mediante el pre y postprocesamiento de prompts y resultados de recuperación.

Como ocurre con la mayoría de los sistemas de software, RAG es fácil de usar, pero difícil de dominar. La verdad es que RAG es más que poner documentos en una base de datos vectorial y añadir encima un LLM. Eso *puede funcionar*, pero no siempre.

Con RAG, estás realizando una *búsqueda semántica* en muchos documentos de texto; estos pueden ir desde decenas de miles hasta decenas de miles de millones de documentos.

Para garantizar tiempos de búsqueda rápidos a escala, normalmente usamos búsqueda vectorial; es decir, transformamos nuestro texto en vectores, los colocamos todos en una base de datos vectorial y comparamos su proximidad con una consulta usando un algoritmo de similitud (como la similitud del coseno).

Para obtener respuestas de alta calidad del agente RAG, puedes trabajar en dos partes del proceso de recuperación:

1. Optimizar el prompt del usuario (*Preprocesadores*)
2. Refinar los resultados de búsqueda recopilados del almacén vectorial (*Postprocesadores*)

## Preprocesadores

En lugar de tratar la consulta original del usuario como la última palabra, el preprocesador la ve como el punto de partida para una interacción más sofisticada con el sistema de conocimiento subyacente. No se trata de cuestionar la intención del usuario, sino de reconocer que su expresión en lenguaje natural a menudo contiene múltiples preguntas incrustadas, restricciones implícitas y supuestos contextuales que deben desglosarse y reformularse para maximizar la eficacia de la recuperación.

Considera la complejidad oculta dentro de consultas aparentemente simples. Cuando alguien pregunta "¿Por qué cayeron nuestras ventas el trimestre pasado?", en realidad está expresando una necesidad de información con múltiples facetas que podría requerir comprender tendencias estacionales, actividades de la competencia, la eficacia de las campañas de marketing, métricas de rendimiento del producto e indicadores económicos. Un sistema RAG ingenuo podría recuperar información general sobre el análisis de ventas, perdiendo la oportunidad de proporcionar perspectivas completas y relevantes en contexto que aborden todo el alcance de la pregunta subyacente.

### Transformación de consultas

La esencia de este patrón es usar un LLM para transformar la pregunta original en un prompt más estructurado que el agente RAG principal pueda usar para realizar una recuperación de documentos más precisa y eficaz del almacén vectorial.

Con Neuron puedes pasar la instancia del proveedor de IA ya adjunta a tu agente:

```php
namespace App\Neuron;

use NeuronAI\RAG\RAG;
use NeuronAI\RAG\PreProcessor\QueryTransformationPreProcessor;
use NeuronAI\RAG\PreProcessor\QueryTransformationType;

class MyChatBot extends RAG
{
    ...

    protected function preProcessors(): array
    {
        return [
            new QueryTransformationPreProcessor(
                provider: $this->resolveProvider(),
                transformation: QueryTransformationType::REWRITING,
            ),
        ];
    }
}
```

O usa un proveedor diferente entre los proveedores de IA compatibles como Gemini, Ollama, OpenAI, HuggingFace, etc.

```php
namespace App\Neuron;

use NeuronAI\RAG\RAG;
use NeuronAI\RAG\PreProcessor\QueryTransformationPreProcessor;
use NeuronAI\RAG\PreProcessor\QueryTransformationType;

class MyChatBot extends RAG
{
    ...

    protected function preProcessors(): array
    {
        return [
            new QueryTransformationPreProcessor(
                // Usa uno de los proveedores de IA compatibles
                provider: new Anthropic(
                    key: 'ANTHROPIC_API_KEY',
                    model: 'ANTHROPIC_MODEL',
                ),
                transformation: QueryTransformationType::REWRITING,
            ),
        ];
    }
}
```

Las tres estrategias principales implementadas en el preprocesador de Neuron son: reescritura, descomposición y HyDE (Hypothetical Document Embeddings), y cada una aborda diferentes aspectos de este desafío de transformación de consultas.

**Reescritura de consultas** aborda la discrepancia fundamental entre el lenguaje conversacional y las formulaciones optimizadas para la búsqueda. Cuando los usuarios expresan sus necesidades en un lenguaje informal y dependiente del contexto, el proceso de reescritura traduce estas expresiones en formulaciones más precisas y buscables que se alinean mejor con la forma en que la información suele organizarse e indexarse.

**Descomposición** gestiona la realidad de que las preguntas complejas a menudo contienen múltiples necesidades de información distintas que se atenderían mejor mediante operaciones de recuperación separadas. En lugar de forzar una sola búsqueda para satisfacer múltiples aspectos diferentes de una consulta, la descomposición divide las preguntas complejas en sus partes constituyentes, permitiendo que cada componente se aborde con precisión enfocada antes de sintetizar los resultados en una respuesta completa.

T**el enfoque HyDE** representa quizá la estrategia más sofisticada, trabajando hacia atrás a partir del supuesto de que la mejor manera de encontrar información relevante es imaginar primero cómo podría ser esa información. En lugar de buscar directamente con la pregunta del usuario, HyDE genera documentos hipotéticos que idealmente responderían a la consulta, y luego usa esos documentos generados como base para búsquedas de similitud. Este enfoque es particularmente potente cuando se trata de conceptos abstractos o cuando la terminología del usuario no coincide estrechamente con el vocabulario utilizado en los documentos fuente.

## Postprocesadores

Para que la búsqueda vectorial funcione en su lugar, necesitamos vectores. Estos vectores son esencialmente compresiones del "significado" detrás de cierto texto en vectores de (normalmente) 768 o 1536 dimensiones. Hay cierta pérdida de información porque estamos comprimiendo esta información en un único vector.

Debido a esta pérdida de información, a menudo vemos que los tres primeros documentos de la búsqueda vectorial, por ejemplo, pasarán por alto información relevante. Desafortunadamente, la recuperación puede devolver información relevante por debajo de nuestro `top_k` umbral.

¿Qué hacemos si la información relevante en una posición más baja ayudaría a nuestro LLM a formular una mejor respuesta? El enfoque más sencillo es aumentar el número de documentos que estamos devolviendo (aumentar `top_k`) y pasárselos todos al LLM.

Desafortunadamente, no podemos pasar todo al LLM porque esto reduce drásticamente el rendimiento del LLM para encontrar información relevante en el texto colocado dentro de su ventana de contexto.

La solución a este problema es recuperar muchos documentos del almacén vectorial y luego *minimizar* el número de documentos que llegan al LLM. Para ello, puedes reordenar y filtrar los documentos recuperados para quedarte solo con los más relevantes para nuestro LLM.

Neuron te permite definir una lista de componentes posprocesadores para encadenar tantas transformaciones como necesites para optimizar la salida del agente.

### Reordenadores

El reordenamiento es una de las operaciones de posprocesamiento más populares que puedes aplicar a los documentos recuperados. Un servicio de reordenamiento calcula una puntuación de similitud de cada documento recuperado del almacén vectorial con la consulta de entrada.

Usamos esta puntuación para reordenar los documentos por relevancia y quedarnos solo con los más útiles.

### Reordenador de Jina

```php
namespace App\Neuron;

use NeuronAI\RAG\RAG;
use NeuronAI\RAG\PostProcessor\JinaRerankerPostProcessor;
use NeuronAI\RAG\VectorStore\FileVectoreStore;
use NeuronAI\RAG\VectorStore\VectorStoreInterface;

class MyChatBot extends RAG
{
    ...
    
    protected function vectorStore(): VectorStoreInterface
    {
        return new FileVectoreStore(
            directory: storage_path(),
            topK: 50
        );
    }

    protected function postProcessors(): array
    {
        return [
            new JinaRerankerPostProcessor(
                key: 'JINA_API_KEY',
                model: 'JINA_MODEL',
                topN: 5
            ),
        ];
    }
}
```

En el ejemplo anterior puedes ver cómo se le indica al almacén vectorial que obtenga 50 documentos, y el reordenador básicamente solo tomará los 5 más relevantes.

### Reordenador de Cohere

```php
namespace App\Neuron;

use NeuronAI\RAG\RAG;
use NeuronAI\RAG\PostProcessor\CohereRerankerPostProcessor;
use NeuronAI\RAG\VectorStore\FileVectoreStore;
use NeuronAI\RAG\VectorStore\VectorStoreInterface;

class MyChatBot extends RAG
{
    ...
    
    protected function vectorStore(): VectorStoreInterface
    {
        return new FileVectoreStore(
            directory: storage_path(),
            topK: 50
        );
    }

    protected function postProcessors(): array
    {
        return [
            new CohereRerankerPostProcessor(
                key: 'COHERE_API_KEY',
                model: 'COHERE_MODEL',
                topN: 3
            ),
        ];
    }
}
```

### Umbral fijo

Usa un umbral fijo simple y configurable para filtrar documentos. Los documentos con puntuaciones por debajo del umbral se eliminan de los resultados.

Es ideal para escenarios que requieren un corte explícito de puntuación para requisitos de calidad fijos.

```php
namespace App\Neuron;

use NeuronAI\RAG\PostProcessor\FixedThresholdPostProcessor;

class MyChatBot extends RAG
{
    ...

    protected function postProcessors(): array
    {
        return [
            new FixedThresholdPostProcessor(
                threshold: 0.5
            ),
        ];
    }
}
```

### Umbral adaptativo

Implementa un algoritmo de umbral dinámico usando la mediana y MAD (desviación absoluta mediana). Se ajusta automáticamente a las distribuciones de puntuación, lo que lo hace robusto frente a valores atípicos.

Puedes configurar un parámetro multiplicador que controla la agresividad del filtrado.

Valores de multiplicador recomendados:

* \[0.2 a 0.4] Modo de alta precisión. Para resultados más dirigidos, con menos documentos pero más relevantes.
* \[0.5 a 0.7] Modo equilibrado. Configuración recomendada para casos de uso generales.
* \[0.8 a 1.0] Modo de alto recuerdo. Para resultados más inclusivos que priorizan la cobertura.
* \>1.0 No recomendado, ya que tiende a incluir casi todos los documentos.

Este componente es ideal para limpiar los resultados de RAG con filtrado dinámico que se adapta a la distribución de puntuaciones del conjunto de resultados actual.

```php
namespace App\Neuron;

use NeuronAI\RAG\PostProcessor\AdaptiveThresholdPostProcessor;

class MyChatBot extends RAG
{
    ...

    protected function postProcessors(): array
    {
        return [
            new AdaptiveThresholdPostProcessor(
                multiplier: 0.6
            ),
        ];
    }
}
```

## Monitorización

Las funciones de observabilidad integradas de Neuron rastrean automáticamente la ejecución de cada posprocesador, por lo que podrás supervisar las interacciones con servicios externos en tu [Inspector](https://inspector.dev/) cuenta. Obtén más información en la [sección de monitorización](https://docs.neuron-ai.dev/neuron-v3-es/agente/observability.md).

<figure><img src="https://content.gitbook.com/content/GHx4l2LknIex7vFIUg1R/blobs/xpMKbcgXc0ICCyxjj5D2/neuron-reranker-observability.png" alt=""><figcaption></figcaption></figure>

## Ampliando el marco

Con Neuron puedes crear fácilmente componentes de posprocesamiento personalizados simplemente extendiendo la `\NeuronAI\PostProcessor\PostProcessorInterface`:

```php
namespace NeuronAI\RAG\PostProcessor;

use NeuronAI\Chat\Messages\Message;
use NeuronAI\RAG\Document;

interface PostProcessorInterface
{
    /**
     * Procesa un array de documentos y devuelve los documentos procesados.
     *
     * @param Message $question La pregunta para la que se procesan los documentos.
     * @param array<Document> $documents Los documentos a procesar.
     * @return array<Document> Los documentos procesados.
     */
    public function process(Message $question, array $documents): array;
}
```

Implementando el `process` método, puedes realizar acciones sobre la lista de documentos y devolver la nueva lista. Neuron ejecutará los posprocesadores en el mismo orden en que aparecen en el `postProcessors()` método.

Aquí tienes un ejemplo práctico:

```php
namespace App\Neuron\PostProcessors;

use NeuronAI\Chat\Messages\Message;
use NeuronAI\RAG\PostProcessor\PostProcessorInterface;

// Implementa tu componente personalizado
class CutOffPostProcessor implements PostProcessorInterface
{
    public function __constructor(protected int $level) {}

    public function process(Message $question, array $documents): array
    {
        /*
         * Aplica un corte en la puntuación devuelta por el almacén vectorial
         */
         
        return $documents;
    }
}
```
