Qdrant

Base de datos vectorial de alto rendimiento para búsqueda semántica y aplicaciones RAG: indexación acelerada por GPU

Qdrant es una base de datos vectorial de código abierto y lista para producción escrita en Rust. Ofrece búsqueda aproximada de vecinos más cercanos (ANN) rápida en miles de millones de vectores con filtrado avanzado, indexación de payload y soporte multivector. Es la columna vertebral de muchos pipelines RAG (Generación Aumentada por Recuperación) y aplicaciones de búsqueda semántica en producción.

GitHub: qdrant/qdrant — 22K+ ⭐

---

¿Por qué Qdrant?

Característica	Qdrant	Pinecone	Weaviate	Chroma
Código abierto	✅	❌	✅	✅
Rendimiento de Rust	✅	—	❌ Go	❌ Python
Filtrado en tiempo de consulta	✅ Avanzado	✅ Básico	✅	✅ Básico
Multivector	✅	❌	✅	❌
HNSW en disco	✅	✅	✅	❌
Indexación de payload	✅	Limitado	✅	Limitado
gRPC + REST	✅ Ambos	✅ REST	✅	REST
Autoalojado	✅	❌ Solo en la nube	✅	✅

Qdrant está escrito en Rust — ofreciendo rendimiento a nivel de C con seguridad de memoria. Las pruebas de benchmark muestran que Qdrant es consistentemente 1.5–3x más rápido que alternativas basadas en Python como Chroma en escenarios de alta carga.

---

Casos de uso clave

• RAG (Generación Aumentada por Recuperación) — encontrar contexto relevante para prompts de LLM

• Búsqueda semántica — buscar por significado, no solo por palabras clave

• Sistemas de recomendación — encontrar ítems similares por similitud de embeddings

• Detección de duplicados — identificar contenido casi duplicado

• Detección de anomalías — encontrar vectores alejados de los centros de los clústeres

• Búsqueda de similitud de imagen/audio — recuperación multimodal

---

Prerrequisitos

• Cuenta en Clore.ai con alquiler de GPU

• Familiaridad básica con APIs REST o Python

• Su modelo de embeddings preferido (OpenAI, SentenceTransformers, etc.)

---

Paso 1 — Alquilar un servidor en Clore.ai

Qdrant está principalmente limitado por CPU/RAM para el servicio, pero se beneficia de GPU cuando:

• Se generan embeddings junto con el servicio (modelo de embeddings en el mismo servidor)

• Operaciones de indexación por lotes a gran escala

1. Ve a clore.ai → Marketplace

2. Para combinación de embeddings + servicio: RTX 3090/4090 con 32GB+ de RAM

3. Para solo servicio: Servidor optimizado para CPU con almacenamiento NVMe rápido

Planificación de memoria:

• Cada vector float32 con 1536 dimensiones = 6KB

• 1 millón de vectores = ~6GB de RAM

• 10 millones de vectores = ~60GB de RAM

• Habilite almacenamiento en disco para colecciones muy grandes

---

Paso 2 — Desplegar el contenedor Qdrant

Imagen Docker:

qdrant/qdrant:latest

Puertos:

22
6333
6334

• Puerto 6333: API REST (HTTP)

• Puerto 6334: API gRPC (mayor rendimiento para operaciones en lote)

Variables de entorno:

QDRANT__SERVICE__HTTP_PORT=6333
QDRANT__SERVICE__GRPC_PORT=6334
QDRANT__LOG_LEVEL=INFO
QDRANT__STORAGE__STORAGE_PATH=/qdrant/storage

Volumen/Almacenamiento persistente: Montar /qdrant/storage para la persistencia de datos. Sin esto, los datos se pierden al reiniciar el contenedor.

---

Paso 3 — Verificar que Qdrant está en ejecución

ssh root@<ip-del-servidor> -p <puerto-ssh>

# Comprobar que Qdrant está en ejecución
curl http://localhost:6333/

# Respuesta esperada:
# {"title":"qdrant - vector search engine","version":"..."}

# Comprobar estado de salud
curl http://localhost:6333/healthz

# Comprobar información del clúster
curl http://localhost:6333/cluster

---

Paso 4 — Instalar el cliente de Python

# Instalar el cliente Qdrant para Python y herramientas de embeddings
pip install qdrant-client sentence-transformers openai numpy

