# Comparación de bases de datos vectoriales

Elige la base de datos vectorial adecuada para tus aplicaciones de IA en los servidores GPU de Clore.ai.

{% hint style="info" %}
**Bases de datos vectoriales** almacenan y recuperan incrustaciones de alta dimensión de forma eficiente — la infraestructura central para sistemas RAG, búsqueda semántica y motores de recomendación. Esta guía compara las cuatro opciones de código abierto más populares.
{% endhint %}

***

## Matriz de decisión rápida

|                         | ChromaDB                      | Qdrant            | Milvus                                 | Weaviate               |
| ----------------------- | ----------------------------- | ----------------- | -------------------------------------- | ---------------------- |
| **Mejor para**          | Prototipado, desarrollo local | RAG en producción | Búsqueda a escala de miles de millones | Grafos de conocimiento |
| **Despliegue**          | Incrustada/Servidor           | Servidor/Nube     | Servidor/Nube                          | Servidor/Nube          |
| **Escalabilidad**       | Nodo único                    | Multi-nodo        | Distribuido                            | Distribuido            |
| **Estrellas en GitHub** | 17K+                          | 21K+              | 31K+                                   | 12K+                   |
| **Licencia**            | Apache 2.0                    | Apache 2.0        | Apache 2.0                             | BSD de 3 cláusulas     |
| **Nube gestionada**     | No                            | Sí (Qdrant Cloud) | Sí (Zilliz)                            | Sí (Weaviate Cloud)    |
| **Idioma**              | Python                        | Rust              | Go                                     | Go                     |

***

## Resumen

### ChromaDB

ChromaDB es la base de datos vectorial más simple — diseñada para prototipado rápido y aplicaciones de pequeña a mediana escala. Puede ejecutarse completamente en memoria o persistir en disco.

**Filosofía**: Cero configuración, máxima experiencia para desarrolladores.

```python
import chromadb

client = chromadb.PersistentClient(path="/data/chroma")
collection = client.create_collection("my_docs")

collection.add(
    documents=["Machine learning is great", "Deep learning uses neural networks"],
    ids=["doc1", "doc2"]
)

results = collection.query(
    query_texts=["What is AI?"],
    n_results=2
)
```

### Qdrant

Qdrant es un motor de búsqueda vectorial listo para producción escrito en Rust. Se centra en el rendimiento, el filtrado y la simplicidad operativa.

**Filosofía**: Rendimiento de producción sin complejidad operativa.

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

client = QdrantClient("localhost", port=6333)
client.create_collection(
    collection_name="my_collection",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
)

client.upsert(
    collection_name="my_collection",
    points=[
        PointStruct(id=1, vector=[...], payload={"text": "document 1"}),
    ]
)

results = client.search(
    collection_name="my_collection",
    query_vector=[...],
    limit=10,
    query_filter=Filter(must=[FieldCondition(key="category", match=MatchValue(value="tech"))])
)
```

### Milvus

Milvus es la base de datos vectorial de código abierto más escalable, diseñada para despliegues a escala de miles de millones. Tiene una arquitectura distribuida con soporte para Kubernetes.

**Filosofía**: Escala masiva, nativa en la nube.

```python
from pymilvus import connections, Collection, FieldSchema, CollectionSchema, DataType

connections.connect("default", host="localhost", port=19530)

fields = [
    FieldSchema(name="id", dtype=DataType.INT64, is_primary=True),
    FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=1536),
    FieldSchema(name="text", dtype=DataType.VARCHAR, max_length=65535),
]
schema = CollectionSchema(fields)
collection = Collection("my_collection", schema)

# Insert data
collection.insert([[1, 2], embeddings, texts])
collection.create_index("embedding", {"metric_type": "COSINE", "index_type": "IVF_FLAT"})
collection.load()

results = collection.search(
    data=[query_embedding],
    anns_field="embedding",
    param={"metric_type": "COSINE", "nprobe": 10},
    limit=10
)
```

### Weaviate

Weaviate combina la búsqueda vectorial con grafos de conocimiento y una API GraphQL. Soporta búsqueda multimodal (texto, imágenes, audio) desde el primer momento.

**Filosofía**: Rico en esquemas, multimodal, capacidades de grafo de conocimiento.

```python
import weaviate

