Qdrant

🔟 Basic Questions to Understand Qdrant and Vector Databases

1. What is a vector database, and how is it different from a traditional relational database?

2. What are embeddings, and why are they important in vector databases?

3. What is Qdrant, and what makes it suitable for vector similarity search?

4. How does Qdrant store and organize vector data internally?

5. What is Approximate Nearest Neighbor (ANN) search, and how does Qdrant implement it?

6. How do you insert (upsert) vector data into Qdrant, and what is a collection?

7. How does Qdrant handle metadata filtering along with vector search?

8. What are some common use cases of Qdrant (e.g., semantic search, recommendation systems, etc.)?

9. How can Qdrant be integrated with OpenAI, Hugging Face, or other embedding models?

10. What are the deployment options for Qdrant (self-hosted, Docker, cloud)?

---

Perfect! Here’s an easy-to-understand breakdown of those 10 basic questions with beginner-friendly answers and some practical examples where needed:

---

1. What is a vector database, and how is it different from a traditional relational database?

A vector database stores and searches high-dimensional vectors (embeddings) rather than rows and columns like traditional relational databases (e.g., MySQL).

• Traditional DB: name = 'Ivy', age = 27

• Vector DB: embedding = [0.25, -0.91, 0.03, ..., 0.67] (e.g., a 768-dimensional vector)

➡️ Used for: Searching semantic meaning, not exact values.

---

2. What are embeddings, and why are they important in vector databases?

Embeddings are numerical representations of data (text, images, etc.) created using AI models. They help machines understand the semantic meaning of content.

• Example:

  • "dog" → [0.1, 0.7, ...]

  • "puppy" → similar vector

  • "car" → very different vector

➡️ These embeddings are what you store in a vector DB like Qdrant for similarity search.

---

3. What is Qdrant, and what makes it suitable for vector similarity search?

Qdrant is an open-source vector search engine built for real-time, efficient, and scalable semantic search.

✅ Key strengths:

• Fast ANN (Approximate Nearest Neighbor) search

• Rich metadata filtering

• REST & gRPC APIs

• Integration with Python, JS, etc.

---

4. How does Qdrant store and organize vector data internally?

Qdrant organizes data into collections. Each collection holds:

• Vectors

• Optional metadata (payload)

• Optional vector names if you use multiple embeddings per record

Structure example:

{
  "id": "doc123",
  "vector": [0.23, 0.56, ...],
  "payload": {
    "title": "AI for Lawyers",
    "tags": ["legaltech", "AI"]
  }
}

---

5. What is Approximate Nearest Neighbor (ANN) search, and how does Qdrant implement it?

ANN search finds "close enough" vectors without scanning everything, making it super fast.

Qdrant uses HNSW (Hierarchical Navigable Small World graphs) – a fast and accurate graph-based algorithm to find similar vectors quickly.

➡️ Think of it like GPS for ideas: "find me texts close in meaning to this one."

---

6. How do you insert (upsert) vector data into Qdrant, and what is a collection?

To insert data:

• Create a collection first.

• Use the upsert API to insert vectors with optional metadata.

Example:

POST /collections/my_docs/points
{
  "points": [
    {
      "id": "doc1",
      "vector": [0.1, 0.2, ..., 0.9],
      "payload": {
        "title": "Intro to Qdrant"
      }
    }
  ]
}

---

7. How does Qdrant handle metadata filtering along with vector search?

You can filter by metadata (payload) while doing similarity search.

Example:

"Find similar documents about AI that are also tagged legaltech"

"filter": {
  "must": [
    {
      "key": "tags",
      "match": { "value": "legaltech" }
    }
  ]
}

---

8. What are some common use cases of Qdrant?

• Semantic Search: Search by meaning instead of keyword.

• Recommendation Engines: "You might also like…" based on vector similarity.

• Chatbots / RAG: Retrieve relevant info from a vector DB to answer user questions.

• Image / Video Search: Find visually similar items.

---

9. How can Qdrant be integrated with OpenAI, Hugging Face, or other embedding models?

✅ Common flow:

1. Use OpenAI or Hugging Face to convert text → embeddings.

2. Store them in Qdrant.

3. At query time, embed the query → search → return top similar results.

Example using OpenAI:

embedding = openai.Embedding.create(input="AI for lawyers")
qdrant_client.search(collection_name="docs", vector=embedding, ...)

---

10. What are the deployment options for Qdrant (self-hosted, Docker, cloud)?

You can run Qdrant:

• Self-hosted (on your server)

• Docker (most popular)

• Qdrant Cloud (managed service)

➡️ Ideal for fast prototyping: docker run -p 6333:6333 qdrant/qdrant

