> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/comparaciones/vector-db-comparison.md).

# 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 dimensionalidad 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 rápida de decisión

|                         | ChromaDB                      | Qdrant            | Milvus                                 | Weaviate               |
| ----------------------- | ----------------------------- | ----------------- | -------------------------------------- | ---------------------- |
| **Ideal para**          | Prototipado, desarrollo local | RAG de producción | Búsqueda a escala de miles de millones | Grafos de conocimiento |
| **Despliegue**          | Incrustado/Servidor           | Servidor/Nube     | Servidor/Nube                          | Servidor/Nube          |
| **Escalabilidad**       | Un solo nodo                  | Múltiples nodos   | 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              | Ir                                     | Ir                     |

***

## Descripción general

### ChromaDB

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

**Filosofía**: Sin configuración, la mejor experiencia para desarrolladores.

```python
import chromadb

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

collection.add(
    documents=["El aprendizaje automático es genial", "El aprendizaje profundo usa redes neuronales"],
    ids=["doc1", "doc2"]
)

results = collection.query(
    query_texts=["¿Qué es la IA?"],
    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": "documento 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 de 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)

# Insertar datos
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 búsqueda vectorial con grafos de conocimiento y una API GraphQL. Admite búsqueda multimodal (texto, imágenes, audio) de forma inmediata.

**Filosofía**: Capacidades con mucho esquema, multimodales y de grafo de conocimiento.

```python
import weaviate

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

# Definir esquema con clases
client.schema.create_class({
    "class": "Document",
    "vectorizer": "text2vec-transformers",
    "properties": [
        {"name": "content", "dataType": ["text"]},
        {"name": "category", "dataType": ["string"]}
    ]
})

# Inserción con auto-vectorización
client.data_object.create(
    {"content": "Tutorial de aprendizaje automático", "category": "tech"},
    "Document"
)

# Búsqueda semántica
result = client.query.get("Document", ["content", "category"])\
    .with_near_text({"concepts": ["inteligencia artificial"]})\
    .with_limit(5)\
    .do()
```

***

## Puntos de referencia de rendimiento

### Benchmarks ANN (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%      | 45 s                   | 2.1 GB            |
| Qdrant (HNSW)   | \~8,500      | 99.1%      | 32 s                   | 1.8 GB            |
| Milvus (HNSW)   | \~12,000     | 98.9%      | 28 s                   | 1.9 GB            |
| Weaviate (HNSW) | \~6,000      | 98.7%      | 38 s                   | 2.0 GB            |

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

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

{% hint style="info" %}
**Los benchmarks son guías, no evangelio.** El rendimiento varía mucho según el tipo de índice, el hardware, las dimensiones de los vectores y los patrones de consulta. Siempre haz pruebas 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 filtrado | Pre-filtrado                 | Pos-filtrado |
| ------------- | ------------ | ---------------------------- | ------------ |
| 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 admiten verdadero prefiltrado sin degradación del rendimiento por posfiltrado.

***

## Comparación de características

### Almacenamiento e indexación

| Función                  | 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

| Función                        | ChromaDB   | Qdrant   | Milvus   | Weaviate    |
| ------------------------------ | ---------- | -------- | -------- | ----------- |
| Similitud vectorial            | ✅          | ✅        | ✅        | ✅           |
| Búsqueda híbrida (BM25+vector) | ❌          | ✅        | ✅        | ✅           |
| Filtrado de metadatos          | ✅ (básico) | ✅ (rico) | ✅ (rico) | ✅ (GraphQL) |
| Búsqueda por palabras clave    | ❌          | ✅        | ✅        | ✅           |
| Búsqueda multivector           | ❌          | ✅        | ✅        | ✅           |
| Vectores dispersos (SPLADE)    | ❌          | ✅        | ✅        | ✅           |
| Vectores con nombre            | ❌          | ✅        | ✅        | ✅           |

### Funciones operativas

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

***

## ChromaDB: análisis en profundidad

### Fortalezas

✅ **La configuración más sencilla** — `pip install chromadb` y listo\
✅ **Modo embebido** — sin proceso de servidor separado\
✅ **Auto-incrustación** — modelos de incrustación integrados\
✅ **LangChain/LlamaIndex** integración nativa\
✅ **Sin configuración** — ideal para prototipado

### Debilidades

❌ **Escala limitada** — tiene dificultades más allá de 1-2M de vectores\
❌ **Sin modo distribuido** — solo un nodo\
❌ **Filtrado limitado** — sin prefiltrado\
❌ **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
```

**Ideal para**: cuadernos de Jupyter, prototipos rápidos de RAG, <1M de vectores

***

## Qdrant: análisis en profundidad

