Which integrations are available for this server?

Uses Ollama to generate GPU-accelerated embeddings, enabling semantic search and retrieval over codebases stored in Qdrant.

How do I use qdrant-mcp-ollama?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@qdrant-mcp-ollama Search the codebase for authentication logic and return relevant code chunks." That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

de en es ja ko ru zh

qdrant-mcp-ollama

by michal7kw

Overview Schema Source Related Servers Discussions Admin

Python

Hybrid

qdrant-mcp-ollama

A Model Context Protocol (MCP) server for Qdrant vector database that uses Ollama for GPU-accelerated embeddings.

Why not the official mcp-server-qdrant?

The official Qdrant MCP server uses FastEmbed for embeddings, which:

Runs on CPU only — slow on large codebases, underutilizes modern GPUs
Uses a small model (all-MiniLM-L6-v2, 384-dim) — lower quality embeddings
Single-process lock in local mode — only one MCP client can access the database at a time

This server solves all three problems:

	Official `mcp-server-qdrant`	`qdrant-mcp-ollama`
Embedding engine	FastEmbed (CPU)	Ollama (GPU)
Default model	all-MiniLM-L6-v2 (384-dim, 80MB)	bge-m3 (1024-dim, 1.2GB)
Concurrent access	No (local mode)	Yes (Qdrant server)
Model flexibility	FastEmbed models only	Any Ollama embedding model

Related MCP server: Claude Context MCP

Architecture

┌──────────────┐     ┌────────────────────┐     ┌─────────────┐
│  MCP Client   │────>│  qdrant-mcp-ollama │────>│   Ollama    │
│ (Claude Code, │     │    (server.py)      │     │  (GPU)      │
│  Kilo Code,   │<────│                    │     └─────────────┘
│  Cursor, etc) │     └────────┬───────────┘
└──────────────┘              │
                              v
                   ┌────────────────────┐
                   │   Qdrant Server    │
                   │  (Docker, :6333)   │
                   │  Storage: local    │
                   │  disk / cloud      │
                   └────────────────────┘

Prerequisites

Ollama — installed and running with an embedding model pulled
Docker — for running the Qdrant server
uv — Python package manager (recommended) or pip

Quick Start

1. Pull an embedding model in Ollama

ollama pull bge-m3

2. Start the Qdrant server

docker run -d --name qdrant-server \
  -p 6333:6333 -p 6334:6334 \
  -v qdrant-storage:/qdrant/storage \
  --restart unless-stopped \
  qdrant/qdrant:latest

3. Run the MCP server

# No install needed — uv downloads dependencies on-the-fly:
QDRANT_URL="http://localhost:6333" \
EMBEDDING_MODEL="bge-m3" \
uv run --with fastmcp --with qdrant-client --with httpx python server.py

4. Embed a codebase

uv run --with qdrant-client --with httpx python embed_codebase.py \
  /path/to/your/project my-project --preset python

5. Search from your MCP client

Once configured (see sections below), ask your AI assistant:

"Search the codebase for authentication logic"

It will use the qdrant_find tool to return semantically relevant code chunks.

Setting Up the Qdrant Server

Option A: Docker (recommended)

Store data on a specific drive (e.g., E: on Windows):

# Create storage directories
mkdir -p E:/qdrant-storage E:/qdrant-snapshots

# Start Qdrant with persistent storage
docker run -d --name qdrant-server \
  -p 6333:6333 -p 6334:6334 \
  -v E:/qdrant-storage:/qdrant/storage \
  -v E:/qdrant-snapshots:/qdrant/snapshots \
  --restart unless-stopped \
  qdrant/qdrant:latest

On Linux/macOS:

docker run -d --name qdrant-server \
  -p 6333:6333 -p 6334:6334 \
  -v ~/qdrant-storage:/qdrant/storage \
  --restart unless-stopped \
  qdrant/qdrant:latest

The --restart unless-stopped flag ensures Qdrant starts automatically with Docker Desktop.

Verify it's running:

docker ps --filter name=qdrant-server
# Or open http://localhost:6333/dashboard in your browser

Option B: Qdrant Cloud

QDRANT_URL="https://your-cluster.cloud.qdrant.io:6333"
QDRANT_API_KEY="your-api-key"

Note: The QDRANT_API_KEY environment variable is passed through to the Qdrant client automatically.

Embedding a Codebase

