Arquitectura RAG Empresarial con pgvector y Modelos de Lenguaje Locales: Soberanía de Datos y Cero Fuga de Información

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. El envío inadvertido de balances financieros, información de clientes o secretos comerciales a servidores de terceros viola regulaciones como GDPR, CCPA y leyes locales de protección de datos personales.

En FORBUS S.R.L. implementamos arquitecturas RAG (Retrieval-Augmented Generation) 100% Privadas bajo el principio innegociable de Zero-Data-Leak (Cero Fuga de Datos): 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 lograr consultas de similitud de coseno en tiempos menores a 15 milisegundos sobre millones de vectores, configuramos la extensión oficial pgvector y creamos índices jerárquicos de mundos pequeños navegables (HNSW):

 sql Copiar
-- 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 Copiar
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 garantizar soberanía absoluta, ejecutamos los pesos del modelo mediante el servidor de inferencia de alto rendimiento vLLM con paginación PagedAttention:

 bash Copiar
# 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.