Ir al contenido principal
Español— Elegir un idioma
Menú

Bases de datos vectoriales (Pinecone, Qdrant, Weaviate)

Lección 8 de 22 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Objetivos
  2. ¿Por qué una base de datos vectorial?
  3. Pinecone
  4. Qdrant
  5. Weaviate
  6. Chroma y pgvector
  7. Comparativa
  8. Resumen

Objetivos

  • Comprender por qué son necesarias las bases de datos vectoriales
  • Comparar Pinecone, Qdrant, Weaviate, Chroma y pgvector
  • Implementar búsquedas con cada una de ellas

¿Por qué una base de datos vectorial?

El índice NumPy de la lección anterior funciona a la perfección para unos pocos miles de documentos, ya que un escaneo exhaustivo de diez mil vectores resulta imperceptible. Sin embargo, al llegar a un millón, ese mismo cálculo supone un segundo de latencia por consulta y la matriz deja de caber cómodamente en memoria.

Surgen cuatro necesidades conjuntas. La búsqueda ANN (Approximate Nearest Neighbors o vecinos más próximos aproximados) abandona la garantía de un resultado exacto a cambio de una respuesta en milisegundos sobre millones de vectores; un compromiso casi siempre aceptable, pues devolver el quinto mejor documento en lugar del cuarto no cambia nada para la experiencia del usuario. El filtrado por metadatos combinado con la búsqueda vectorial permite restringir una consulta a una categoría, idioma o rango de fechas sin necesidad de posprocesamiento. La persistencia y las actualizaciones en tiempo real evitan tener que reconstruir un archivo entero solo para añadir un documento. Por último, la escalabilidad horizontal es lo que distingue un prototipo de un servicio en producción.

Pinecone

Pinecone es un servicio gestionado: no provisionas servidores, creas un índice especificando su dimensión y métrica, y el resto se gestiona automáticamente. Observa el filtro categorie pasado directamente a query: la búsqueda vectorial y el filtrado se ejecutan juntos, no uno tras otro.

from pinecone import Pinecone
from openai import OpenAI

pc = Pinecone(api_key="your-pinecone-key")
openai_client = OpenAI()

# Crear un índice
pc.create_index(
    name="my-corpus",
    dimension=3072,
    metric="cosine",
    spec={"serverless": {"cloud": "aws", "region": "eu-west-1"}}
)

index = pc.Index("my-corpus")

# Indexar documentos
documents = [
    {"id": "doc1", "texte": "Python Installation Guide",
     "categorie": "tutorial"},
    {"id": "doc2", "texte": "Deploying a Flask Application",
     "categorie": "tutorial"},
    {"id": "doc3", "texte": "Q1 2026 Quarterly Report",
     "categorie": "report"},
]

# Generar embeddings
textes = [d["texte"] for d in documents]
response = openai_client.embeddings.create(
    input=textes,
    model="text-embedding-3-large"
)

# Insertar en Pinecone (upsert)
vecteurs = [
    {
        "id": doc["id"],
        "values": emb.embedding,
        "metadata": {"texte": doc["texte"], "categorie": doc["categorie"]}
    }
    for doc, emb in zip(documents, response.data)
]
index.upsert(vectors=vecteurs)

# Búsqueda
query_emb = openai_client.embeddings.create(
    input="how to install Python",
    model="text-embedding-3-large"
).data[0].embedding

resultats = index.query(
    vector=query_emb,
    top_k=3,
    include_metadata=True,
    filter={"categorie": {"$eq": "tutorial"}}
)

for match in resultats.matches:
    print(f"[{match.score:.3f}] {match.metadata['texte']}")

La dimensión declarada en la creación es definitiva: cambiar de text-embedding-3-large a text-embedding-3-small obliga a recrear el índice. Decide el modelo antes, no después.

Qdrant

Qdrant es de código abierto, autoalojable y ofrece un rendimiento excelente. El vocabulario difiere: hablamos de colecciones, puntos y cargas útiles (payloads) donde Pinecone habla de índices, vectores y metadatos, pero el esquema es idéntico. Ten en cuenta que el ejemplo llama a la API de embeddings documento a documento dentro del bucle: esto es aceptable para tres documentos, pero piensa en volver al procesamiento por lotes en cuanto crezca el corpus.

from qdrant_client import QdrantClient
from qdrant_client.models import (
    Distance, VectorParams, PointStruct, Filter,
    FieldCondition, MatchValue
)
from openai import OpenAI

qclient = QdrantClient(url="http://localhost:6333")
openai_client = OpenAI()

# Crear una colección
qclient.create_collection(
    collection_name="my-corpus",
    vectors_config=VectorParams(
        size=3072,
        distance=Distance.COSINE
    )
)

# Indexar documentos
points = []
for i, doc in enumerate(documents):
    emb = openai_client.embeddings.create(
        input=doc["texte"],
        model="text-embedding-3-large"
    ).data[0].embedding

    points.append(PointStruct(
        id=i,
        vector=emb,
        payload={"texte": doc["texte"], "categorie": doc["categorie"]}
    ))