client = weaviate.Client("http://localhost:8080")

# Define schema with classes
client.schema.create_class({
    "class": "Document",
    "vectorizer": "text2vec-transformers",
    "properties": [
        {"name": "content", "dataType": ["text"]},
        {"name": "category", "dataType": ["string"]}
    ]
})

# Insert with auto-vectorization
client.data_object.create(
    {"content": "Machine learning tutorial", "category": "tech"},
    "Document"
)

# Semantic search
result = client.query.get("Document", ["content", "category"])\
    .with_near_text({"concepts": ["artificial intelligence"]})\
    .with_limit(5)\
    .do()
```

***

## Benchmarks de rendimiento

### ANN Benchmarks (ann-benchmarks.com, 2024)

#### 1M vectores, 768 dimensiones, similitud coseno

| Base de datos   | QPS (1 hilo) | Recall\@10 | Tiempo de construcción | Tamaño del índice |
| --------------- | ------------ | ---------- | ---------------------- | ----------------- |
| ChromaDB (HNSW) | \~2,000      | 98.5%      | 45s                    | 2.1GB             |
| Qdrant (HNSW)   | \~8,500      | 99.1%      | 32s                    | 1.8GB             |
| Milvus (HNSW)   | \~12,000     | 98.9%      | 28s                    | 1.9GB             |
| Weaviate (HNSW) | \~6,000      | 98.7%      | 38s                    | 2.0GB             |

#### 10M vectores (prueba de escalabilidad)

| Base de datos | QPS     | Uso de RAM      | Notas                      |
| ------------- | ------- | --------------- | -------------------------- |
| ChromaDB      | \~800   | 22GB            | Dificultades a gran escala |
| Qdrant        | \~5,200 | 18GB            | Bueno con cuantización     |
| Milvus        | \~9,800 | 15GB (indexado) | Mejor a escala             |
| Weaviate      | \~3,500 | 21GB            | Moderado                   |

{% hint style="info" %}
**Los benchmarks son guías, no evangelio.** El rendimiento varía enormemente según el tipo de índice, el hardware, las dimensiones del vector y los patrones de consulta. Siempre haz benchmarks con tus propios datos.
{% endhint %}

### Rendimiento de filtrado (búsqueda ANN filtrada)

La búsqueda filtrada (similitud vectorial + filtro de metadatos) es crucial para RAG en producción:

| Base de datos | QPS filtrada | Pre-filtro                   | Post-filtro |
| ------------- | ------------ | ---------------------------- | ----------- |
| ChromaDB      | \~500        | ❌                            | ✅           |
| Qdrant        | \~6,000      | ✅ (HNSW + índice de payload) | ✅           |
| Milvus        | \~8,000      | ✅                            | ✅           |
| Weaviate      | \~3,000      | ✅ (índice invertido)         | ✅           |

**Ganador para búsqueda filtrada**: Qdrant y Milvus, que soportan verdadero pre-filtrado sin degradación de rendimiento por post-filtrado.

***

## Comparación de características

### Almacenamiento e indexación

| Característica           | ChromaDB | Qdrant | Milvus | Weaviate |
| ------------------------ | -------- | ------ | ------ | -------- |
| Índice HNSW              | ✅        | ✅      | ✅      | ✅        |
| Índice IVF               | ❌        | ❌      | ✅      | ❌        |
| DiskANN                  | ❌        | ✅      | ✅      | ❌        |
| Cuantización escalar     | ❌        | ✅      | ✅      | ✅        |
| Cuantización de producto | ❌        | ✅      | ✅      | ❌        |
| Cuantización binaria     | ❌        | ✅      | ✅      | ✅        |
| Almacenamiento en disco  | ✅        | ✅      | ✅      | ✅        |
| Mmap                     | ❌        | ✅      | ✅      | ✅        |

### Capacidades de consulta

| Característica                 | ChromaDB   | Qdrant       | Milvus       | Weaviate    |
| ------------------------------ | ---------- | ------------ | ------------ | ----------- |
| Similitud vectorial            | ✅          | ✅            | ✅            | ✅           |
| Búsqueda híbrida (BM25+vector) | ❌          | ✅            | ✅            | ✅           |
| Filtrado por metadatos         | ✅ (básico) | ✅ (completo) | ✅ (completo) | ✅ (GraphQL) |
| Búsqueda por palabra clave     | ❌          | ✅            | ✅            | ✅           |
| Búsqueda multi-vector          | ❌          | ✅            | ✅            | ✅           |
| Vectores dispersos (SPLADE)    | ❌          | ✅            | ✅            | ✅           |
| Vectores con nombre            | ❌          | ✅            | ✅            | ✅           |

### Características operativas

| Característica                   | ChromaDB | Qdrant | Milvus | Weaviate |
| -------------------------------- | -------- | ------ | ------ | -------- |
| API REST                         | ✅        | ✅      | ✅      | ✅        |
| API gRPC                         | ❌        | ✅      | ✅      | ❌        |
| API GraphQL                      | ❌        | ❌      | ❌      | ✅        |
| Autenticación                    | Básico   | ✅      | ✅      | ✅        |
| RBAC                             | ❌        | ✅      | ✅      | ✅        |
| Escalado horizontal              | ❌        | ✅      | ✅      | ✅        |
| Soporte para Kubernetes          | ❌        | ✅      | ✅      | ✅        |
| Instantáneas/Copias de seguridad | ❌        | ✅      | ✅      | ✅        |
| Monitorización (Prometheus)      | ❌        | ✅      | ✅      | ✅        |

***

## ChromaDB: Análisis detallado

### Fortalezas

✅ **Configuración más simple** — `pip install chromadb` y ya está\
✅ **Modo incrustado** — sin proceso de servidor separado\
✅ **Auto-incrustación** — modelos de incrustación integrados\
✅ **Integración con LangChain/LlamaIndex** integración nativa\
✅ **Cero configuración** — ideal para prototipado

### Debilidades

❌ **Escala limitada** — tiene dificultades más allá de 1-2M vectores\
❌ **Sin modo distribuido** — solo nodo único\
❌ **Filtrado limitado** — sin pre-filtrado\
❌ **Sin cuantización** — mayor uso de memoria\
❌ **Lento a escala** — operaciones basadas en Python

### Despliegue en Clore.ai

```bash
# Modo cliente/servidor
docker run -d \
  --name chromadb \
  -p 8000:8000 \
  -v $(pwd)/chroma-data:/chroma/chroma \
  chromadb/chroma:latest

