Bases de datos vectoriales para agentes de IA

Las bases de datos vectoriales son la memoria a largo plazo de los agentes de IA. Sin ellas, los LLMs dependen únicamente de lo que contienen sus datos de entrenamiento, que suele estar desactualizado, ser incompleto o carecer de especificidad para el dominio. Con bases de datos vectoriales, los agentes pueden buscar semánticamente, recordar conversaciones anteriores y recuperar conocimiento específico del dominio mediante RAG (Retrieval-Augmented Generation).

Si estás construyendo un agente de IA que haga más que “simplemente chatear”, tarde o temprano necesitarás una base de datos vectorial. Este artículo explora los conceptos clave, compara las principales soluciones y muestra ejemplos de código completos.

TL;DR: Bases de datos vectoriales en 90 segundos

¿Qué es una base de datos vectorial?

Embeddings: El fundamento

Antes de entender las bases de datos vectoriales, necesitamos entender los embeddings. Un embedding es una representación numérica de texto: un array de cientos o miles de números que capturan el “significado” del texto.

from openai import OpenAI
client = OpenAI()

# Texto → vector (1536 dimensiones con text-embedding-3-small)
response = client.embeddings.create(
    model="text-embedding-3-small",
    input="Python es un lenguaje de programación."
)

vector = response.data[0].embedding
print(f"Dimensiones: {len(vector)}")  # p. ej. 1536
print(f"Primeros 5 valores: {vector[:5]}")
# [0.012, -0.034, 0.056, 0.078, -0.091, ...]

El principio clave: Los textos con significado similar tienen vectores similares. “Python es un lenguaje de programación” y “Python es un lenguaje de script” tienen vectores que están próximos. “Python es una serpiente” tiene un vector más lejano.

Búsqueda de similitud: Cómo funcionan las bases de datos vectoriales

Las bases de datos vectoriales encuentran vectores similares usando métricas de distancia:

• Cosine Similarity: Mide el ángulo entre vectores. Popular para embeddings de texto. Valor 1 = idéntico, 0 = independiente.
• Euclidean Distance (L2): Línea recta entre vectores. Distancia más pequeña = más similar.
• Dot Product: Rápido, pero menos significativo sin normalización.

# Cosine similarity calculado manualmente
import numpy as np

def cosine_similarity(v1, v2):
    return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))

sim = cosine_similarity(vector_a, vector_b)
# 0.95 = muy similar, 0.50 = moderadamente similar, 0.10 = apenas similar

El flujo de trabajo completo

ALMACENAR:
Texto → Modelo de embedding → Vector [0.12, -0.34, 0.56, ...] 
    → Base de datos vectorial (con metadatos: fuente, fecha, categoría)

BUSCAR:
Consulta "¿Qué es Python?" → Modelo de embedding → Vector 
    → Búsqueda de similitud en BD → Vectores más similares (top-K) 
    → Devolver textos asociados

¿Por qué los agentes de IA necesitan bases de datos vectoriales?

1. Memoria a largo plazo

Los LLMs tienen una ventana de contexto limitada (p. ej. 128K tokens en GPT-4o). Las conversaciones más largas deben almacenarse externamente. Las bases de datos vectoriales permiten encontrar semánticamente conversaciones anteriores relevantes y cargarlas en el contexto.

2. RAG: Retrieval-Augmented Generation

En lugar de depender de los datos de entrenamiento del LLM, buscas documentos relevantes en la base de datos vectorial y los proporcionas como contexto:

Pregunta del usuario → Búsqueda en base de datos vectorial → Top 5 documentos relevantes 
    → Prompt del LLM: "Responde la pregunta basándote en estos documentos: ..."

Este es el flujo de trabajo estándar para agentes de IA específicos del dominio (p. ej. soporte al cliente, bases de conocimiento internas, documentación de código).

3. Búsqueda semántica

Las búsquedas tradicionales requieren palabras clave exactas. Las bases de datos vectoriales encuentran similitud de significado: “¿Cómo programo un bucle?” también encuentra “Implementación de loop en Python”.

4. Escalabilidad

Con millones de documentos, la búsqueda por palabras clave es lenta e imprecisa. Las bases de datos vectoriales usan algoritmos Approximate Nearest Neighbor (ANN) que buscan en miles de millones de vectores en milisegundos.

Las principales bases de datos vectoriales: En detalle

Qdrant: Alto rendimiento en Rust

Qdrant es una base de datos vectorial escrita en Rust, optimizada para velocidad y uso en producción. Soporta filtrado, metadatos de payload y varias métricas de distancia.

from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct

# Conexión (local o Cloud)
client = QdrantClient(host="localhost", port=6333)
# O Cloud: QdrantClient(url="https://cluster-url", api_key="...")