---

Awesome! Let’s walk through a simple example using OpenAI embeddings + Qdrant with Python. We’ll simulate a basic semantic search system, like searching through documents or FAQs.

---

🧪 Use Case: Semantic Search with OpenAI + Qdrant

Goal: You want to store text data (like FAQ answers or article snippets), embed them using OpenAI, store in Qdrant, and search semantically.

---

✅ Prerequisites

Install these:

pip install openai qdrant-client

---

⚙️ Step 1: Setup OpenAI + Qdrant Clients

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

# Set your OpenAI API key
openai.api_key = "your-openai-key"

# Connect to Qdrant (Docker localhost or Qdrant Cloud)
qdrant = QdrantClient(host="localhost", port=6333)  # adjust if cloud

# Create a collection
qdrant.recreate_collection(
    collection_name="my_faqs",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
)

---

📌 Step 2: Add Some Text Data

Let’s embed 3 small docs using OpenAI and store them.

def get_embedding(text):
    response = openai.Embedding.create(
        model="text-embedding-3-small",
        input=text
    )
    return response['data'][0]['embedding']

docs = [
    {"id": 1, "text": "How to reset my password?"},
    {"id": 2, "text": "What is Qdrant used for?"},
    {"id": 3, "text": "How can I integrate OpenAI with Python?"}
]

# Embed and insert into Qdrant
qdrant.upsert(
    collection_name="my_faqs",
    points=[
        {
            "id": doc["id"],
            "vector": get_embedding(doc["text"]),
            "payload": {"text": doc["text"]}
        }
        for doc in docs
    ]
)

---

🔍 Step 3: Perform a Semantic Search

Now, let’s query something similar in meaning (but phrased differently).

query = "How do I connect ChatGPT with my Python app?"
query_vector = get_embedding(query)

search_results = qdrant.search(
    collection_name="my_faqs",
    query_vector=query_vector,
    limit=3
)

for hit in search_results:
    print(f"[Score: {hit.score:.2f}] {hit.payload['text']}")

---

📦 Output Example

[Score: 0.91] How can I integrate OpenAI with Python?
[Score: 0.55] What is Qdrant used for?
[Score: 0.30] How to reset my password?

---

🔁 Bonus: Add Metadata Filtering

Add tags to payloads:

"payload": {
  "text": doc["text"],
  "category": "integration"
}

Then filter on them:

from qdrant_client.models import Filter, FieldCondition, MatchValue

search_results = qdrant.search(
    collection_name="my_faqs",
    query_vector=query_vector,
    limit=3,
    query_filter=Filter(
        must=[
            FieldCondition(
                key="category",
                match=MatchValue(value="integration")
            )
        ]
    )
)

---

Nice! Since you're interested in FastAPI + Jinja + PDF + Qdrant + OpenAI, I’ll guide you through building a mini web app that:

---

🧩 Use Case: Upload PDFs → Extract & Embed Content → Store in Qdrant → Semantic Search via UI

---

🛠️ Tech Stack:

• FastAPI – web backend

• Jinja2 – HTML templating

• PyMuPDF – for PDF text extraction

• OpenAI – for generating embeddings

• Qdrant – for vector search

• Weaviate alternative – using Qdrant instead

---

🔧 Step-by-step Architecture:

1. 📄 Upload PDF(s) via a Jinja-based form

2. 📤 Extract text from each PDF (via fitz)

3. 🧠 Convert text to embeddings using OpenAI

4. 🧊 Store embeddings in Qdrant with metadata

5. 🔍 Accept search queries and return semantically similar chunks

---

from fastapi import FastAPI, UploadFile, Form, Request
from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
import fitz  # PyMuPDF
import openai
from qdrant_client import QdrantClient
from qdrant_client.models import VectorParams, Distance
import uuid
import os
from dotenv import load_dotenv

load_dotenv()

app = FastAPI()
app.mount("/static", StaticFiles(directory="static"), name="static")
templates = Jinja2Templates(directory="templates")

# Set your OpenAI API key
openai.api_key = os.getenv("OPENAI_API_KEY")

# Connect to Qdrant
qdrant = QdrantClient(host=os.getenv("QDRANT_HOST", "qdrant"), port=int(os.getenv("QDRANT_PORT", 6333)))
qdrant.recreate_collection(
    collection_name="pdf_chunks",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
)


def embed_text(text):
    response = openai.Embedding.create(
        model="text-embedding-3-small",
        input=text
    )
    return response["data"][0]["embedding"]


def extract_chunks_from_pdf(file):
    doc = fitz.open(stream=file.file.read(), filetype="pdf")
    chunks = []
    for page in doc:
        text = page.get_text()
        if text.strip():
            chunks.append(text.strip())
    return chunks