qclient.upsert(collection_name="my-corpus", points=points)

# Búsqueda con filtro
query_emb = openai_client.embeddings.create(
    input="deploy a web application",
    model="text-embedding-3-large"
).data[0].embedding

resultats = qclient.search(
    collection_name="my-corpus",
    query_vector=query_emb,
    limit=3,
    query_filter=Filter(
        must=[FieldCondition(
            key="categorie",
            match=MatchValue(value="tutorial")
        )]
    )
)

for r in resultats:
    print(f"[{r.score:.3f}] {r.payload['texte']}")

Weaviate

Weaviate destaca por su búsqueda híbrida nativa, que retomaremos en la lección 9. Su modelo de datos es más estructurado que el de sus competidores: declaras explícitamente las propiedades y sus tipos antes de insertar nada, lo que acerca la experiencia a la de una base de datos clásica.

import weaviate
from openai import OpenAI

wclient = weaviate.connect_to_local()
openai_client = OpenAI()

# Crear una colección
from weaviate.classes.config import Property, DataType

collection = wclient.collections.create(
    name="Document",
    properties=[
        Property(name="texte", data_type=DataType.TEXT),
        Property(name="categorie", data_type=DataType.TEXT),
    ]
)

# Indexar
for doc in documents:
    emb = openai_client.embeddings.create(
        input=doc["texte"],
        model="text-embedding-3-large"
    ).data[0].embedding

    collection.data.insert(
        properties={"texte": doc["texte"], "categorie": doc["categorie"]},
        vector=emb
    )

# Búsqueda
query_emb = openai_client.embeddings.create(
    input="install Python",
    model="text-embedding-3-large"
).data[0].embedding

resultats = collection.query.near_vector(
    near_vector=query_emb,
    limit=3
)

Chroma y pgvector

Chroma está pensado para el prototipado: un cliente persistente apuntando a una carpeta local, una colección creada al vuelo, sin infraestructura. Es la opción que te lleva de un índice NumPy a una base de datos real sin cambiar tu entorno de trabajo.

import chromadb
from openai import OpenAI

chroma = chromadb.PersistentClient(path="./chroma_db")
openai_client = OpenAI()

collection = chroma.get_or_create_collection("my-corpus")

# Indexar
for doc in documents:
    emb = openai_client.embeddings.create(
        input=doc["texte"],
        model="text-embedding-3-large"
    ).data[0].embedding

    collection.add(
        ids=[doc["id"]],
        embeddings=[emb],
        documents=[doc["texte"]],
        metadatas=[{"categorie": doc["categorie"]}]
    )

# Búsqueda
query_emb = openai_client.embeddings.create(
    input="how to install Python",
    model="text-embedding-3-large"
).data[0].embedding

resultats = collection.query(query_embeddings=[query_emb], n_results=3)

pgvector aborda una situación muy distinta: tus documentos ya están en PostgreSQL, con sus joins, permisos de acceso y copias de seguridad. En lugar de introducir un segundo sistema que sincronizar, la extensión añade un tipo vector y operadores de distancia a la base de datos existente. El operador <=> calcula la distancia coseno, y el índice HNSW es lo que hace que la consulta sea usable más allá de unos pocos miles de filas.

-- Extensión pgvector
CREATE EXTENSION vector;

CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    texte TEXT,
    categorie TEXT,
    embedding vector(3072)
);

-- Índice HNSW para rendimiento
CREATE INDEX ON documents
USING hnsw (embedding vector_cosine_ops);

-- Búsqueda de los 5 vecinos más próximos
SELECT id, texte, 1 - (embedding <=> $1::vector) AS score
FROM documents
ORDER BY embedding <=> $1::vector
LIMIT 5;

Comparativa

CriterioPineconeQdrantWeaviateChromapgvector
TipoGestionadoCódigo abiertoCódigo abiertoCódigo abiertoExtensión
AlojamientoNubeAutoalojado/NubeAutoalojado/NubeLocal/IncrustadoPostgreSQL
Búsqueda híbrida✅✅✅ Nativa❌Vía SQL
Producción✅✅✅⚠️ Prototipado✅
Facilidad de uso✅✅✅✅✅✅✅

La elección depende menos del rendimiento bruto, que en la práctica es muy similar, que de tu contexto: un equipo que ya ejecuta PostgreSQL tiene todo el interés en mantenerse en él, un equipo sin operaciones (ops) elegirá una solución gestionada, y un equipo que deba alojar en Europa por razones normativas se decantará por el autoalojamiento.

Resumen

  • Chroma para prototipado rápido
  • pgvector si ya tienes PostgreSQL
  • Pinecone para una solución gestionada sin infraestructura
  • Qdrant para autoalojamiento de alto rendimiento
  • Weaviate para búsqueda híbrida nativa