# Verificar conexión
python3 << 'EOF'
from qdrant_client import QdrantClient

client = QdrantClient("localhost", port=6333)
print(f"Qdrant conectado: {client.get_collections()}")
EOF

---

Paso 5 — Crear una colección

Una colección es un grupo nombrado de vectores con una dimensionalidad fija.

from qdrant_client import QdrantClient
from qdrant_client.models import (
    Distance,
    VectorParams,
    HnswConfigDiff,
    OptimizersConfigDiff,
    QuantizationConfig,
    ScalarQuantizationConfig,
    ScalarType
)

client = QdrantClient("localhost", port=6333)

# Crear colección para OpenAI text-embedding-3-small (1536 dims)
client.create_collection(
    collection_name="documents",
    vectors_config=VectorParams(
        size=1536,           # Dimensión del vector (coincida con su modelo de embeddings)
        distance=Distance.COSINE,  # Opciones: COSINE, EUCLID, DOT
        on_disk=False        # Poner True para colecciones muy grandes
    ),
    hnsw_config=HnswConfigDiff(
        m=16,                # Conectividad del grafo HNSW (más alto = mejor recall, más RAM)
        ef_construct=100,    # Profundidad de búsqueda en tiempo de construcción (más alto = mejor calidad, indexación más lenta)
        full_scan_threshold=10000  # Usar fuerza bruta por debajo de este recuento
    ),
    optimizers_config=OptimizersConfigDiff(
        indexing_threshold=20000  # Iniciar la indexación HNSW después de esta cantidad de vectores
    ),
    quantization_config=QuantizationConfig(
        scalar=ScalarQuantizationConfig(
            type=ScalarType.INT8,  # Comprimir vectores a INT8 (reducción de memoria 4x)
            quantile=0.99,
            always_ram=True        # Mantener el índice cuantizado en RAM
        )
    )
)

print("¡Colección creada!")
print(client.get_collection("documents"))

Colección para SentenceTransformers (384 dims)

client.create_collection(
    collection_name="embeddings_384",
    vectors_config=VectorParams(
        size=384,              # tamaño de salida de all-MiniLM-L6-v2
        distance=Distance.COSINE
    )
)

---

Paso 6 — Indexar documentos

Con OpenAI Embeddings

from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct
from openai import OpenAI
import uuid

client = QdrantClient("localhost", port=6333)
openai_client = OpenAI(api_key="tu-clave-openai")

def get_embeddings(texts: list[str], batch_size: int = 100) -> list[list[float]]:
    """Generar embeddings por lotes."""
    all_embeddings = []
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        response = openai_client.embeddings.create(
            model="text-embedding-3-small",
            input=batch
        )
        all_embeddings.extend([e.embedding for e in response.data])
    return all_embeddings

# Documentos de ejemplo
documents = [
    {
        "id": str(uuid.uuid4()),
        "text": "Qdrant es una base de datos vectorial construida en Rust para alto rendimiento.",
        "source": "documentation",
        "category": "database",
        "year": 2024
    },
    {
        "id": str(uuid.uuid4()),
        "text": "Los modelos de aprendizaje automático convierten el texto en representaciones vectoriales densas.",
        "source": "article",
        "category": "ml",
        "year": 2023
    },
    # Añadir más documentos...
]

# Generar embeddings
texts = [doc["text"] for doc in documents]
embeddings = get_embeddings(texts)

# Upsert en Qdrant
points = [
    PointStruct(
        id=str(uuid.uuid4()),
        vector=embedding,
        payload={
            "text": doc["text"],
            "source": doc["source"],
            "category": doc["category"],
            "year": doc["year"]
        }
    )
    for doc, embedding in zip(documents, embeddings)
]

client.upsert(
    collection_name="documents",
    points=points,
    wait=True  # Esperar a que la indexación se complete
)

print(f"¡Indexados {len(points)} documentos!")

Con SentenceTransformers (Local, acelerado por GPU)

from sentence_transformers import SentenceTransformer
from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct
import torch
import uuid

# Cargar modelo de embeddings en GPU
model = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")

client = QdrantClient("localhost", port=6333)