@app.get("/", response_class=HTMLResponse)
async def index(request: Request):
    return templates.TemplateResponse("index.html", {"request": request})


@app.post("/upload")
async def upload_pdf(request: Request, file: UploadFile):
    chunks = extract_chunks_from_pdf(file)
    qdrant_points = []
    for chunk in chunks:
        vector = embed_text(chunk)
        qdrant_points.append({
            "id": str(uuid.uuid4()),
            "vector": vector,
            "payload": {"text": chunk, "source": file.filename}
        })

    qdrant.upsert(collection_name="pdf_chunks", points=qdrant_points)
    return templates.TemplateResponse("index.html", {"request": request, "message": "PDF uploaded and embedded."})


@app.post("/search")
async def search(request: Request, query: str = Form(...)):
    vector = embed_text(query)
    results = qdrant.search(collection_name="pdf_chunks", query_vector=vector, limit=5)
    matches = [hit.payload for hit in results]
    return templates.TemplateResponse("index.html", {
        "request": request,
        "results": matches,
        "query": query
    })

Awesome! I’ve created your core FastAPI app with Jinja2 frontend support to handle:

• ✅ PDF uploads

• ✅ Text chunk extraction

• ✅ OpenAI embedding

• ✅ Storing vectors in Qdrant

• ✅ Semantic search with user queries

🗂️ You’ll need:

1. A templates/index.html file:

Would you like me to generate that next (with file upload, search form, and results display)?

2. Local Qdrant running:

docker run -p 6333:6333 qdrant/qdrant

3. requirements.txt:

fastapi
jinja2
uvicorn
qdrant-client
openai
PyMuPDF

Let me know if you'd like:

• The index.html UI template,

• Deployment instructions (e.g., Docker, Render),

• Or any API key handling tips (e.g., dotenv).

---

Docker compose

from fastapi import FastAPI, UploadFile, Form, Request
from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
import fitz  # PyMuPDF
import openai
from qdrant_client import QdrantClient
from qdrant_client.models import VectorParams, Distance
import uuid
import os
from dotenv import load_dotenv

load_dotenv()

app = FastAPI()
app.mount("/static", StaticFiles(directory="static"), name="static")
templates = Jinja2Templates(directory="templates")

# Set your OpenAI API key
openai.api_key = os.getenv("OPENAI_API_KEY")

# Connect to Qdrant
qdrant = QdrantClient(host=os.getenv("QDRANT_HOST", "qdrant"), port=int(os.getenv("QDRANT_PORT", 6333)))
qdrant.recreate_collection(
    collection_name="pdf_chunks",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
)


def embed_text(text):
    response = openai.Embedding.create(
        model="text-embedding-3-small",
        input=text
    )
    return response["data"][0]["embedding"]


def extract_chunks_from_pdf(file):
    doc = fitz.open(stream=file.file.read(), filetype="pdf")
    chunks = []
    for page in doc:
        text = page.get_text()
        if text.strip():
            chunks.append(text.strip())
    return chunks


@app.get("/", response_class=HTMLResponse)
async def index(request: Request):
    return templates.TemplateResponse("index.html", {"request": request})


@app.post("/upload")
async def upload_pdf(request: Request, file: UploadFile):
    chunks = extract_chunks_from_pdf(file)
    qdrant_points = []
    for chunk in chunks:
        vector = embed_text(chunk)
        qdrant_points.append({
            "id": str(uuid.uuid4()),
            "vector": vector,
            "payload": {"text": chunk, "source": file.filename}
        })

    qdrant.upsert(collection_name="pdf_chunks", points=qdrant_points)
    return templates.TemplateResponse("index.html", {"request": request, "message": "PDF uploaded and embedded."})


@app.post("/search")
async def search(request: Request, query: str = Form(...)):
    vector = embed_text(query)
    results = qdrant.search(collection_name="pdf_chunks", query_vector=vector, limit=5)
    matches = [hit.payload for hit in results]
    return templates.TemplateResponse("index.html", {
        "request": request,
        "results": matches,
        "query": query
    })

Here you go!

---

🖼️ templates/index.html

Create a folder named templates/ and add this file inside it:

<!DOCTYPE html>
<html>
<head>
    <title>PDF Semantic Search</title>
