PGVector base de datos vectorial

PostgreSQL con extensión pgvector

PostgreSQL es una de las bases de datos relacionales más utilizadas en entornos empresariales, y con la extensión pgvector se convierte en una solución híbrida que combina las capacidades tradicionales de SQL con el almacenamiento y búsqueda de vectores. Esta combinación resulta especialmente atractiva para organizaciones que ya tienen infraestructura PostgreSQL establecida.

La extensión pgvector añade un tipo de dato específico para vectores y operadores optimizados para realizar búsquedas de similitud. A diferencia de las soluciones especializadas como ChromaDB, pgvector mantiene todas las garantías ACID de PostgreSQL, lo que significa que las operaciones vectoriales se benefician de transacciones, consistencia y durabilidad.

Configuración del entorno con Docker

Para comenzar a trabajar con pgvector, la forma más sencilla es utilizar Docker Compose con una imagen que ya incluye la extensión preinstalada. El siguiente archivo docker-compose.yml configura un contenedor PostgreSQL con pgvector:

version: '3.8'

services:
  postgres:
    container_name: pgvector
    image: pgvector/pgvector:pg17
    ports:
      - "5434:5432"
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: postgres
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

Esta configuración utiliza el puerto 5434 para evitar conflictos con instalaciones locales de PostgreSQL que típicamente usan el puerto 5432. El volumen persistente garantiza que los datos se mantengan entre reinicios del contenedor.

Para iniciar el servicio, ejecuta el siguiente comando en el directorio donde se encuentra el archivo:

docker-compose up -d

Instalación de dependencias Python

Una vez que el contenedor está ejecutándose, necesitas instalar las dependencias de Python para conectarte a PostgreSQL desde LangChain:

pip install langchain-postgres psycopg[binary]

El paquete langchain-postgres proporciona la integración específica con PostgreSQL, mientras que psycopg es el adaptador de base de datos que permite la comunicación entre Python y PostgreSQL.

Verificación de la conexión

Antes de trabajar con vectores, es recomendable verificar que la conexión funciona correctamente y que la extensión pgvector está disponible:

import psycopg

# Cadena de conexión
connection_string = "postgresql://postgres:postgres@localhost:5434/postgres"

# Verificar conexión y extensión
with psycopg.connect(connection_string) as conn:
    with conn.cursor() as cur:
        # Crear la extensión si no existe
        cur.execute("CREATE EXTENSION IF NOT EXISTS vector;")
        
        # Verificar que la extensión está instalada
        cur.execute("SELECT * FROM pg_extension WHERE extname = 'vector';")
        result = cur.fetchone()
        
        if result:
            print("Extensión pgvector instalada correctamente")
        else:
            print("Error: extensión pgvector no encontrada")

Características empresariales de pgvector

La principal ventaja de pgvector en entornos empresariales radica en su integración nativa con PostgreSQL. Esto significa que puedes combinar búsquedas vectoriales con consultas SQL tradicionales en una sola transacción:

# Ejemplo conceptual de consulta híbrida
query = """
SELECT 
    documento.titulo,
    documento.fecha_creacion,
    embedding <-> %s as distancia
FROM documentos documento
WHERE documento.categoria = 'tecnico'
    AND documento.fecha_creacion > '2024-01-01'
ORDER BY embedding <-> %s
LIMIT 5;
"""

Esta capacidad de consultas híbridas permite filtrar documentos por metadatos tradicionales (fecha, categoría, autor) mientras se realiza simultáneamente una búsqueda por similitud vectorial.

Tipos de índices vectoriales

pgvector soporta diferentes tipos de índices para optimizar las búsquedas vectoriales según las necesidades específicas:

• IVFFlat: Ideal para conjuntos de datos medianos, ofrece un buen equilibrio entre velocidad de búsqueda y precisión
• HNSW: Optimizado para búsquedas muy rápidas en conjuntos de datos grandes, con mayor uso de memoria

-- Crear índice IVFFlat
CREATE INDEX ON documentos USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);

-- Crear índice HNSW
CREATE INDEX ON documentos USING hnsw (embedding vector_cosine_ops);

Consideraciones de rendimiento