documents = [
    {"text": "¿Cómo configuro Qdrant en un servidor con GPU?", "tag": "setup"},
    {"text": "Las bases de datos vectoriales almacenan embeddings de alta dimensión para búsqueda por similitud.", "tag": "concept"},
    {"text": "El algoritmo HNSW proporciona búsqueda aproximada de vecinos más cercanos.", "tag": "algorithm"},
    # ... más documentos
]

# Codificación por lotes acelerada por GPU
texts = [doc["text"] for doc in documents]
embeddings = model.encode(
    texts,
    batch_size=256,       # Tamaño de lote grande para eficiencia en GPU
    show_progress_bar=True,
    normalize_embeddings=True  # Normalizar para similitud coseno
)

# Indexar en Qdrant
points = [
    PointStruct(
        id=str(uuid.uuid4()),
        vector=embedding.tolist(),
        payload=doc
    )
    for doc, embedding in zip(documents, embeddings)
]

# Upsert por lotes (más eficiente)
BATCH_SIZE = 1000
for i in range(0, len(points), BATCH_SIZE):
    batch = points[i:i + BATCH_SIZE]
    client.upsert(collection_name="embeddings_384", points=batch)
    print(f"Indexados {min(i + BATCH_SIZE, len(points))}/{len(points)}")

---

Paso 7 — Buscar y consultar

Búsqueda semántica básica

from qdrant_client import QdrantClient
from sentence_transformers import SentenceTransformer

client = QdrantClient("localhost", port=6333)
model = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")

def search(query: str, limit: int = 5, collection: str = "embeddings_384"):
    # Generar embedding de la consulta
    query_vector = model.encode(query, normalize_embeddings=True).tolist()
    
    # Buscar
    results = client.search(
        collection_name=collection,
        query_vector=query_vector,
        limit=limit,
        with_payload=True,
        with_vectors=False    # No devolver vectores (ahorra ancho de banda)
    )
    
    return results

# Probar búsqueda
results = search("rendimiento de bases de datos vectoriales")
for r in results:
    print(f"Score: {r.score:.4f} | {r.payload['text'][:100]}")

Búsqueda filtrada (Metadatos + Vector)

from qdrant_client.models import Filter, FieldCondition, MatchValue, Range

# Búsqueda con filtros de metadatos
results = client.search(
    collection_name="documents",
    query_vector=query_vector,
    query_filter=Filter(
        must=[
            FieldCondition(
                key="category",
                match=MatchValue(value="database")
            ),
            FieldCondition(
                key="year",
                range=Range(gte=2023)  # Año >= 2023
            )
        ]
    ),
    limit=10,
    with_payload=True
)

Búsqueda por lotes/múltiples consultas

from qdrant_client.models import SearchRequest

queries = [
    "cómo instalar una base de datos vectorial",
    "optimización de inferencia en aprendizaje automático",
    "arquitectura de pipeline RAG"
]

query_vectors = model.encode(queries, normalize_embeddings=True)

# Búsqueda por lotes (una llamada API para todas las consultas)
results = client.search_batch(
    collection_name="embeddings_384",
    requests=[
        SearchRequest(
            vector=vec.tolist(),
            limit=5,
            with_payload=True
        )
        for vec in query_vectors
    ]
)

for query, res in zip(queries, results):
    print(f"\nConsulta: {query}")
    for r in res:
        print(f"  {r.score:.3f}: {r.payload['text'][:80]}")

---

Paso 8 — Construir un pipeline RAG

from qdrant_client import QdrantClient
from sentence_transformers import SentenceTransformer
from openai import OpenAI

# Inicializar clientes
qdrant = QdrantClient("localhost", port=6333)
embedder = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")
llm = OpenAI(api_key="tu-clave-openai")

def rag_query(question: str, n_context: int = 5) -> str:
    # Paso 1: Embedding de la pregunta
    query_vector = embedder.encode(question, normalize_embeddings=True).tolist()
    
    # Paso 2: Recuperar contexto relevante de Qdrant
    search_results = qdrant.search(
        collection_name="documents",
        query_vector=query_vector,
        limit=n_context,
        with_payload=True
    )
    
    # Paso 3: Construir cadena de contexto
    context = "\n\n".join([
        f"[Fuente: {r.payload.get('source', 'desconocida')}]\n{r.payload['text']}"
        for r in search_results
        if r.score > 0.5  # Filtrar resultados de baja confianza
    ])
    
    # Paso 4: Generar respuesta con LLM
    response = llm.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "system",
                "content": "Responde preguntas basándote en el contexto proporcionado. Sé conciso y preciso."
            },
            {
                "role": "user",
                "content": f"Contexto:\n{context}\n\nPregunta: {question}"
            }
        ],
        temperature=0.1
    )
    
    return response.choices[0].message.content

