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 rápida de vecinos más cercanos aproximados (ANN) a través de miles de millones de vectores con filtrado avanzado, indexación de payload y soporte multivector. Es la base de muchos flujos de trabajo RAG (Generación Aumentada por Recuperación) en producción y aplicaciones de búsqueda semántica.

GitHub: qdrant/qdrant — 22K+ ⭐

---

¿Por qué Qdrant?

Función	Qdrant	Pinecone	Weaviate	Chroma
Código abierto	✅	❌	✅	✅
Rendimiento de Rust	✅	—	❌ Go	❌ Python
Filtrado en tiempo de consulta	✅ Avanzado	✅ Básico	✅	✅ Básico
Multivector	✅	❌	✅	❌
HNSW basado 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 de nivel C con seguridad de memoria. Las pruebas comparativas muestran que Qdrant es consistentemente 1,5–3 veces más rápido que alternativas basadas en Python como Chroma para 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 elementos similares mediante 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 imágenes/audio — recuperación multimodal

---

Requisitos previos

• Cuenta de Clore.ai con alquiler de GPU

• Familiaridad básica con APIs REST o Python

• Tu modelo de embeddings de elección (OpenAI, SentenceTransformers, etc.)

---

Paso 1 — Alquilar un servidor en Clore.ai

Qdrant depende principalmente de CPU/RAM para servir, pero se beneficia de GPU cuando:

• Generar 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 embeddings + servicio: RTX 3090/4090 con 32 GB+ 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 = 6 KB

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

• 10 millones de vectores = ~60 GB de RAM

• Habilita el almacenamiento en disco para colecciones muy grandes

---

Paso 2 — Implementar el contenedor de Qdrant

Imagen de 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 se está ejecutando

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

# Verificar que Qdrant se está ejecutando
curl http://localhost:6333/

# Respuesta esperada:
# {"title":"qdrant - motor de búsqueda vectorial","version":"..."}

# Comprobar el estado
curl http://localhost:6333/healthz

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

---

Paso 4 — Instalar el cliente de Python

# Instalar el cliente Python de Qdrant 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 dimensiones)
client.create_collection(
    collection_name="documents",
    vectors_config=VectorParams(
        size=1536,           # Dimensión del vector (debe coincidir con tu modelo de embeddings)
        distance=Distance.COSINE,  # Opciones: COSINE, EUCLID, DOT
        on_disk=False        # Establece 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 la construcción (más alto = mejor calidad, indexación más lenta)
        full_scan_threshold=10000  # Usar fuerza bruta por debajo de este número
    ),
    optimizers_config=OptimizersConfigDiff(
        indexing_threshold=20000  # Empezar 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 de 4x)
            quantile=0.99,
            always_ram=True        # Mantener el índice cuantizado en RAM
        )
    )
)

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

Colección para SentenceTransformers (384 dimensiones)

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="your-openai-api-key")

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": "documentación",
        "category": "base de datos",
        "year": 2024
    },
    {
        "id": str(uuid.uuid4()),
        "text": "Los modelos de aprendizaje automático convierten texto en representaciones vectoriales densas.",
        "source": "artículo",
        "category": "ml",
        "year": 2023
    },
    # Añadir más documentos...
]

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

# Hacer 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 se complete la indexación
)

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

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 el modelo de embeddings en la GPU
model = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")

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

documents = [
    {"text": "¿Cómo configuro Qdrant en un servidor GPU?", "tag": "configuración"},
    {"text": "Las bases de datos vectoriales almacenan embeddings de alta dimensión para búsqueda por similitud.", "tag": "concepto"},
    {"text": "El algoritmo HNSW proporciona búsqueda aproximada de vecinos más cercanos.", "tag": "algoritmo"},
    # ... 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 de 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 base de datos vectorial")
for r in results:
    print(f"Puntuación: {r.score:.4f} | {r.payload['text'][:100]}")

Búsqueda filtrada (metadatos + vector)

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

# Buscar 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/multiconsulta

from qdrant_client.models import SearchRequest

queries = [
    "how to install vector database",
    "machine learning inference optimization",
    "RAG pipeline architecture"
]

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

# Búsqueda por lotes (una llamada a la 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 — Crear una tubería 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="your-openai-key")

def rag_query(question: str, n_context: int = 5) -> str:
    # Paso 1: Convertir la pregunta en embedding
    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 la cadena de contexto
    context = "\n\n".join([
        f"[Fuente: {r.payload.get('source', 'unknown')}]\n{r.payload['text']}"
        for r in search_results
        if r.score > 0.5  # Filtrar resultados con baja confianza
    ])
    
    # Paso 4: Generar respuesta con el LLM
    response = llm.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "system",
                "content": "Responde a las 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 la tubería RAG
answer = rag_query("¿Qué es Qdrant y cómo funciona?")
print(answer)

---

Paso 9 — Supervisar y gestionar colecciones

# Estadísticas de la colección
info = client.get_collection("documents")
print(f"Cantidad de vectores: {info.vectors_count:,}")
print(f"Cantidad 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 la 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

# Verificar que Qdrant se está ejecutando
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 los parámetros de HNSW para mejor recall
client.update_collection(
    collection_name="documents",
    hnsw_config=HnswConfigDiff(ef=128)  # Aumentar ef en tiempo de búsqueda (predeterminado 100)
)

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

Uso elevado 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	Costo mensual	Capacidad
RAG pequeño	RTX 3090, 32GB RAM	~$60–80	~5M vectores
Búsqueda media	RTX 4090, 64GB RAM	~$120–150	~15M vectores
A gran escala	A100, 128GB RAM	~$250–350	~30M vectores

---

Recursos adicionales

• Documentación de Qdrant

• GitHub de Qdrant

• Cliente Python de Qdrant

• Ejemplos de Qdrant

• Puntos de referencia de bases de datos vectoriales

• Sentence Transformers

---

Qdrant en Clore.ai te ofrece una base de datos vectorial de alto rendimiento y autohospedada, sin los costos por consulta de Pinecone o Weaviate Cloud. Perfecta para canalizaciones de RAG que procesan millones de documentos.

---

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
Búsqueda vectorial en producción	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
Embeddings de alto rendimiento	RTX 4090 (24GB)	$0.14–0.42/gpu/hr

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