# Prueba
curl http://localhost:8000/api/v1/heartbeat
```

**Mejor para**: Cuadernos Jupyter, prototipos RAG rápidos, <1M vectores

***

## Qdrant: Análisis detallado

### Fortalezas

✅ **Mejor filtrado** — búsqueda vectorial con verdadero pre-filtrado\
✅ **Rendimiento de Rust** — extremadamente rápido, baja latencia\
✅ **Cuantización** — binario/escalar reduce la memoria 4-32×\
✅ **Vectores dispersos** — búsqueda híbrida densa+dispersa\
✅ **Operaciones simples** — único binario, sin dependencias\
✅ **Buena documentación** — excelentes guías y ejemplos

### Debilidades

❌ **Escritor único** en la capa gratuita (sin escrituras distribuidas)\
❌ **Ecosistema más pequeño** que Milvus\
❌ **Sin GraphQL** — solo REST/gRPC

### Despliegue en Clore.ai

```bash
# Despliegue simple
docker run -d \
  --name qdrant \
  -p 6333:6333 \
  -p 6334:6334 \
  -v $(pwd)/qdrant-storage:/qdrant/storage \
  qdrant/qdrant:latest

# Con autenticación
docker run -d \
  --name qdrant \
  -p 6333:6333 \
  -e QDRANT__SERVICE__API_KEY=your-secret-key \
  -v $(pwd)/qdrant-storage:/qdrant/storage \
  qdrant/qdrant:latest

