Construyendo un sistema RAG con LangChain y PostgreSQL

En los últimos años, la integración entre inteligencia artificial generativa y datos corporativos estructurados se ha convertido en una de las áreas más prometedoras de la ingeniería de software. Este proyecto — desarrollado como parte del MBA en Ingeniería de Software con IA de Full Cycle — presenta una arquitectura práctica de RAG (Retrieval-Augmented Generation) utilizando Python, LangChain y PostgreSQL con la extensión pgVector.

El concepto de RAG (Retrieval-Augmented Generation)

RAG es un enfoque que combina recuperación de información (retrieval) con generación de lenguaje natural (generation). A diferencia de una IA pura, que depende solo del conocimiento incorporado en su modelo, el RAG busca información en fuentes externas (bases de datos, PDFs, documentos corporativos) y las inserta en el contexto antes de generar una respuesta. Esto garantiza precisión, rastreabilidad y actualización continua de los datos.

Arquitectura y componentes principales

La arquitectura fue diseñada para ser modular y extensible, basada en tres capas principales:

Ingestión: carga el contenido de un PDF, lo divide en chunks (1000 caracteres con overlap de 150) y genera embeddings usando proveedores como HuggingFace, OpenAI o Gemini.
Almacenamiento: guarda los vectores generados en PostgreSQL, utilizando la extensión pgVector, permitiendo consultas de similitud basadas en distancia vectorial.
Búsqueda y Respuesta: consulta el banco vectorial, recupera los contextos más relevantes y los envía al modelo de lenguaje, que genera una respuesta basada exclusivamente en el contenido encontrado.

├── docker-compose.yml
├── requirements.txt
├── .env.example
├── document.pdf
└── src/
    ├── ingest.py      # Pipeline de ingestión y vectorización del PDF
    ├── search.py      # Búsqueda semántica y montaje de contexto
    └── chat.py        # CLI interactivo con fallback rule-based

Pipeline de ingestión

La etapa de ingestión es responsable de transformar contenido textual en representaciones numéricas vectoriales. Esto se hace vía embeddings, que mapean significado semántico en espacios de alta dimensión. El sistema soporta tres proveedores:

🧠 HuggingFace (Local): modelo all-MiniLM-L6-v2, ideal para ambientes sin conexión con APIs.
☁️ OpenAI (text-embedding-3-small): rápido y optimizado para costo-beneficio.
⚡ Gemini (models/embedding-001): alternativa Google con integración directa al ecosistema Generative AI.

from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_postgres import PGVector

embeddings = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2')
PGVector.from_documents(
    documents=chunks,
    embedding=embeddings,
    connection=engine,
    collection_name='pdf_chunks'
)

Búsqueda semántica y generación de respuestas

En la fase de consulta, el sistema recibe una pregunta, genera su embedding y realiza una búsqueda de similitud en el banco vectorial. Los 10 chunks más relevantes son concatenados y usados para formar el contexto de la respuesta. Si el modelo LLM no está disponible, el sistema aplica un fallback rule-based que busca patrones explícitos (como valores monetarios o nombres de empresas).

context = build_context(results)
chain = prompt | llm | StrOutputParser()
response = chain.invoke({"contexto": context, "pregunta": question})

Aplicaciones prácticas en otros proyectos

Esta arquitectura puede ser reutilizada en diversos escenarios corporativos y de productos SaaS. Algunos ejemplos de aplicación real incluyen:

📚 Asistentes de soporte interno: bots capaces de responder dudas basándose en manuales técnicos y políticas empresariales.
🏥 Salud y nutrición: integración con reportes médicos o bases de alimentos para recomendaciones personalizadas.
🏢 Compliance y jurídico: búsqueda semántica en documentos legales para acelerar due diligence y auditorías.
🛒 E-commerce: recomendación contextualizada de productos basada en descripciones y catálogos.
📊 Data Intelligence: combinación con pipelines ETL para análisis de datos no estructurados y consultas híbridas SQL + embeddings.

Lecciones aprendidas y próximos pasos

El proyecto demostró el poder de combinar IA generativa con bases de datos relacionales tradicionales. Entre las principales lecciones: mantener consistencia entre dimensiones vectoriales, usar fallback lógico para ambientes offline y modularizar el código para facilitar cambios de proveedores. Como evolución natural, el próximo paso será exponer esta arquitectura como una API REST con FastAPI y construir una interfaz web interactiva en Next.js.

Arquitectura RAG con LangChain, PostgreSQL y pgVector

Integrar LangChain con pgVector es una de las formas más elegantes y escalables de traer IA contextualizada a aplicaciones empresariales modernas. Es un camino sólido para transformar datos en inteligencia.

Vinicius Aguiar