The embed_codebase.py script scans a directory, chunks source files, and bulk-embeds them into Qdrant using Ollama on GPU.

Basic usage

uv run --with qdrant-client --with httpx python embed_codebase.py <directory> <collection-name>

Using extension presets

# Python project
python embed_codebase.py ./my-api api-backend --preset python

# Full-stack web project
python embed_codebase.py ./my-app frontend --preset web

# R / bioinformatics project
python embed_codebase.py ./analysis bio-analysis --preset r

# Everything
python embed_codebase.py ./mono-repo all-code --preset all

Custom extensions

python embed_codebase.py ./project my-collection --extensions .py .sql .sh .yaml

Available presets

Preset	Extensions
`python`	`.py` `.pyi`
`javascript`	`.js` `.jsx` `.mjs` `.cjs`
`typescript`	`.ts` `.tsx`
`web`	`.js` `.jsx` `.ts` `.tsx` `.vue` `.svelte` `.html` `.css` `.scss`
`r`	`.R` `.r` `.Rmd` `.rmd`
`java`	`.java`
`csharp`	`.cs`
`go`	`.go`
`rust`	`.rs`
`cpp`	`.cpp` `.hpp` `.cc` `.hh` `.c` `.h`
`all`	All common source extensions

If no --preset or --extensions is provided, the script auto-detects file types.

All options

usage: embed_codebase.py <directory> <collection> [options]

positional arguments:
  directory              Path to the codebase directory
  collection             Qdrant collection name