# Crear collection (como una tabla en SQL)
client.create_collection(
    "agent_memory",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
    # Opcional: optimización para producción
    optimizers_config=OptimizersConfigDiff(
        indexing_threshold=0,  # Indexar inmediatamente
    )
)

# Insertar vectores con metadatos
client.upsert(
    "agent_memory",
    points=[
        PointStruct(
            id=1,
            vector=[0.12, -0.34, 0.56],  # En práctica: 1536-dimensional
            payload={
                "text": "Python es un lenguaje de programación.",
                "category": "programming",
                "source": "wikipedia",
                "date": "2026-07"
            }
        ),
        PointStruct(
            id=2,
            vector=[0.15, -0.31, 0.52],
            payload={
                "text": "Java es un lenguaje orientado a objetos.",
                "category": "programming",
                "source": "oracle-docs",
                "date": "2026-07"
            }
        )
    ]
)

# Búsqueda semántica con filtro
results = client.search(
    "agent_memory",
    query_vector=[0.11, -0.32, 0.55],
    query_filter=Filter(
        must=[
            FieldCondition(key="category", match=MatchValue(value="programming"))
        ]
    ),
    limit=5
)

for result in results:
    print(f"Score: {result.score:.4f} - {result.payload['text']}")

Fortalezas: Muy rápido (Rust), bueno para producción, filtrado, auto-hosting o Cloud, código abierto. Desventajas: Comunidad menor que Pinecone, sin embeddings integrados (necesitas modelo externo). Idoneidad: Sistemas en producción donde el rendimiento y el auto-hosting son importantes.

Weaviate — GraphQL-API con embeddings integrados

Weaviate es una base de datos vectorial escrita en Go que incluye modelos de embedding incorporados. No necesitas generar embeddings externos; Weaviate lo hace automáticamente.

import weaviate

# Conexión (local)
client = weaviate.connect_to_local()

# Crear colección con embeddings automáticos
articles = client.collections.create(
    name="Article",
    vectorizer_config=weaviate.Configure.Vectorizer.text2vec_openai(),
    # ¡Weaviate genera embeddings automáticamente!
)

# Añadir objeto (sin vectores manuales)
articles.data.insert({
    "title": "Programación con IA 2026",
    "content": "Texto completo del artículo...",
    "category": "programming"
})
# Weaviate genera el vector automáticamente

# Búsqueda semántica (near_text, no near_vector)
results = articles.query.near_text(
    query="¿Cómo funciona la programación con IA?",
    limit=5,
    filters=Filter.by_property("category").equal("programming")
)

for obj in results.objects:
    print(f"{obj.properties['title']}: {obj.properties['content'][:100]}")

Ventajas: embeddings incorporados (sin necesidad de modelo externo), GraphQL-API, Hybrid Search (vector + palabra clave), multi-modal (texto, imagen, audio). Desventajas: instalación más compleja, mayor consumo de recursos, menos flexibilidad al elegir el modelo de embedding. Ideal para: proyectos donde Hybrid Search es importante y no quieres gestionar embeddings por tu cuenta.

Chroma — Integración más simple para Python

Chroma (antes ChromaDB) es la base de datos vectorial más simple para Python. Está escrita en Python y no requiere un servidor separado; todo se ejecuta en el mismo proceso.

import chromadb

# En memoria o persistente
client = chromadb.PersistentClient(path="./chroma_data")
# O en memoria: client = chromadb.Client()

# Crear colección
collection = client.create_collection(
    name="agent_memory",
    metadata={"description": "Memoria a largo plazo del agente IA"}
)

# Añadir (Chroma genera embeddings automáticamente con el modelo por defecto)
collection.add(
    documents=["Python es un lenguaje de programación."],
    metadatas=[{"source": "wiki", "category": "programming"}],
    ids=["1"]
)

# O con embeddings propios:
# collection.add(embeddings=[[0.12, ...]], documents=[...], ids=[...])

# Búsqueda semántica
results = collection.query(
    query_texts=["¿Qué es Python?"],
    n_results=5,
    where={"category": "programming"}  # Filtro de metadatos
)

for doc, score, meta in zip(
    results["documents"][0],
    results["distances"][0],
    results["metadatas"][0]
):
    print(f"Score: {score:.4f} - {doc} (Source: {meta['source']})")

Ventajas: integración más simple (3 líneas de código), gratuito, sin servidor necesario, embeddings automáticos con modelo por defecto. Desventajas: no pensado para escala grande (millones+ de vectores), menos características que Qdrant/Weaviate. Ideal para: prototipos, desarrollo, proyectos pequeños, pruebas locales.

Pinecone — Base de datos vectorial gestionada en la nube

Pinecone es una base de datos vectorial completamente gestionada en la nube. Sin infraestructura, sin mantenimiento, sin problemas de escalabilidad, pero de pago.

from pinecone import Pinecone

pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"])
index = pc.Index("agent-memory")

