Todo RAG sério precisa de uma vector database. Qdrant (escrito em Rust) é a opção open-source mais rápida e produtiva: payload filtering em runtime, multi-tenancy, snapshots, escalável horizontalmente, gRPC + REST. No GPUBrasil, deploy em 1 clique.

⚡ Resumo

Qdrant supera Pinecone em latência e custo, supera ChromaDB em escala, e é open-source com licença Apache 2.0. Ideal para RAG corporativo brasileiro.

O que é o Qdrant?

Qdrant é um vector search engine criado em 2021 por Andrey Vasnetsov. Escrito em Rust, foca em performance, payload filtering e multi-tenancy. É usado por Cohere, Bayer, Hubspot e milhares de startups de IA.

Características principais

Casos de uso brasileiros

Hardware recomendado

Qdrant não precisa de GPU para a query, mas roda perfeitamente em qualquer template do GPUBrasil:

💰 Custo no GPUBrasil

RTX A4000 (R$ 1,80/h) hospedando Qdrant + 10M vetores em quantização int8: cabe em 16GB RAM. Para serviço 24x7: ~R$ 1.300/mês. Pinecone para mesmo volume: ~R$ 6.000/mês.

Deploy em 1 clique

Passo 1: Iniciar template

  1. Console → Templates → 📚 RAG & Knowledge
  2. Selecione Qdrant
  3. GPU: RTX A4000 (recomendado)
  4. Clique em Iniciar

O template usa qdrant/qdrant:latest, persiste storage em volume, expõe REST na porta 6333 e gRPC na 6334. Web UI dashboard em /dashboard.

Passo 2: Criar coleção

from qdrant_client import QdrantClient
from qdrant_client.models import VectorParams, Distance

client = QdrantClient(url="https://sua-instancia.gpubrasil.com.br")

# Criar coleção com vetores de 1024 dim (BGE-M3)
client.create_collection(
    collection_name="contratos",
    vectors_config=VectorParams(size=1024, distance=Distance.COSINE)
)

Passo 3: Upsert documentos com payload

from qdrant_client.models import PointStruct
from sentence_transformers import SentenceTransformer

emb_model = SentenceTransformer("BAAI/bge-m3")

docs = [
    {"id": 1, "text": "Cláusula de rescisão...", "cliente": "Acme", "ano": 2024},
    {"id": 2, "text": "Termo de confidencialidade...", "cliente": "Beta", "ano": 2025},
]

vectors = emb_model.encode([d["text"] for d in docs]).tolist()

client.upsert(
    collection_name="contratos",
    points=[
        PointStruct(id=d["id"], vector=v, payload=d)
        for d, v in zip(docs, vectors)
    ]
)

Passo 4: Busca com filtros

from qdrant_client.models import Filter, FieldCondition, MatchValue

query_vec = emb_model.encode("rescisão de contrato").tolist()

results = client.search(
    collection_name="contratos",
    query_vector=query_vec,
    query_filter=Filter(
        must=[
            FieldCondition(key="cliente", match=MatchValue(value="Acme")),
            FieldCondition(key="ano", match=MatchValue(value=2024))
        ]
    ),
    limit=5
)

for r in results:
    print(f"score={r.score:.3f} | {r.payload['text'][:80]}")

Passo 5: Hybrid search (dense + sparse)

# Combina embedding (semântico) + BM25 (keyword)
from qdrant_client.models import (
    SparseVector, NamedVector, NamedSparseVector
)

results = client.query_points(
    collection_name="contratos",
    prefetch=[
        # Dense vector retrieval
        models.Prefetch(
            query=dense_vec,
            using="dense",
            limit=20
        ),
        # Sparse (BM25) retrieval
        models.Prefetch(
            query=SparseVector(indices=[...], values=[...]),
            using="sparse",
            limit=20
        )
    ],
    # Reranking with reciprocal rank fusion
    query=models.FusionQuery(fusion=models.Fusion.RRF),
    limit=10
)

Multi-tenancy SaaS

Para SaaS B2B com isolamento por cliente:

# Estratégia: 1 coleção, payload com tenant_id
client.create_payload_index(
    collection_name="docs",
    field_name="tenant_id",
    field_schema=models.PayloadSchemaType.KEYWORD
)

# Inserir
client.upsert(
    collection_name="docs",
    points=[PointStruct(
        id=uuid4().int >> 64,
        vector=vec,
        payload={"tenant_id": "cliente_acme", "text": "..."}
    )]
)

# Buscar (sempre filtrar por tenant)
client.search(
    collection_name="docs",
    query_vector=q,
    query_filter=Filter(must=[
        FieldCondition(key="tenant_id", match=MatchValue(value="cliente_acme"))
    ])
)

Quantização para escala

# Reduz memória em 4x sem perder accuracy
client.update_collection(
    collection_name="contratos",
    quantization_config=models.ScalarQuantization(
        scalar=models.ScalarQuantizationConfig(
            type=models.ScalarType.INT8,
            quantile=0.99,
            always_ram=True
        )
    )
)

Snapshots e backup

# Criar snapshot
client.create_snapshot(collection_name="contratos")

# Listar
print(client.list_snapshots(collection_name="contratos"))

# Restaurar (em outra instância ou após desastre)
client.recover_snapshot(
    collection_name="contratos",
    location="https://outro-host/snapshots/snapshot-2026-05-20.snapshot"
)

Qdrant vs alternativas

Dicas de produção

Suba seu vector DB brasileiro em 90 segundos

Ganhe R$ 25 grátis no GPUBrasil e suba Qdrant em 1 clique.

Começar Grátis →

Conclusão

Qdrant é o vector DB open-source mais maduro para produção em 2026. Combinado com Marker/GROBID (ingestão), bge-m3 (embeddings) e vLLM (geração) no GPUBrasil, você monta um stack RAG nacional ponta a ponta — sem dependência de Pinecone, OpenAI ou qualquer fornecedor estrangeiro.

Stack RAG completo: AnythingLLM · vLLM · Marker