options:
  --extensions EXT [EXT ...]  File extensions to include (e.g. .py .ts)
  --preset PRESET             Use a preset group of extensions
  --model MODEL               Ollama embedding model (default: bge-m3)
  --qdrant-url URL            Qdrant server URL (default: http://localhost:6333)
  --ollama-url URL            Ollama server URL (default: http://localhost:11434)
  --chunk-size N              Max lines per chunk (default: 80)
  --chunk-overlap N           Overlap lines between chunks (default: 10)
  --batch-size N              Upload batch size for Qdrant (default: 500)
  --append                    Append to existing collection instead of replacing

Append mode

By default, re-running the script replaces the collection. Use --append to add to an existing collection:

# First embed
python embed_codebase.py ./src main-code --preset typescript

# Add more files later
python embed_codebase.py ./docs main-code --extensions .md --append

Multi-Codebase Usage

Use separate collections for each codebase to keep search results scoped and relevant:

# Project A
python embed_codebase.py ~/projects/api-server api-server --preset python

# Project B
python embed_codebase.py ~/projects/web-app web-app --preset web

# Project C
python embed_codebase.py ~/projects/data-pipeline data-pipeline --preset python

When configuring the MCP server:

Without COLLECTION_NAME: You must specify the collection per query. This is ideal when one MCP server serves multiple projects.
With COLLECTION_NAME: A default collection is used automatically. Set this per-project if your MCP client supports project-scoped configuration.

Configuring Claude Code

Add the MCP server

claude mcp add qdrant -s user \
  -e QDRANT_URL="http://localhost:6333" \
  -e OLLAMA_URL="http://localhost:11434" \
  -e EMBEDDING_MODEL="bge-m3" \
  -- uv run --with fastmcp --with qdrant-client --with httpx \
     python /path/to/qdrant-mcp-ollama/server.py

Replace /path/to/qdrant-mcp-ollama/ with the actual path where you cloned this repo.

With a default collection

If you primarily work on one project:

claude mcp add qdrant -s user \
  -e QDRANT_URL="http://localhost:6333" \
  -e OLLAMA_URL="http://localhost:11434" \
  -e EMBEDDING_MODEL="bge-m3" \
  -e COLLECTION_NAME="my-project" \
  -- uv run --with fastmcp --with qdrant-client --with httpx \
     python /path/to/qdrant-mcp-ollama/server.py

Verify

claude mcp list
# Should show: qdrant: ... ✓ Connected

claude mcp get qdrant
# Shows full configuration details

Usage in Claude Code

Once configured, Claude Code can use these tools:

qdrant_store — Store information: "Store this authentication pattern in Qdrant"
qdrant_find — Search: "Find code related to database migrations"

For multi-collection setups (no default), specify the collection:

"Search the api-server collection for rate limiting logic"

Configuring Kilo Code (VS Code Extension)

Kilo Code is a VS Code extension with built-in MCP support.

Option 1: Manual MCP configuration

Open Kilo Code settings in VS Code
Navigate to MCP Servers configuration
Add a new server with:

Field	Value
Name	`qdrant`
Command	`uv`
Arguments	`run --with fastmcp --with qdrant-client --with httpx python /path/to/server.py`

Set environment variables:

Variable	Value
`QDRANT_URL`	`http://localhost:6333`
`OLLAMA_URL`	`http://localhost:11434`
`EMBEDDING_MODEL`	`bge-m3`
`COLLECTION_NAME`	Your project collection name (e.g., `my-project`)

Option 2: VS Code settings.json

Add to your VS Code settings.json (Ctrl+Shift+P > Preferences: Open User Settings (JSON)):

{
  "kilocode.mcpServers": {
    "qdrant": {
      "command": "uv",
      "args": [
        "run", "--with", "fastmcp", "--with", "qdrant-client", "--with", "httpx",
        "python", "/path/to/qdrant-mcp-ollama/server.py"
      ],
      "env": {
        "QDRANT_URL": "http://localhost:6333",
        "OLLAMA_URL": "http://localhost:11434",
        "EMBEDDING_MODEL": "bge-m3",
        "COLLECTION_NAME": "my-project"
      }
    }
  }
}

Per-project setup in Kilo Code

For multi-codebase setups, configure Kilo Code at project scope (not global) with a project-specific COLLECTION_NAME. This way each workspace searches only its own codebase.

Configuring Other MCP Clients

Cursor / Windsurf

Run the server with SSE transport for remote-capable clients:

QDRANT_URL="http://localhost:6333" \
OLLAMA_URL="http://localhost:11434" \
EMBEDDING_MODEL="bge-m3" \
FASTMCP_PORT=8000 \
uv run --with fastmcp --with qdrant-client --with httpx \
  python server.py --transport sse

Then in Cursor/Windsurf MCP settings, connect to: http://localhost:8000/sse

Generic MCP client (stdio)

The default transport is stdio. Any MCP client that supports stdio can use this server by running:

uv run --with fastmcp --with qdrant-client --with httpx python server.py

Configuration Reference

MCP Server Environment Variables

Variable	Description	Default
`QDRANT_URL`	Qdrant server URL	`http://localhost:6333`
`QDRANT_API_KEY`	API key for Qdrant Cloud	None
`OLLAMA_URL`	Ollama server URL	`http://localhost:11434`
`EMBEDDING_MODEL`	Ollama embedding model name	`bge-m3`
`COLLECTION_NAME`	Default collection (empty = must specify per call)	(empty)

Choosing an Embedding Model

All models below are available via ollama pull <model>:

Model	Dimensions	Size	Speed	Quality	Best for
`bge-m3`	1024	1.2 GB	Moderate	High	General purpose, multilingual
`nomic-embed-text`	768	274 MB	Fast	Good	Lightweight, English-focused
`mxbai-embed-large`	1024	670 MB	Moderate	High	English, high quality
`snowflake-arctic-embed2`	1024	1.2 GB	Moderate	Very High	Best quality, English
`all-minilm`	384	46 MB	Very Fast	Fair	Minimal resources

Recommendation: Start with bge-m3. It handles code well, supports multilingual content (comments in any language), and balances quality with speed.

Important: The embedding model used to index a collection must match the model used for queries. If you re-embed with a different model, delete and recreate the collection.

GPU Utilization

Larger models use more GPU. If your GPU is underutilized:

Switch from nomic-embed-text (274 MB) to bge-m3 (1.2 GB) or larger
The embedding script sends all texts in a single batch to maximize GPU saturation
For individual queries (via qdrant_find), GPU spikes are brief and normal — embedding a single query takes milliseconds

Check GPU usage: nvidia-smi (NVIDIA) or rocm-smi (AMD)

MCP Tools

`qdrant_store`

Store information in the Qdrant database.

Parameter	Type	Required	Description
`information`	string	Yes	Text to store and make searchable
`collection_name`	string	If no default set	Target collection
`metadata`	dict	No	Optional metadata to attach

`qdrant_find`

Search for relevant information using semantic similarity.

Parameter	Type	Required	Description
`query`	string	Yes	Natural language search query
`collection_name`	string	If no default set	Collection to search
`top_k`	int	No	Max results to return (default: 5)

Troubleshooting

"Connection closed" / MCP server won't start

Is Ollama running? Check with ollama list. Start it with ollama serve if needed.
Is the embedding model pulled? Run ollama pull bge-m3.
Is Qdrant running? Check with docker ps --filter name=qdrant-server.

"Collection does not exist"

The collection is created by the embedding script or on first qdrant_store call. Either:

Run embed_codebase.py to index your codebase first
Or store something with qdrant_store to auto-create the collection

Dimension mismatch errors

This happens when the collection was created with one embedding model but you're querying with another. Fix:

Delete the collection: visit http://localhost:6333/dashboard
Re-embed with the correct model
Ensure EMBEDDING_MODEL in the MCP server config matches what you used for embedding

"Storage folder is already accessed by another instance"

This error comes from the official mcp-server-qdrant using local mode (QDRANT_LOCAL_PATH). This project avoids that by connecting to a Qdrant server via URL. Make sure you're not running both servers pointing to the same local path.

Slow embedding / low GPU utilization

Use a larger model: bge-m3 (1.2 GB) instead of nomic-embed-text (274 MB)
The embedding script sends all texts in one batch — if you have thousands of chunks, this maximizes GPU usage
For very large codebases (10,000+ files), consider splitting into multiple runs per directory

License

Apache License 2.0 — see LICENSE.

Available Tools

2 tools

qdrant_findC

Search for relevant information in the Qdrant database using semantic similarity.

ParametersJSON Schema

Name	Required	Description
`query`	Yes	Natural language query to search for. The query is embedded using the same GPU model used for storage, ensuring accurate results.
`top_k`	No	Maximum number of results to return (default: 5).
`collection_name`	No	Name of the collection to search in. Required if no default collection is configured.

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It implies a read-only operation but does not explicitly state that no data is modified, does not mention return behavior, error conditions, or limitations. The single sentence provides minimal behavioral disclosure beyond the literal action.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with no redundancy or filler. It is front-loaded with the verb and resource. While extremely brief, it is not a tautology and conveys the essential purpose. It avoids unnecessary words while being clear.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has a sibling (qdrant_store) and an output schema (which covers return format), the description is still incomplete. It lacks any usage context, such as when to choose this over storage or how the search integrates with the workflow. The presence of an output schema reduces the need to explain returns, but the description does not cover the selection decision or behavioral expectations.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema covers all three parameters (query, top_k, collection_name) with descriptions, so the baseline is 3. The description adds nothing beyond the schema; it mentions 'semantic similarity' which is already implied by the query parameter's embedding mention. No additional value is provided.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a clear verb ('Search'), the target resource ('Qdrant database'), and the method ('semantic similarity'). This distinguishes it from the sibling qdrant_store, which likely stores information. However, it does not explicitly name the sibling or contrast with it, so it lacks the full differentiation seen in higher-scoring examples.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus the alternative qdrant_store, nor any mention of prerequisites or context. The description only states the action without any direction on selection or exclusion criteria.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

qdrant_storeC

Store information in the Qdrant database with GPU-accelerated embeddings.

ParametersJSON Schema

Name	Required	Description
`metadata`	No	Optional metadata dictionary to attach to the stored point.
`information`	Yes	The text information to store. This will be embedded and made searchable via semantic similarity.
`collection_name`	No	Name of the collection to store in. Required if no default collection is configured.

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that information will be stored with embeddings, but does not disclose potential side effects such as whether existing points are overwritten, whether collections are auto-created, or any error behavior. The mutation is implied but not explicitly flagged.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence that conveys the core action. 'GPU-accelerated embeddings' adds a performance detail that may be useful context, but it could be considered extraneous. Overall, it is appropriately sized and front-loaded with the action.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple store operation with only 3 parameters and an output schema present, the description covers the basic action. However, it omits guidance on when a collection_name is required and does not mention any setup steps or constraints. It meets a minimum viable level but leaves gaps that an agent might need to handle.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific detail beyond what the schema already provides. The only minor addition is implying that information gets embedded, which is already stated in the schema. This meets the baseline but does not exceed it.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Store information in the Qdrant database') with a specific resource and purpose. It implies a write operation distinct from the sibling qdrant_find, though it doesn't explicitly differentiate. The mention of 'GPU-accelerated embeddings' adds implementation detail but doesn't obscure the core purpose.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is given on when to use this tool versus the sibling qdrant_find. The description does not say 'use this to add data, use qdrant_find to search' or mention any prerequisites like collection existence. An agent would have to infer usage from the name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

2 tool updatesv0.1.0Aug 24, 2026
- First observedqdrant_find
- First observedqdrant_store

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

B3.2/5.0

Scored 2026-08-24 01:10 across 2 tools

Disambiguation5/5

The two tools, qdrant_store and qdrant_find, have entirely distinct purposes—one writes data, the other retrieves it. There is zero ambiguity between them.

Naming Consistency5/5

Both tools follow a consistent 'qdrant_<verb>' pattern, using clear action verbs (store, find). The naming is predictable and uniform.

Tool Count3/5

With only two tools, the server feels thin for what is typically a database domain, but it is not an extreme mismatch. It sits at the borderline of adequacy.

Completeness2/5

The server only provides store and find, lacking any management operations like delete, update, or list. For a database, this is a significant gap that will limit workflow coverage.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Related MCP Connectors

Hint-Services-obsidian-github-mcp
ai.smithery
Connect AI assistants to your GitHub-hosted Obsidian vault to seamlessly access, search, and analy…
Note Taking Version Control File Systems
29
Ragora A
io.github.mregmi
Search your knowledge bases from any AI assistant using hybrid RAG.
RAG Systems Search Knowledge & Memory
2
Maguyva
ai.maguyva
Code intelligence for coding agents: semantic, AST, graph, and full-text search. 279+ languages.
Code Analysis Coding Agents
23
agent-memory A
com.agishub
Persistent semantic memory for AI agents: store and recall text by meaning (RAG). x402
RAG Systems Vector Databases
211

Related MCP Servers

Qdrant MCP Server
Vector Databases Code Analysis
steiner385
A
license
Not graded
quality
D
maintenance
Enables semantic code search across codebases using Qdrant vector database and OpenAI embeddings, allowing users to find code by meaning rather than just keywords through natural language queries.
Updated 9 days ago (2026-09-04 20:02 UTC)
2
MIT
Claude Context MCP
RAG Systems Vector Databases Code Analysis
sahinrasit
F
license
Not graded
quality
C
maintenance
Enables AI assistants to index and search codebases using semantic search powered by multiple embedding providers (OpenAI, VoyageAI, Gemini, Ollama) and vector database storage.
Updated a year ago (2025-09-26 10:56 UTC)
-
Arda Vector Database MCPofficial
Vector Databases Search Code Analysis
ardaglobal
F
license
Not graded
quality
D
maintenance
Enables semantic code search across multi-language codebases using natural language queries, integrated with Qdrant vector database for fast, cached retrieval.
Updated 8 months ago (2026-01-14 00:14 UTC)
1
-
qdrant-codebase-mcp
Vector Databases Code Analysis
theepicsaxguy
A
license
Not graded
quality
F
maintenance
Indexes codebases into Qdrant for semantic search, enabling AI assistants to find relevant code by meaning without re-exploring the repo.
Updated 6 days ago (2026-09-07 18:51 UTC)
MIT

qdrant-mcp-ollama

Why not the official mcp-server-qdrant?

Architecture

Prerequisites

Quick Start

1. Pull an embedding model in Ollama

2. Start the Qdrant server

3. Run the MCP server

4. Embed a codebase

5. Search from your MCP client

Setting Up the Qdrant Server

Option A: Docker (recommended)

Option B: Qdrant Cloud

Embedding a Codebase

Basic usage

Using extension presets

Custom extensions

Available presets

All options

Append mode

Multi-Codebase Usage

Configuring Claude Code

Add the MCP server

With a default collection

Verify

Usage in Claude Code

Configuring Kilo Code (VS Code Extension)

Option 1: Manual MCP configuration

Option 2: VS Code settings.json

Per-project setup in Kilo Code

Configuring Other MCP Clients

Cursor / Windsurf

Generic MCP client (stdio)

Configuration Reference

MCP Server Environment Variables

Choosing an Embedding Model

GPU Utilization

MCP Tools

qdrant_store

qdrant_find

Troubleshooting

"Connection closed" / MCP server won't start

"Collection does not exist"

Dimension mismatch errors

"Storage folder is already accessed by another instance"

Slow embedding / low GPU utilization

License

Available Tools

Output Schema

TDQS

Output Schema

TDQS

Tool Schema Changelog

TDQS

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

Qdrant MCP Server

Claude Context MCP

Arda Vector Database MCPofficial

qdrant-codebase-mcp

`qdrant_store`

`qdrant_find`