</head>
<body>
    <h1>📄 PDF Semantic Search</h1>

    {% if message %}
    <p><strong>{{ message }}</strong></p>
    {% endif %}

    <h2>Upload PDF</h2>
    <form action="/upload" method="post" enctype="multipart/form-data">
        <input type="file" name="file" required>
        <button type="submit">Upload</button>
    </form>

    <h2>Search</h2>
    <form action="/search" method="post">
        <input type="text" name="query" placeholder="Enter your question..." value="{{ query or '' }}" required>
        <button type="submit">Search</button>
    </form>

    {% if results %}
        <h3>🔍 Search Results:</h3>
        <ul>
            {% for item in results %}
                <li><strong>{{ item.source }}:</strong> {{ item.text }}</li>
            {% endfor %}
        </ul>
    {% endif %}
</body>
</html>

---

🐳 docker-compose.yml

Here’s a simple docker-compose.yml file to run both your FastAPI app and Qdrant:

version: "3.8"

services:
  qdrant:
    image: qdrant/qdrant
    ports:
      - "6333:6333"

  app:
    build: .
    ports:
      - "8000:8000"
    environment:
      - OPENAI_API_KEY=your-openai-key
      - QDRANT_HOST=qdrant
      - QDRANT_PORT=6333
    depends_on:
      - qdrant

---

🐍 Dockerfile

Add this to your root folder to build your FastAPI app container:

FROM python:3.10-slim

WORKDIR /app

COPY . /app

RUN pip install --upgrade pip && \
    pip install -r requirements.txt

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

---

📦 requirements.txt

fastapi
jinja2
uvicorn
python-multipart
qdrant-client
openai
PyMuPDF
python-dotenv

---

✅ Next Steps

1. Add your .env file (or replace the OPENAI_API_KEY in docker-compose.yml)

2. Build and run:

docker-compose up --build

Visit: http://localhost:8000

---

Great! Focusing on collections and points (not pointers 😉) in Qdrant is a smart move—these are the building blocks of how data is stored and searched. Let’s break them down clearly:

---

📚 1. What is a Collection in Qdrant?

A collection in Qdrant is like a table in a relational database.

Each collection:

• Holds a group of vectors

• Has a specific vector size (e.g., 1536 for OpenAI)

• Uses a particular distance metric (Cosine, Dot, Euclidean)

• Can include payloads (i.e., metadata like titles, tags, etc.)

✅ Example:

qdrant.recreate_collection(
    collection_name="products",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
)

➡️ This sets up a collection to store vectors of length 1536 and use cosine similarity.

---

📍 2. What is a Point in Qdrant?

A point is a single item stored in a collection. Think of it as a row in a database table.

Each point has:

• A unique ID (can be int or UUID string)

• A vector

• An optional payload (metadata)

✅ Point Example:

{
  "id": "123abc",
  "vector": [0.1, 0.2, ..., 0.9],
  "payload": {
    "title": "Intro to Qdrant",
    "category": "AI"
  }
}

You can insert/update a point using upsert:

qdrant.upsert(
    collection_name="products",
    points=[
        {
            "id": "123abc",
            "vector": some_vector,
            "payload": {"name": "ChatGPT Mug", "category": "merch"}
        }
    ]
)

---

🔄 3. How Do You Update Points?

Use the same upsert function. If the point id already exists, it updates the vector and payload.

Want to update only payload?

qdrant.set_payload(
    collection_name="products",
    payload={"in_stock": True},
    points=["123abc"]
)

---

❌ 4. How to Delete Points or Collections?

Delete a specific point:

qdrant.delete(collection_name="products", points=["123abc"])

Delete a whole collection:

qdrant.delete_collection(collection_name="products")

---

🎯 5. Search in a Collection

You always search within a collection. Here's how:

qdrant.search(
    collection_name="products",
    query_vector=query_vector,
    limit=5
)

You can also filter by payload:

query_filter=Filter(
    must=[
        FieldCondition(
            key="category",
            match=MatchValue(value="merch")
        )
    ]
)

---

🛠️ Common Qdrant Terms Recap

Term	Meaning
Collection	A named group of vectors (like a table)
Point	A vector + payload + ID (like a row)
Payload	Metadata attached to a point
Upsert	Insert or update a point
Vector	Embedding used for similarity search
Distance	Similarity function (Cosine, Dot, etc.)

---

Would you like me to generate code examples to:

• Handle multiple collections (e.g., per user or file)?

• Add namespaces or filters for search?

• Automatically check if a collection exists before creating?

Let me know where you want to go deeper 🔍

---

Yes, you absolutely can put multiple users’ embeddings into a single collection in Qdrant — and it’s actually a common pattern in many applications like:

• Multi-user semantic search

• Multi-tenant apps

• Chatbots with shared backends

But how you do it matters, especially if you want to isolate or query them per user.

---

✅ Recommended Pattern

Store all embeddings in one collection, and use the payload to differentiate users.