# Prueba
curl http://localhost:6333/health
```

**Mejor para**: RAG de producción, búsqueda filtrada, 1-100M vectores

***

## Milvus: Análisis detallado

### Fortalezas

✅ **Escala masiva** — probado hasta +10B vectores\
✅ **Distribuido** — arquitectura nativa en la nube con Kubernetes\
✅ **La mayoría de tipos de índice** — IVF, HNSW, DiskANN, ScaNN\
✅ **Aceleración por GPU** — construcción de índices con GPU\
✅ **Características empresariales** — RBAC, registros de auditoría, cifrado\
✅ **Zilliz Cloud** — opción totalmente gestionada

### Debilidades

❌ **Despliegue complejo** — requiere etcd, MinIO y Pulsar/Kafka\
❌ **Requiere muchos recursos** — se recomiendan mínimo 3 nodos\
❌ **Curva de aprendizaje más pronunciada** — más conceptos que entender\
❌ **Excesivo para pequeña escala** — no usar para <1M vectores

### Despliegue en Clore.ai (Standalone)

```yaml
# docker-compose.yml para Milvus standalone
version: "3.8"
services:
  etcd:
    image: quay.io/coreos/etcd:v3.5.5
    environment:
      - ETCD_AUTO_COMPACTION_MODE=revision
      - ETCD_AUTO_COMPACTION_RETENTION=1000
      - ETCD_QUOTA_BACKEND_BYTES=4294967296
    command: etcd -advertise-client-urls=http://etcd:2379 -listen-client-urls=http://0.0.0.0:2379

  minio:
    image: minio/minio:RELEASE.2023-03-13T19-46-17Z
    environment:
      MINIO_ACCESS_KEY: minioadmin
      MINIO_SECRET_KEY: minioadmin
    command: minio server /minio_data --console-address ":9001"

  milvus:
    image: milvusdb/milvus:v2.4.0
    command: ["milvus", "run", "standalone"]
    environment:
      ETCD_ENDPOINTS: etcd:2379
      MINIO_ADDRESS: minio:9000
    ports:
      - "19530:19530"
      - "9091:9091"
    depends_on:
      - etcd
      - minio
```

```bash
docker compose up -d
# Toma ~60 segundos para arrancar completamente
```

**Mejor para**: Producción a gran escala, 100M+ vectores, despliegues empresariales

***

## Weaviate: Análisis detallado

### Fortalezas

✅ **Multimodal** — texto, imágenes, audio, video\
✅ **Auto-vectorización** — integraciones de modelos integradas\
✅ **API GraphQL** — consultas enriquecidas con recorridos de grafos\
✅ **Sistema de módulos** — vectorizadores y lectores enchufables\
✅ **Búsqueda híbrida** — BM25 + vector listo para usar\
✅ **Búsqueda generativa** — RAG integrado con el módulo de generación

### Debilidades

❌ **Mayor uso de memoria** — el almacenamiento con conocimiento de esquemas es más grande\
❌ **Sin gRPC** — solo GraphQL (más lento para QPS altas)\
❌ **Esquema complejo** — requiere definición de clases previa\
❌ **Más lento a escala extrema** que Milvus

### Despliegue en Clore.ai

```bash
# Despliegue simple
docker run -d \
  --name weaviate \
  -p 8080:8080 \
  -p 50051:50051 \
  -e AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED=true \
  -e PERSISTENCE_DATA_PATH=/var/lib/weaviate \
  -e DEFAULT_VECTORIZER_MODULE=none \
  -e CLUSTER_HOSTNAME=node1 \
  -v $(pwd)/weaviate-data:/var/lib/weaviate \
  cr.weaviate.io/semitechnologies/weaviate:1.25.0

# Con vectorizador transformer
docker run -d \
  --name weaviate \
  -p 8080:8080 \
  -e DEFAULT_VECTORIZER_MODULE=text2vec-transformers \
  -e TRANSFORMERS_INFERENCE_API=http://t2v-transformers:8080 \
  cr.weaviate.io/semitechnologies/weaviate:1.25.0
```

**Mejor para**: Búsqueda multimodal, grafos de conocimiento, búsqueda generativa

***

## Cuándo usar cada uno

### Decisión basada en escala

```
< 100K vectores    → ChromaDB (incrustada)
100K - 10M        → Qdrant (mejor equilibrio)
10M - 1B          → Milvus o Qdrant (en clúster)
1B+               → Milvus (distribuido)
```

### Decisión basada en caso de uso

| Caso de uso                 | Mejor opción      | Por qué                              |
| --------------------------- | ----------------- | ------------------------------------ |
| Prototipo RAG               | ChromaDB          | Cero configuración, API simple       |
| RAG en producción           | Qdrant            | Filtrado rápido, operaciones simples |
| Búsqueda semántica          | Qdrant o Milvus   | Mejor rendimiento                    |
| Multimodal                  | Weaviate          | Soporte integrado de imagen/audio    |
| Grafo de conocimiento       | Weaviate          | Consultas por recorrido de grafos    |
| Escala de miles de millones | Milvus            | Arquitectura distribuida             |
| Búsqueda híbrida            | Qdrant o Weaviate | BM25 + vector                        |
| Empresa                     | Milvus o Weaviate | RBAC, registros de auditoría         |

***

## Requisitos de memoria en Clore.ai

### Fórmula de estimación de RAM

```
RAM necesaria ≈ (vectores × dimensiones × 4 bytes) × 1.5 (sobrecarga)

