Qdrant Has a Free API: A Vector Database Built in Rust for AI Applications

#ai #database #python #rust

Qdrant is a vector similarity search engine built in Rust. It stores and searches high-dimensional vectors for RAG, recommendation systems, and semantic search.

Why Qdrant Matters

AI applications need to find similar items — similar documents, images, products. Traditional databases cannot search by similarity. Qdrant is built for exactly this.

What you get for free:

Vector similarity search (cosine, dot product, Euclidean)
Payload filtering (combine vector search with metadata filters)
Built in Rust for maximum performance
Horizontal scaling with sharding
REST and gRPC APIs
Python, JS, Rust, Go clients
Free cloud tier (1GB, 1M vectors)
Docker deployment

Quick Start

# Docker
docker run -p 6333:6333 -p 6334:6334 qdrant/qdrant

# Or install locally
cargo install qdrant

Python Client

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

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

# Create collection
client.create_collection(
    collection_name="articles",
    vectors_config=VectorParams(size=384, distance=Distance.COSINE),
)

# Insert vectors (from embeddings)
client.upsert(
    collection_name="articles",
    points=[
        PointStruct(
            id=1,
            vector=[0.1, 0.2, ...],  # 384-dim embedding
            payload={"title": "Intro to AI", "category": "tech", "views": 1500},
        ),
        PointStruct(
            id=2,
            vector=[0.3, 0.1, ...],
            payload={"title": "ML Basics", "category": "tech", "views": 2300},
        ),
    ],
)

# Search similar
results = client.query_points(
    collection_name="articles",
    query=[0.15, 0.22, ...],  # Query vector
    limit=5,
)
for result in results.points:
    print(f"{result.payload['title']}: {result.score:.3f}")

# Search with filters
results = client.query_points(
    collection_name="articles",
    query=[0.15, 0.22, ...],
    query_filter=models.Filter(
        must=[
            models.FieldCondition(
                key="category", match=models.MatchValue(value="tech")
            ),
            models.FieldCondition(
                key="views", range=models.Range(gte=1000)
            ),
        ]
    ),
    limit=10,
)

RAG Pipeline

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("all-MiniLM-L6-v2")

# Index documents
documents = ["AI is transforming...", "Machine learning..."]
embeddings = model.encode(documents)

client.upsert(
    collection_name="knowledge",
    points=[
        PointStruct(id=i, vector=emb.tolist(), payload={"text": doc})
        for i, (doc, emb) in enumerate(zip(documents, embeddings))
    ],
)

# Query
query = "How does AI work?"
query_vector = model.encode(query).tolist()
results = client.query_points(
    collection_name="knowledge",
    query=query_vector,
    limit=3,
)
context = "\n".join([r.payload["text"] for r in results.points])
# Feed context to LLM for RAG

REST API

# Create collection
curl -X PUT http://localhost:6333/collections/articles \
  -H 'Content-Type: application/json' \
  -d '{"vectors": {"size": 384, "distance": "Cosine"}}'

# Search
curl -X POST http://localhost:6333/collections/articles/points/query \
  -H 'Content-Type: application/json' \
  -d '{"query": [0.1, 0.2, ...], "limit": 5}'

DEV Community