Example: Two users uploading documents

qdrant.upsert(
    collection_name="pdf_chunks",
    points=[
        {
            "id": "abc1",
            "vector": user1_vector,
            "payload": {
                "user_id": "user_1",
                "text": "Some text from user 1"
            }
        },
        {
            "id": "abc2",
            "vector": user2_vector,
            "payload": {
                "user_id": "user_2",
                "text": "Some text from user 2"
            }
        }
    ]
)

---

🔍 Then, During Search:

You can filter by user_id so each user only sees their own data:

from qdrant_client.models import Filter, FieldCondition, MatchValue

search_results = qdrant.search(
    collection_name="pdf_chunks",
    query_vector=some_query_vector,
    limit=5,
    query_filter=Filter(
        must=[
            FieldCondition(
                key="user_id",
                match=MatchValue(value="user_1")
            )
        ]
    )
)

---

🛡️ Why This is Better than One Collection per User:

Option	Pros	Cons
🟢 One collection	Easier to manage, query, and scale	Must filter carefully by user_id
🔴 One collection per user	Isolation is strong	Hard to scale, hard to query across users

If you're building a multi-user app (like a SaaS product), one collection with user_id filtering is the best practice.

---

Would you like a FastAPI endpoint that adds this logic for per-user document upload and search?

---

Absolutely! Let’s take a deeper yet beginner-friendly dive into the core concepts of Qdrant: collection, point, payload, upsert, vector, distance – these form the backbone of vector search engines.

---

📁 1. Collection

A collection is like a “folder” or “table” where related vectors are stored.

🔹 Key Facts:

• Each collection has:

  • A name (like "pdf_chunks" or "user_documents")

  • A vector size (e.g. 768 or 1536)

  • A distance function (how similarity is measured)

🧠 Analogy:

If Qdrant is a library, each collection is a bookshelf. All books on that shelf are sorted by a common theme (vector size + similarity logic).

---

📍 2. Point

A point is a single item (row) in a collection — it holds a vector + optional metadata (payload) + a unique ID.

🔹 Structure:

{
  "id": "123",
  "vector": [0.1, 0.7, ..., 0.3],
  "payload": {
    "user_id": "user_1",
    "text": "What is Qdrant?",
    "source": "FAQ.pdf"
  }
}

🧠 Analogy:

A point is like a book in a bookshelf. It has:

• A unique ID (like a barcode)

• Contents (vector)

• Info on the back cover (payload)

---

🧾 3. Payload

The payload is the extra metadata you attach to a point — it’s not part of the vector but helps you filter or organize results.

🔹 Use it for:

• User IDs

• Tags

• Sources (e.g., PDF name)

• Timestamps

• Categories

🔍 Use case:

“Search semantically for answers, but only from user_1’s files”

You filter by this:

"filter": {
  "must": [
    {"key": "user_id", "match": {"value": "user_1"}}
  ]
}

---

🔁 4. Upsert

Upsert = “insert if new, update if exists”

You use it to add or update points in a collection.

✅ Example:

qdrant.upsert(
    collection_name="my_docs",
    points=[
        {
            "id": "faq-001",
            "vector": [0.2, 0.3, ...],
            "payload": {
                "user_id": "user_123",
                "text": "What is vector search?"
            }
        }
    ]
)

If "faq-001" already exists, it updates the vector and payload.

---

📐 5. Vector

A vector is a list of numbers that represents the meaning of some content (like a sentence or image).

🔹 Example:

[0.12, 0.91, -0.37, ..., 0.44]  # usually length 768, 1536, or more

Vectors come from embedding models like:

• OpenAI’s text-embedding-3-small

• Hugging Face Transformers

• Cohere, etc.

🧠 Why Use Vectors?

Because they capture meaning, not just keywords. You can now ask:

“Which document is most semantically similar to this question?”

---

📏 6. Distance

A distance function is how Qdrant measures how similar two vectors are.

Options:

• Cosine – angle between vectors (great for NLP)

• Dot – dot product (works well with normalized vectors)

• Euclidean – physical distance (L2 norm)

🔍 Cosine Similarity Example:

qdrant.recreate_collection(
    collection_name="articles",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
)

🧠 Tip:

• For OpenAI embeddings → use Cosine

• For image search → often Euclidean

---

🔄 Summary Table

Concept	What it is	Analogy
Collection	A group of related vectors	A bookshelf
Point	A single record with vector + metadata	A book
Payload	Metadata for filtering/search context	Book info on the back cover
Upsert	Insert or update a point	Add or replace a book
Vector	Numeric representation of meaning	Encoded essence of the content
Distance	How similarity is measured	Angle or distance between books