Qdrant: The Vector Database That Just Runs
Practice

Qdrant: The Vector Database That Just Runs

Start Qdrant with Docker, embed your documents, search by meaning — plus: which embedding model you need and what it actually costs.

Too much jargon?→ Look it up in the glossary

In an earlier post we figured out what a vector store actually is: a tool that makes text searchable by meaning. Nice theory. Today we start one — and feed it real documents.

The tool is called Qdrant (say „quadrant"). It's open source, it runs on your own machine, and getting started is honestly unspectacularly easy.

What Qdrant is — and isn't

Qdrant is the vector store itself: the database that stores your numeric fingerprints (the embeddings) and finds the most similar ones in a flash. That's it. It doesn't think, it doesn't chat, it doesn't write text. It searches. Very well and very fast.

That distinction matters, because some tools have something like this built in without you noticing. OpenWebUI, for instance, has a knowledge base on board. Flowise brings no vector store of its own — but it hooks up to one, like Qdrant, with basically a single click. So Qdrant is the layer underneath — the one you take into your own hands when you want full control.

Installation: one command

If Docker is running, Qdrant is up in a single line:

docker run -p 6333:6333 -p 6334:6334 \
  -v "$(pwd)/qdrant_storage:/qdrant/storage" \
  qdrant/qdrant

That's it. The -v part just makes sure your data survives a restart (without it, everything lives inside the container and is gone next time).

In your browser at http://localhost:6333/dashboard you even get a small interface where you can see your collections. No account, no cloud, no signup.

(Small note: Qdrant starts with no password. Perfectly fine for an experiment on your own machine — before you put it on the open internet, read the security chapter of the docs first.)

Embedding documents — the example script

Now the part that shows what happens under the hood. We split a text, send each chunk to an embedding model, and store the results in Qdrant. In Python it looks like this:

from qdrant_client import QdrantClient, models
from openai import OpenAI

qdrant = QdrantClient(url="http://localhost:6333")
ai = OpenAI()  # API key comes from the environment

qdrant.recreate_collection(            # Step 1: create a collection
    "my-notes",
    vectors_config=models.VectorParams(size=1536, distance=models.Distance.COSINE),
)  # 1536 = length of the number row for this model

chunks = ["First paragraph ...", "Second paragraph ...", "..."]
for i, text in enumerate(chunks):      # Step 2: embed chunks and store them
    vector = ai.embeddings.create(
        model="text-embedding-3-small", input=text
    ).data[0].embedding
    qdrant.upsert("my-notes", [
        models.PointStruct(id=i, vector=vector, payload={"text": text})
    ])

question = ai.embeddings.create(       # Step 3: search by meaning
    model="text-embedding-3-small", input="What was that about again?"
).data[0].embedding
hits = qdrant.query_points("my-notes", query=question, limit=3)
for h in hits.points:
    print(h.payload["text"])

Three steps: create a collection, embed chunks, search. Exactly the principle from the vector-store article — only now there's a real database behind it.

And now the honest reassurance: in practice you rarely write this script yourself. OpenWebUI has the embedding built in; in Flowise you click in a Qdrant node — and both then handle it in the background. The example exists so you understand what the fancy tools do. Build it yourself and you hold every screw in your own hand.

What you need on the AI side

Qdrant stores the embeddings — but creating them takes an embedding model. That's its own kind of AI, specialised in turning text into numbers (not in chatting). Four ways:

  • OpenAI — text-embedding-3-small is the unflashy standard. Grab an API key, off you go.
  • Jina AI — still around, alive and well. Based in Berlin, processes in the EU and signs a data processing agreement (DPA) on request — a pleasantly European answer to GDPR questions. (Honest footnote: since late 2025 Jina belongs to US firm Elastic; the servers stay in the EU according to the provider.) To get started there's a free quota — currently around a million tokens to play with, non-commercial.
  • OpenRouter — the model aggregator now does embeddings too, giving you access to several providers with one key (OpenAI, Mistral, Qwen, Google). Handy for comparing.
  • Fully local — with Ollama the embedding runs on your own machine too. Note: that's a separate model specialised in embedding — not your chat model. Solid picks are nomic-embed-text (small and fast) or bge-m3 (multilingual, good for German). No API key, no cloud, your documents never leave the house. Just remember these models produce a different vector length than OpenAI (nomic-embed-text is 768, not 1536) — so adjust the collection's size in the code above. A bit slower, but free and private.

The running thread on this blog: wherever there's an open, self-hosted option, it's worth a look — especially when the documents are confidential.

What does an embedding cost?

The surprising answer: almost nothing. text-embedding-3-small currently costs about 2 cents per million tokens (a token is roughly a syllable).

What does that mean in practice? Embedding a thick thousand-page book lands in the one-or-two-cent range. Embedding a single search query is so cheap you can barely express it in cents anymore. And locally via Ollama? Zero — apart from the electricity for your machine.

Embeddings are by far the cheapest part of the whole AI bill. This is not where you need to pinch pennies.

Two ways to put it to work

Zoo Code — the open-source coding assistant in your editor can use a local Qdrant as a memory for your code. Instead of dumping half the codebase into the model on every question, it pulls out exactly the relevant spots. Saves tokens and makes the answers more accurate.

Flowise — here you click together a complete AI workflow, with no code at all: documents in, Qdrant as the store, a chat model in front — and there's your chatbot that knows your content. How to do that step by step is worth its own article. That one's coming next.

Is it worth it for you?

If you only ask something now and then: no, a ready-made tool with a built-in knowledge base is enough. Running Qdrant yourself pays off the moment you want to build something of your own — a chatbot, a code memory, a searchable collection that grows with you and stays on your machine.

The Docker command above is a risk-free start. Launch Qdrant, open the dashboard, have a look around. And next time we'll build the chatbot around it with Flowise.