Arquitectura RAG Empresarial con pgvector y Modelos de Lenguaje Locales: Control de Datos y Despliegue Privado

El Desafío de la Privacidad en la IA Generativa Corporativa

El uso masivo de APIs de LLMs en la nube pública representa un riesgo inaceptable para organizaciones del sector financiero, legal, salud y logística. Antes de enviar información de clientes o documentos confidenciales a un proveedor externo, evalúa los permisos de acceso, las condiciones de tratamiento y las obligaciones aplicables con el responsable de privacidad de tu organización.

En FORBUS S.R.L. implementamos arquitecturas RAG (Retrieval-Augmented Generation) 100% Privadas bajo el objetivo de minimizar la exposición de datos, con controles de acceso, registros y revisión de las salidas de red: tanto los vectores de conocimiento como la inferencia del modelo se ejecutan dentro de la red privada (VPC o servidores on-premise) del cliente.

1. Diagrama de la Arquitectura RAG Empresarial

 Renderizando Diagrama de Arquitectura...

2. Configuración de PostgreSQL 16 con la Extensión pgvector

Para evaluar consultas de similitud de coseno según el tamaño del conjunto de datos y las necesidades de latencia, configuramos la extensión oficial pgvector y creamos índices jerárquicos de mundos pequeños navegables (HNSW):

 sql
-- Habilitar extensión pgvector
CREATE EXTENSION IF NOT EXISTS vector;

-- Tabla de chunks documentales con metadatos
CREATE TABLE enterprise_knowledge_chunks (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    document_id VARCHAR(100) NOT NULL,
    chunk_index INT NOT NULL,
    content_text TEXT NOT NULL,
    metadata JSONB NOT NULL DEFAULT '{}'::jsonb,
    tsv tsvector GENERATED ALWAYS AS (to_tsvector('spanish', content_text)) STORED,
    embedding vector(1024) NOT NULL,
    created_at TIMESTAMPTZ DEFAULT clock_timestamp()
);

-- Índice HNSW optimizado para distancia Coseno
CREATE INDEX idx_knowledge_embedding_hnsw 
ON enterprise_knowledge_chunks 
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 128);

-- Índice GIN para búsqueda full-text complementaria (búsqueda híbrida)
CREATE INDEX idx_knowledge_tsv ON enterprise_knowledge_chunks USING GIN(tsv);

3. Implementación de Búsqueda Híbrida (Vectorial + Sintáctica)

La búsqueda exclusivamente semántica puede fallar cuando el usuario busca identificadores exactos (ej. códigos de factura, números de serie o referencias normativas específicas). Por ello, combinamos la distancia de coseno con ts_rank mediante la técnica de Reciprocal Rank Fusion (RRF):

 python
import psycopg2
from typing import List, Dict, Any

def hybrid_search(cur, query_vector: List[float], query_text: str, top_k: int = 5) -> List[Dict[str, Any]]:
    sql = """
    WITH semantic_search AS (
        SELECT id, document_id, content_text, metadata,
               1 - (embedding <=> %(vector)s::vector) AS semantic_score,
               ROW_NUMBER() OVER (ORDER BY embedding <=> %(vector)s::vector) AS rank_semantic
        FROM enterprise_knowledge_chunks
        ORDER BY embedding <=> %(vector)s::vector
        LIMIT 20
    ),
    fulltext_search AS (
        SELECT id, document_id, content_text, metadata,
               ts_rank_cd(tsv, plainto_tsquery('spanish', %(query_text)s)) AS text_score,
               ROW_NUMBER() OVER (ORDER BY ts_rank_cd(tsv, plainto_tsquery('spanish', %(query_text)s)) DESC) AS rank_text
        FROM enterprise_knowledge_chunks
        WHERE tsv @@ plainto_tsquery('spanish', %(query_text)s)
        LIMIT 20
    )
    SELECT COALESCE(s.id, f.id) AS chunk_id,
           COALESCE(s.content_text, f.content_text) AS content,
           COALESCE(s.metadata, f.metadata) AS metadata,
           -- Reciprocal Rank Fusion Formula (k = 60)
           (COALESCE(1.0 / (60 + s.rank_semantic), 0.0) + 
            COALESCE(1.0 / (60 + f.rank_text), 0.0)) AS rrf_score
    FROM semantic_search s
    FULL OUTER JOIN fulltext_search f ON s.id = f.id
    ORDER BY rrf_score DESC
    LIMIT %(top_k)s;
    """
    cur.execute(sql, {'vector': query_vector, 'query_text': query_text, 'top_k': top_k})
    return cur.fetchall()

4. Despliegue de Inferencia Local con vLLM

Para evitar el costo de suscripciones comerciales y mantener el control del despliegue, ejecutamos los pesos del modelo mediante el servidor de inferencia de alto rendimiento vLLM con paginación PagedAttention:

 bash
# Despliegue en contenedor con aceleración NVIDIA TensorRT / CUDA
python3 -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Meta-Llama-3-70B-Instruct \
    --tensor-parallel-size 4 \
    --gpu-memory-utilization 0.92 \
    --max-model-len 8192 \
    --dtype bfloat16 \
    --port 8000

Resultados y Conclusiones

La implementación de este esquema permite responder consultas complejas sobre cientos de miles de páginas con citas textuales verificables, latencia promedio de inferencia menor a 1.2 segundos y la certeza legal de que ningún byte corporativo sale de la infraestructura custodiada por la empresa.