# Upsert
index.upsert(
    vectors=[
        {
            "id": "1",
            "values": [0.12, -0.34, 0.56],  # 1536-dimensional
            "metadata": {"text": "Python es un lenguaje de programación.", "category": "programming"}
        }
    ]
)

# Query con filtro
results = index.query(
    vector=[0.11, -0.32, 0.55],
    top_k=5,
    include_metadata=True,
    filter={"category": {"$eq": "programming"}}
)

for match in results["matches"]:
    print(f"Score: {match['score']:.4f} - {match['metadata']['text']}")

Ventajas: completamente gestionado, escalable (miles de millones de vectores), sin infraestructura, opción sin servidor. Desventajas: costos (desde ~70$/mes), dependencia del proveedor, datos fuera de tu infraestructura (nube). Ideal para: empresas, cuando no quieres gestionar infraestructura y dispones de presupuesto.

Comparativa

Característica	Qdrant	Weaviate	Chroma	Pinecone
Hosting	Self/Cloud	Self/Cloud	Self/Local	Solo nube
Lenguaje	Rust	Go	Python	Go
Embeddings	Externo	Incorporado	Externo/Por defecto	Externo
Hybrid Search	Sí	Sí	No	Sí
Escalabilidad	Alta	Alta	Media	Muy alta
Costos	OSS/Cloud	OSS/Cloud	Gratuito	Desde ~70$/mes
Filtrado	Sí (Payload)	Sí (GraphQL)	Sí (where)	Sí (metadata)
Multi-modal	No	Sí (texto/imagen/audio)	No	No
Ideal para	Producción	Complejo/Hybrid	Prototipo	Empresa

Mi recomendación:

• Desarrollo/Prototipo: Chroma, 3 líneas de código, gratuito, sin servidor
• Producción (auto-alojado): Qdrant, rápido, Rust, código abierto, buena documentación
• Producción (gestionado): Pinecone, sin infraestructura, si tienes presupuesto
• Hybrid Search necesario: Weaviate, único con verdadero Hybrid Search de vector + palabra clave

Pipeline RAG con bases de datos vectoriales

RAG (Retrieval-Augmented Generation) es el caso de uso más frecuente para bases de datos vectoriales en agentes IA. Aquí hay un pipeline completo:

from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_qdrant import QdrantVectorStore
from langchain.text_splitter import RecursiveCharacterTextSplitter

# 1. Cargar documentos y dividirlos en fragmentos
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,        # 500 tokens por fragmento
    chunk_overlap=100,     # 100 tokens de solapamiento entre fragmentos
    separators=["\n\n", "\n", ". ", " "]
)
chunks = text_splitter.split_text(document_text)
# chunks = ["Primer párrafo...", "Segundo párrafo...", ...]

# 2. Generar embeddings y almacenarlos en Qdrant
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vector_store = QdrantVectorStore.from_texts(
    chunks,
    embeddings,
    url="http://localhost:6333",
    collection_name="knowledge_base"
)

# 3. Query RAG: encontrar documentos relevantes
llm = ChatOpenAI(model="gpt-4o", temperature=0)
retriever = vector_store.as_retriever(search_kwargs={"k": 5})

# 4. Generar respuesta con documentos encontrados como contexto
from langchain.chains import RetrievalQA
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=retriever,
    return_source_documents=True  # Muestra qué documentos se usaron
)

result = qa_chain.invoke({"query": "¿Qué es la programación con IA?"})
print(f"Respuesta: {result['result']}")
print(f"Fuentes: se usaron {len(result['source_documents'])} documentos")

Qué ocurre aquí:

1. Chunking: el texto del documento se corta en trozos de 500 tokens (con 100 tokens de solapamiento para no perder contexto)
2. Embedding + Almacenamiento: cada fragmento se convierte en un vector y se guarda en Qdrant
3. Retrieval: la pregunta del usuario se convierte en un vector, y Qdrant encuentra los 5 fragmentos más similares
4. Generación: el LLM recibe la pregunta más los 5 fragmentos encontrados como contexto y genera una respuesta

RAG en sistemas multi-agente

En un sistema multi-agente, cada agente puede tener su propia base de datos vectorial:

# Agente de investigación: busca en datos de web scraping
research_db = QdrantVectorStore(collection_name="web_research", ...)

# Agente de código: busca en documentación de código
code_db = QdrantVectorStore(collection_name="code_docs", ...)

# Agente de soporte: busca en base de conocimiento
support_db = QdrantVectorStore(collection_name="kb_articles", ...)

Mejores prácticas

1. Optimizar el tamaño de chunks

El tamaño de chunks es el parámetro más importante para la calidad en RAG:

• Muy pequeño (100 tokens): Pierde contexto, el chunk aislado no tiene sentido
• Muy grande (2000 tokens): Búsqueda imprecisa, el vector representa demasiados temas
• Recomendación: 500-1000 tokens, con solapamiento de 100-200 tokens

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=100,
    separators=["\n\n", "\n", ". ", " "]  # Natürliche Trennpunkte
)

2. Aprovechar los metadatos

Los metadatos permiten filtrado, algo crítico para bases de datos grandes:

# Metadatos al almacenar
collection.add(
    documents=["Artikel über Python"],
    metadatas=[{
        "category": "programming",
        "date": "2026-07",
        "author": "IRC",
        "source": "wiki",
        "language": "de"
    }],
    ids=["1"]
)

# Búsqueda filtrada: Solo artículos de programación en alemán
results = collection.query(
    query_texts=["Python"],
    where={"$and": [
        {"category": {"$eq": "programming"}},
        {"language": {"$eq": "de"}}
    ]},
    n_results=5
)

3. Elegir el modelo de embedding

Modelo	Dimensiones	Costo	Idoneidad
text-embedding-3-small	1536	$0.02/M tokens	Estándar, rápido
text-embedding-3-large	3072	$0.13/M tokens	Mayor calidad
sentence-transformers (local)	384-768	Gratuito	Desarrollo, privacidad

Importante: Si cambias el modelo de embedding, todos los vectores deben regenerarse (re-embedding). Los diferentes modelos producen vectores incompatibles.

4. Monitoreo

• Latencia de consultas: Debe estar por debajo de 100ms para buena experiencia
• Medir calidad de recall: Conjuntos de prueba con pares query-documento conocidos
• Rastrear uso de memoria: Los vectores consumen espacio (1536 dimensiones × 4 bytes = ~6KB por vector)
• Tamaño del índice: Qdrant y Pinecone muestran estadísticas del índice

5. Estrategia de re-embedding

Si actualizas el modelo de embedding:

1. Crear una nueva colección
2. Re-embedder todos los documentos y almacenarlos en la nueva colección
3. Realizar pruebas en la nueva colección
4. Redirigir el alias de la colección antigua a la nueva
5. Eliminar la colección antigua

Puntos relevantes para evaluación

• Base de datos vectorial: Almacena embeddings (vectores numéricos) para búsqueda semántica
• Embeddings: Representación numérica de texto, generados por modelos de embedding (p. ej., OpenAI text-embedding-3-small, 1536 dimensiones)
• Búsqueda de similitud: Similitud de coseno, distancia euclidiana, producto punto
• RAG: Retrieval-Augmented Generation, el LLM recibe documentos relevantes de la base de datos vectorial como contexto
• Chunking: Dividir texto en fragmentos (500-1000 tokens, 100-200 de solapamiento)
• Herramientas: Qdrant (Rust, producción), Weaviate (Go, búsqueda híbrida, embeddings integrados), Chroma (Python, prototipos), Pinecone (cloud, empresarial)
• Mejores prácticas: Optimizar tamaño de chunks, usar metadatos para filtrado, elegir conscientemente el modelo de embedding, monitoreo, re-embedding al cambiar modelos

Preguntas frecuentes

¿Qué base de datos vectorial usar para empezar? Chroma para prototipos, solo 3 líneas de código, gratuito, sin servidor. Qdrant para producción, rápido, código abierto, con opción de auto-hospedaje o cloud.

¿Necesito bases de datos vectoriales para cada agente de IA? No. Solo si el agente debe buscar en grandes bases de conocimiento, necesita memoria a largo plazo, o usa RAG para respuestas específicas del dominio. Para chatbots simples es suficiente la ventana de contexto del LLM.

¿Puedo ejecutar bases de datos vectoriales localmente? Sí. Qdrant (Docker), Weaviate (Docker) y Chroma (proceso Python) pueden ejecutarse localmente. Pinecone es solo cloud.

¿Cuántos vectores caben en una base de datos vectorial? Qdrant y Pinecone: Miles de millones. Weaviate: Millones. Chroma: Cientos de miles (después se vuelve lento). El límite suele ser almacenamiento, no el software.

¿Cuánto cuesta operar una base de datos vectorial?

• Chroma: Gratuito (auto-hospedado)
• Qdrant: Gratuito (auto-hospedado) o cloud desde ~25$/mes
• Weaviate: Gratuito (auto-hospedado) o cloud desde ~25$/mes
• Pinecone: Desde ~70$/mes (solo cloud)
• Costos de embedding: text-embedding-3-small cuesta $0.02 por 1M tokens

¿Puedo usar bases de datos vectoriales con modelos de embedding locales? Sí. Con sentence-transformers (p. ej., all-MiniLM-L6-v2) puedes embedder gratis localmente. Los vectores son más pequeños (384 dimensiones) y la calidad algo menor que OpenAI, pero suficiente para muchos casos de uso. Ideal para datos sensibles a la privacidad.

Lecturas recomendadas