### Fortalezas

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

### Debilidades

❌ **Escritura única** en el nivel gratuito (sin escrituras distribuidas)\
❌ **Ecosistema más pequeño** que Milvus\
❌ **Sin GraphQL** — solo REST/gRPC

### Despliegue en Clore.ai

```bash
# Despliegue sencillo
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=tu-clave-secreta \
  -v $(pwd)/qdrant-storage:/qdrant/storage \
  qdrant/qdrant:latest

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

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

***

## Milvus: análisis en profundidad

### Fortalezas

✅ **Escala masiva** — probado con más de 10 mil millones de vectores\
✅ **Distribuido** — arquitectura Kubernetes nativa de la nube\
✅ **La mayoría de los tipos de índice** — IVF, HNSW, DiskANN, ScaNN\
✅ **Aceleración GPU** — construcción de índices acelerada por GPU\
✅ **Funciones empresariales** — RBAC, registros de auditoría, cifrado\
✅ **Zilliz Cloud** — opción totalmente gestionada

### Debilidades

❌ **Despliegue complejo** — requiere etcd, MinIO y Pulsar/Kafka\
❌ **Elevado consumo de recursos** — se recomiendan al menos 3 nodos\
❌ **Curva de aprendizaje más pronunciada** — hay más conceptos que entender\
❌ **Excesivo para pequeña escala** — no lo uses para <1M de vectores

### Despliegue en Clore.ai (autónomo)

```yaml
# docker-compose.yml para Milvus autónomo
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
# Tarda ~60 segundos en iniciarse por completo
```

**Ideal para**: Producción a gran escala, más de 100M de vectores, despliegues empresariales

***

## Weaviate: análisis en profundidad

### Fortalezas

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

### Debilidades

❌ **Mayor memoria** — el almacenamiento consciente del esquema es más grande\
❌ **Sin gRPC** — solo GraphQL (más lento para QPS altos)\
❌ **Esquema complejo** — requiere definir clases por adelantado\
❌ **Más lento a escala extrema** que Milvus

### Despliegue en Clore.ai

```bash
# Despliegue sencillo
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
```

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

***

## Cuándo usar cada uno

### Decisión basada en la escala

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

### Decisión basada en el caso de uso

| Caso de uso                 | Mejor opción      | Por qué                                     |
| --------------------------- | ----------------- | ------------------------------------------- |
| Prototipo de RAG            | ChromaDB          | Sin configuración, API sencilla             |
| RAG de producción           | Qdrant            | Filtrado rápido, operaciones simples        |
| Búsqueda semántica          | Qdrant o Milvus   | Mejor rendimiento                           |
| Multimodal                  | Weaviate          | Compatibilidad integrada con imágenes/audio |
| Grafo de conocimiento       | Weaviate          | Consultas de recorrido de grafos            |
| Escala de miles de millones | Milvus            | Arquitectura distribuida                    |
| Búsqueda híbrida            | Qdrant o Weaviate | BM25 + vector                               |
| Empresarial                 | 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.2 GB de RAM

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

### Especificaciones recomendadas del servidor

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

***

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

| Base de datos | `docker run` para estar listo | Dependencias            |
| ------------- | ----------------------------- | ----------------------- |
| ChromaDB      | \~5 segundos                  | Ninguno                 |
| Qdrant        | \~3 segundos                  | Ninguno                 |
| Milvus        | \~60 segundos                 | etcd + MinIO            |
| Weaviate      | \~15 segundos                 | Ninguno (independiente) |

***

## Precios (autoalojado en Clore.ai)

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

```
Ejemplo: sistema RAG de 1M de vectores
- Qdrant: servidor de 8 GB de RAM ~$0.10/h
- ChromaDB: servidor de 16 GB de RAM ~$0.15/h  
- Weaviate: servidor de 16 GB de RAM ~$0.15/h
- Milvus: servidor de 32 GB de RAM ~$0.30/h (+ sobrecarga para 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)
* [Benchmark de ANN](https://ann-benchmarks.com)
* [Benchmark de bases de datos vectoriales de Qdrant](https://qdrant.tech/benchmarks)

***

## Resumen

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

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

***

## Recomendaciones de GPU para Clore.ai

| Caso de uso        | GPU recomendada | Costo estimado en Clore.ai                |
| ------------------ | --------------- | ----------------------------------------- |
| Desarrollo/Pruebas | RTX 3090 (24GB) | $0.07–0.21/gpu/hr                         |
| Producción         | RTX 4090 (24GB) | $0.14–0.42/gpu/hr                         |
| Gran escala        | A100 80GB       | [bare metal](https://clore.ai/bare-metal) |

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.