Ejemplo: 1M vectores × 1536 dims × 4 bytes × 1.5 = 9.2GB de RAM

Con cuantización (Qdrant binario):
1M × 1536 / 8 × 1.5 = 0.29GB de RAM (¡compresión 32×!)
```

### Especificaciones de servidor recomendadas

| Tamaño del conjunto de datos | ChromaDB | Qdrant   | Milvus   | Weaviate |
| ---------------------------- | -------- | -------- | -------- | -------- |
| 1M de vectores               | 16GB RAM | 8GB RAM  | 32GB RAM | 16GB RAM |
| 10M de vectores              | ❌        | 32GB RAM | 64GB RAM | 48GB RAM |
| 100M de vectores             | ❌        | 128GB+   | 256GB+   | 256GB+   |

***

## Comparación rápida: Tiempo de configuración con Docker

| Base de datos | `docker run` hasta listo | Dependencias         |
| ------------- | ------------------------ | -------------------- |
| ChromaDB      | \~5 segundos             | Ninguna              |
| Qdrant        | \~3 segundos             | Ninguna              |
| Milvus        | \~60 segundos            | etcd + MinIO         |
| Weaviate      | \~15 segundos            | Ninguna (standalone) |

***

## Precios (autoalojado en Clore.ai)

Las cuatro bases de datos son **gratuitas** para autoalojar. El costo es solo el alquiler del servidor en Clore.ai:

```
Ejemplo: sistema RAG con 1M vectores
- Qdrant: servidor 8GB RAM ~ $0.10/hr
- ChromaDB: servidor 16GB RAM ~ $0.15/hr  
- Weaviate: servidor 16GB RAM ~ $0.15/hr
- Milvus: servidor 32GB RAM ~ $0.30/hr (+ sobrecarga por etcd/minio)
```

***

## Enlaces útiles

* [Documentación de ChromaDB](https://docs.trychroma.com)
* [Documentación de Qdrant](https://qdrant.tech/documentation)
* [Documentación de Milvus](https://milvus.io/docs)
* [Documentación de Weaviate](https://weaviate.io/developers/weaviate)
* [Benchmarks ANN](https://ann-benchmarks.com)
* [Benchmark de bases de datos vectoriales por Qdrant](https://qdrant.tech/benchmarks)

***

## Resumen

| Comienza con... | Si necesitas...                                                |
| --------------- | -------------------------------------------------------------- |
| **ChromaDB**    | Prototipo rápido, <1M vectores, configuración mínima           |
| **Qdrant**      | RAG de producción, gran filtrado, simplicidad operativa        |
| **Milvus**      | Escala de miles de millones, empresa, arquitectura distribuida |
| **Weaviate**    | Multimodal, grafos de conocimiento, consultas GraphQL          |

Para la mayoría de aplicaciones RAG en producción en Clore.ai, **Qdrant** ofrece el mejor equilibrio entre rendimiento, características y simplicidad operativa. Para necesidades a gran escala o empresariales, **Milvus** es el estándar de la industria.

***

## Recomendaciones de GPU en Clore.ai

| Caso de uso        | GPU recomendada | Coste estimado en Clore.ai |
| ------------------ | --------------- | -------------------------- |
| Desarrollo/Pruebas | RTX 3090 (24GB) | \~$0.12/gpu/hr             |
| Producción         | RTX 4090 (24GB) | \~$0.70/gpu/hr             |
| Gran escala        | A100 80GB       | \~$1.20/gpu/hr             |

> 💡 Todos los ejemplos en esta guía pueden desplegarse en [Clore.ai](https://clore.ai/marketplace) servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/comparaciones/vector-db-comparison.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.