Al trabajar con grandes volúmenes de datos vectoriales, pgvector ofrece varias opciones de configuración para optimizar el rendimiento:

# Configuración de parámetros de conexión para mejor rendimiento
connection_params = {
    "host": "localhost",
    "port": "5434",
    "database": "postgres",
    "user": "postgres",
    "password": "postgres",
    "options": "-c shared_preload_libraries=vector"
}

La extensión pgvector también permite ajustar parámetros específicos como ivfflat.probes para controlar el equilibrio entre velocidad y precisión en las búsquedas.

Integración con sistemas existentes

Una de las ventajas más significativas de pgvector es su capacidad de integrarse con sistemas empresariales existentes que ya utilizan PostgreSQL. Esto elimina la necesidad de mantener bases de datos separadas para diferentes tipos de datos:

# Ejemplo de integración con sistema de usuarios existente
connection_string = "postgresql://postgres:postgres@localhost:5434/postgres"

# La misma base de datos puede contener:
# - Tablas tradicionales (usuarios, productos, pedidos)
# - Tablas con vectores (documentos_embedding, imagenes_embedding)
# - Vistas que combinan ambos tipos de datos

Esta unificación simplifica la arquitectura del sistema, reduce la complejidad operacional y permite aprovechar las herramientas de administración, monitoreo y backup ya establecidas para PostgreSQL.

PGVector en LangChain

La integración de PGVector con LangChain se realiza a través del paquete langchain-postgres, que proporciona una interfaz consistente con otros vectorstores del ecosistema LangChain. Esta implementación mantiene la compatibilidad con las operaciones estándar de vectorstore mientras aprovecha las capacidades empresariales de PostgreSQL.

Configuración básica del vectorstore

Para crear una instancia de PGVector en LangChain, necesitas configurar la conexión y especificar el modelo de embeddings que utilizarás:

from langchain_postgres import PGVector
from langchain_openai import OpenAIEmbeddings

# Configurar embeddings
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# Crear instancia de PGVector
vector_store = PGVector(
    embeddings=embeddings,
    collection_name="documentos_empresa",
    connection="postgresql+psycopg://postgres:postgres@localhost:5434/postgres",
)

La cadena de conexión utiliza el formato SQLAlchemy con el driver psycopg, que es el recomendado para las versiones actuales de LangChain. El parámetro collection_name define el nombre de la tabla donde se almacenarán los vectores.

Operaciones básicas con documentos

Una vez configurado el vectorstore, puedes realizar las operaciones estándar de LangChain para gestionar documentos:

from langchain_core.documents import Document

# Crear documentos de ejemplo
documentos = [
    Document(
        page_content="PostgreSQL es una base de datos relacional robusta",
        metadata={"categoria": "base_datos", "autor": "equipo_dev"}
    ),
    Document(
        page_content="LangChain facilita el desarrollo de aplicaciones con LLM",
        metadata={"categoria": "framework", "autor": "equipo_ia"}
    ),
    Document(
        page_content="Los vectores permiten búsquedas semánticas avanzadas",
        metadata={"categoria": "ia", "autor": "equipo_ia"}
    )
]

# Añadir documentos al vectorstore
ids = vector_store.add_documents(documentos)
print(f"Documentos añadidos con IDs: {ids}")

Búsquedas por similitud

PGVector en LangChain soporta diferentes métodos de búsqueda que aprovechan las capacidades de la extensión pgvector:

# Búsqueda por similitud básica
query = "¿Qué es una base de datos?"
resultados = vector_store.similarity_search(query, k=2)

for doc in resultados:
    print(f"Contenido: {doc.page_content}")
    print(f"Metadata: {doc.metadata}")
    print("---")

Para obtener también las puntuaciones de similitud, puedes utilizar el método específico:

# Búsqueda con puntuaciones
resultados_con_score = vector_store.similarity_search_with_score(query, k=2)

for doc, score in resultados_con_score:
    print(f"Puntuación: {score:.4f}")
    print(f"Contenido: {doc.page_content}")
    print("---")

Ejemplo completo:

Filtrado por metadatos

Una de las ventajas de PGVector es su capacidad para combinar búsquedas vectoriales con filtros tradicionales basados en metadatos:

# Búsqueda filtrada por metadatos
filtro = {"categoria": "ia"}
resultados_filtrados = vector_store.similarity_search(
    query="búsquedas semánticas",
    k=3,
    filter=filtro
)

print(f"Encontrados {len(resultados_filtrados)} documentos en categoría 'ia'")

Configuración avanzada de conexión

Para entornos de producción, puedes configurar parámetros adicionales de conexión que optimicen el rendimiento:

from langchain_postgres import PGVector
from sqlalchemy import create_engine

# Configuración avanzada del motor de base de datos
engine = create_engine(
    "postgresql+psycopg://postgres:postgres@localhost:5434/postgres",
    pool_size=10,
    max_overflow=20,
    pool_pre_ping=True
)

# Vectorstore con configuración personalizada
vector_store_avanzado = PGVector(
    embeddings=embeddings,
    collection_name="documentos_produccion",
    connection=engine,
    pre_delete_collection=False,  # No eliminar colección existente
    use_jsonb=True  # Usar JSONB para metadatos
)

Gestión de colecciones

PGVector permite trabajar con múltiples colecciones dentro de la misma base de datos, lo que facilita la organización de diferentes tipos de documentos:

# Crear diferentes colecciones para diferentes propósitos
vector_store_manuales = PGVector(
    embeddings=embeddings,
    collection_name="manuales_tecnicos",
    connection="postgresql+psycopg://postgres:postgres@localhost:5434/postgres"
)

vector_store_faqs = PGVector(
    embeddings=embeddings,
    collection_name="preguntas_frecuentes",
    connection="postgresql+psycopg://postgres:postgres@localhost:5434/postgres"
)

# Cada colección mantiene sus propios índices y configuraciones

Actualización y eliminación de documentos

PGVector soporta operaciones de mantenimiento que son esenciales en aplicaciones empresariales:

# Eliminar documentos por ID
vector_store.delete(ids=["id_documento_1", "id_documento_2"])

# Actualizar documentos existentes
documentos_actualizados = [
    Document(
        page_content="PostgreSQL con pgvector es ideal para aplicaciones empresariales",
        metadata={"categoria": "base_datos", "version": "actualizada"}
    )
]

# Añadir documentos actualizados
nuevos_ids = vector_store.add_documents(documentos_actualizados)

En Cursor IDE o Visual Studio Code es posible instalar extensión PostgreSQL y conectarse a este PGVector, donde veremos una tabla con las colecciones:

Y otra tabla con los embeddings de PGVector:

En la columna embedding tenemos los embeddings y en la columna document vemos el contenido al que corresponden esos embeddings.

Integración con LCEL

PGVector se integra perfectamente con LangChain Expression Language (LCEL) para crear cadenas de procesamiento más complejas:

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

# Configurar componentes
chat_model = ChatOpenAI(model="gpt-4o")
prompt = ChatPromptTemplate.from_template(
    "Basándote en el siguiente contexto: {context}\n\nResponde a: {question}"
)

# Crear retriever desde el vectorstore
retriever = vector_store.as_retriever(search_kwargs={"k": 3})

# Cadena LCEL que combina búsqueda y generación
chain = (
    {"context": retriever, "question": lambda x: x["question"]}
    | prompt
    | chat_model
    | StrOutputParser()
)

# Usar la cadena
respuesta = chain.invoke({"question": "¿Qué ventajas tiene PostgreSQL?"})
print(respuesta)

Monitoreo y métricas

En entornos empresariales, es importante poder monitorear el rendimiento del vectorstore:

import time

# Función para medir tiempo de búsqueda
def busqueda_con_metricas(query, k=5):
    inicio = time.time()
    resultados = vector_store.similarity_search(query, k=k)
    tiempo_transcurrido = time.time() - inicio
    
    print(f"Búsqueda completada en {tiempo_transcurrido:.3f} segundos")
    print(f"Documentos encontrados: {len(resultados)}")
    
    return resultados

# Ejemplo de uso
resultados = busqueda_con_metricas("aplicaciones de inteligencia artificial")

Esta integración con LangChain permite que PGVector funcione como un componente estándar en aplicaciones RAG, manteniendo la familiaridad de la API mientras se beneficia de las garantías empresariales de PostgreSQL.