# Probar pipeline RAG
answer = rag_query("¿Qué es Qdrant y cómo funciona?")
print(answer)

---

Paso 9 — Monitorizar y gestionar colecciones

# Estadísticas de la colección
info = client.get_collection("documents")
print(f"Recuento de vectores: {info.vectors_count:,}")
print(f"Recuento de puntos: {info.points_count:,}")
print(f"Vectores indexados: {info.indexed_vectors_count:,}")
print(f"Estado: {info.status}")
print(f"Uso de disco: {info.disk_data_size / 1024 / 1024:.1f} MB")

# Listar todas las colecciones
collections = client.get_collections()
for c in collections.collections:
    print(f" - {c.name}")

# Eliminar puntos por filtro
client.delete(
    collection_name="documents",
    points_selector=Filter(
        must=[FieldCondition(key="source", match=MatchValue(value="old_source"))]
    )
)

# Optimizar colección (forzar construcción del índice)
client.update_collection(
    collection_name="documents",
    optimizer_config=OptimizersConfigDiff(indexing_threshold=0)  # Forzar indexación inmediata
)

---

Solución de problemas

Conexión rechazada

# Comprobar que Qdrant está en ejecución
docker ps | grep qdrant
# O comprobar el proceso
ps aux | grep qdrant

# Comprobar que los puertos están abiertos
curl http://localhost:6333/
netstat -tlnp | grep 6333

Rendimiento de búsqueda lento

# Optimizar parámetros HNSW para mejor recall
client.update_collection(
    collection_name="documents",
    hnsw_config=HnswConfigDiff(ef=128)  # Aumentar ef en tiempo de búsqueda (por defecto 100)
)

# Usar cuantización INT8 para ajustar más vectores en RAM

Alto uso de memoria

# Habilitar almacenamiento en disco para colecciones grandes
client.create_collection(
    collection_name="large_collection",
    vectors_config=VectorParams(
        size=1536,
        distance=Distance.COSINE,
        on_disk=True  # Almacenar vectores en disco en lugar de RAM
    )
)

---

Referencia rápida de la API REST

# Listar colecciones
curl http://localhost:6333/collections

# Crear colección
curl -X PUT http://localhost:6333/collections/my_collection \
    -H "Content-Type: application/json" \
    -d '{"vectors": {"size": 384, "distance": "Cosine"}}'

# Contar puntos
curl http://localhost:6333/collections/my_collection/points/count

# Buscar
curl -X POST http://localhost:6333/collections/my_collection/points/search \
    -H "Content-Type: application/json" \
    -d '{
        "vector": [0.1, 0.2, ...],
        "limit": 5,
        "with_payload": true
    }'

# Eliminar colección
curl -X DELETE http://localhost:6333/collections/my_collection

---

Estimación de costos en Clore.ai

Configuración	Servidor	Coste mensual	Capacidad
RAG pequeño	RTX 3090, 32GB RAM	~$60–80	~5M vectores
Búsqueda mediana	RTX 4090, 64GB RAM	~$120–150	~15M vectores
Gran escala	A100, 128GB RAM	~$250–350	~30M vectores

---

Recursos adicionales

• Documentación de Qdrant

• Qdrant en GitHub

• Cliente de Python de Qdrant

• Ejemplos de Qdrant

• Benchmarks de bases de datos vectoriales

• Sentence Transformers

---

Qdrant en Clore.ai te ofrece una base de datos vectorial autoalojada y de alto rendimiento sin los costes por consulta de Pinecone o Weaviate Cloud. Perfecto para pipelines RAG que procesan millones de documentos.

---

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
Búsqueda vectorial en producción	RTX 3090 (24GB)	~$0.12/gpu/hr
Embeddings de alto rendimiento	RTX 4090 (24GB)	~$0.70/gpu/hr

💡 Todos los ejemplos en esta guía pueden desplegarse en Clore.ai servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.