Práctica: Implementación de un Sistema RAG Híbrido con pgvector

Concepto clave

Un sistema RAG híbrido con pgvector combina la potencia de las búsquedas vectoriales con las capacidades relacionales tradicionales de PostgreSQL. Imagina que tienes una biblioteca donde no solo puedes buscar libros por título (búsqueda tradicional), sino también por "sentimiento" o "estilo" (búsqueda vectorial). pgvector permite almacenar y consultar embeddings de texto directamente en PostgreSQL, creando una base de datos que entiende tanto datos estructurados como semántica.

La arquitectura híbrida es crucial porque muchos sistemas reales necesitan filtrar por metadatos (como fecha, categoría o usuario) antes de realizar la búsqueda semántica. Por ejemplo, en un sistema de soporte técnico, primero querrías filtrar por "producto X" y luego buscar preguntas similares. pgvector integra esto en una sola consulta SQL, evitando la complejidad de mantener múltiples sistemas.

"La verdadera ventaja de pgvector no es solo almacenar vectores, sino combinarlos con 30 años de evolución de bases de datos relacionales."

Cómo funciona en la práctica

Implementar un sistema RAG con pgvector sigue estos pasos:

1. Preparar la base de datos: Instalar la extensión pgvector y crear tablas con columnas vectoriales.
2. Generar y almacenar embeddings: Usar un modelo como sentence-transformers para convertir documentos en vectores y guardarlos en PostgreSQL.
3. Consultar híbridamente: Combinar filtros SQL tradicionales con búsqueda por similitud vectorial usando operadores como <-> (distancia euclidiana).
4. Integrar con LLM: Tomar los resultados relevantes y usarlos como contexto para un modelo como GPT-4.

Ejemplo de una tabla:

id	contenido	embedding	categoria	fecha
1	"Cómo configurar pgvector"	[0.1, 0.2, ...]	tutorial	2024-01-15
2	"Errores comunes en RAG"	[0.3, 0.4, ...]	debugging	2024-02-20

Caso de estudio

Una empresa de e-learning implementó un asistente de preguntas sobre sus cursos usando pgvector. Tenían 10,000 fragmentos de video-transcripciones almacenados en PostgreSQL con metadatos como curso_id, dificultad y duración. Cuando un estudiante pregunta "¿Cómo optimizar consultas SQL?", el sistema:

1. Filtra por curso_id = "bases-de-datos"
2. Busca los 5 fragmentos más similares usando embeddings
3. Combina esos fragmentos en un contexto para GPT-4
4. Genera una respuesta precisa citando los videos relevantes

Esto redujo el tiempo de respuesta de soporte en un 70% y mejoró la precisión versus usar solo búsqueda por palabras clave.

Errores comunes

• No normalizar vectores: pgvector funciona mejor con vectores normalizados (magnitud ~1). Usa embedding / norm(embedding) al almacenar.
• Ignorar índices: Sin un índice HNSW o IVFFlat, las consultas serán lentas con más de 10,000 vectores. Crea índices después de insertar datos.
• Mezclar distancias: Usar distancia euclidiana (<->) cuando necesitas similitud coseno. Para similitud coseno, usa 1 - (embedding <=> query_embedding).
• Olvidar mantenimiento: Los índices vectoriales necesitan REINDEX después de muchas inserciones para mantener el rendimiento.
• Embeddings de mala calidad: Usar un modelo genérico para dominios especializados (médico, legal) dará resultados pobres. Fine-tune o elige modelos de dominio.

Checklist de dominio

• Puedo instalar y configurar la extensión pgvector en PostgreSQL 12+
• Sé crear tablas con columnas vector(768) y definir índices HNSW apropiados
• He implementado un pipeline que genera embeddings y los inserta en PostgreSQL
• Puedo escribir consultas SQL que combinen filtros WHERE con ORDER BY usando operadores vectoriales
• He integrado los resultados de pgvector con un LLM via API (OpenAI, Anthropic, o local)
• Sé monitorear el rendimiento de consultas vectoriales con EXPLAIN ANALYZE
• Puedo decidir cuándo usar búsqueda híbrida vs. solo vectorial basado en requisitos del negocio

Implementa un sistema de preguntas y respuestas sobre documentación técnica

Construye un sistema RAG que responda preguntas sobre la documentación de PostgreSQL usando pgvector. Sigue estos pasos:

1. Configura el entorno:
   • Instala PostgreSQL 15+ con pgvector en un entorno local o cloud
   • Crea una base de datos llamada rag_demo y ejecuta CREATE EXTENSION vector;
2. Prepara los datos:
   • Descarga 50 páginas de la documentación oficial de PostgreSQL (puedes usar web scraping o archivos markdown)
   • Divide cada página en fragmentos de 200-300 palabras
   • Genera embeddings para cada fragmento usando el modelo all-MiniLM-L6-v2 (dimensión 384)
3. Diseña el esquema:
   • Crea una tabla docs con: id (serial), contenido (text), embedding (vector(384)), categoria (text), url (text)
   • Inserta todos los fragmentos con sus embeddings y metadatos
   • Crea un índice HNSW: CREATE INDEX ON docs USING hnsw (embedding vector_cosine_ops);
4. Implementa la búsqueda híbrida:
   • Escribe una función SQL que acepte una pregunta (texto), una categoría opcional, y devuelva los 3 fragmentos más relevantes
   • La función debe filtrar por categoría si se provee, y usar similitud coseno
   • Prueba con: "¿Cómo crear un índice concurrente?" (categoría: "performance")
5. Integra con LLM:
   • Usa la API de OpenAI o un modelo local (Llama 3) para generar respuestas basadas en los fragmentos recuperados
   • Crea un script Python que: 1) convierte la pregunta en embedding, 2) ejecuta la consulta SQL, 3) envía contexto al LLM
6. Evalúa:
   • Prueba con 5 preguntas técnicas y verifica que las respuestas sean precisas y citen la documentación correcta
   • Mide el tiempo de respuesta end-to-end

Pistas

• Usa pgvector 0.5.0+ para soporte completo de HNSW
• Para similitud coseno en pgvector, la distancia es 1 - (embedding <=> query_embedding) donde <=> es el operador de distancia coseno
• Considera usar un pool de conexiones en tu script Python para mejor rendimiento

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.