What can you do with this server?

The turbocontext server enables high-performance, local codebase indexing and semantic search for AI coding agents via MCP. You can: * Index a codebase: Parse source files (Python, JavaScript, TypeScript, Rust, Go, C++, and more) into AST chunks using Tree-sitter, generate embeddings with FastEmbed, and store them in a 4-bit quantized Turbovec index. Files unchanged since last indexing are automatically skipped; use force=True to re-index everything. * Search code semantically: Query the index using natural language; results are retrieved from the vector index and reranked with a cross-encoder (BAAI/bge-reranker-v2-m3) for sub-20ms, highly relevant context. * Add memory notes: Inject plain-text architectural decisions or notes directly into the index, searchable alongside code chunks. * Monitor status: Get diagnostic metrics (chunk, file, memory counts, disk size, model info) for any workspace. * Clear a workspace: Purge all data (chunks, memories, file hashes) for a workspace, resetting its index. * Real-time file watching: Start/stop watchers to automatically update the index on file edits or deletions. * Workspace isolation: Each operation is scoped to a unique workspace_id, preventing cross-workspace leakage. * Optimized performance: 4-bit quantization and efficient algorithms deliver sub-20ms search latency and up to 8x memory compression, suitable for large codebases.

Which integrations are available for this server?

Allows Hermes AI agents to integrate with codebase indexing and search capabilities via MCP.

How do I use turbocontext?

1. Click on "Install 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., "@turbocontext search my codebase for the error handling middleware" 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.

turbocontext

by e-x-h-i-b-i-t

Overview Schema Source Related Servers Score Discussions Admin

Python

Local

A 100,000 code chunk index takes 307 MB of RAM as float32. Turbocontext fits it in 38 MB - and searches it in sub-20ms with cross-encoder accuracy.

Turbocontext is a high-performance, real-time codebase indexing engine and vector context retriever for AI coding agents (Claude Code, Cursor, Aider, Hermes, Windsurf, Continue). Built on Tree-sitter AST parsing, FastEmbed local ONNX embeddings, Google Research's TurboQuant 4-bit quantization algorithm via turbovec, and Cross-Encoder reranking, it serves workspace-isolated context queries over Model Context Protocol (MCP) stdio transport.

Incremental online ingest. SHA-256 file hashing skips unchanged files automatically (~90% indexing work saved). Added or modified files are AST-chunked and indexed immediately — no parameter tuning, no separate training step.
8.0x Memory compression. Quantizes dense 768-dim float32 vectors down to 4-bit representations ($384\text{ bytes/vec}$ instead of $3,072\text{ bytes/vec}$), enabling massive codebase indexing in RAM.
Tree-sitter AST breadcrumbs. Decomposes multi-language source code (.py, .js, .ts, .rs, .go, .cpp, .c, .java, .html, .css, .json) into semantic function and class blocks with prepended breadcrumbs (File: [path]\nType: [Class|Function]\n\n[code]).
Filtered allowlist search. Pass a workspace uint64 ID allowlist to search() and the Turbovec kernel honours it directly. You get zero cross-workspace data leakage and no over-fetching penalty.
Two-stage cross-encoder precision. Oversamples candidate vectors from Turbovec search, then reranks top candidates using BAAI/bge-reranker-v2-m3 cross-encoder to eliminate context noise.
Pure local & air-gapped. Runs locally via stdio MCP. No cloud API calls, no third-party vector database service, no code leaving your machine or VPC.

Building AI agent workflows where context quality, RAM footprint, or sub-20ms latency matters? You're in the right place.

Quickstart (Python & MCP)

Environment Setup

# Clone the repository
git clone https://github.com/e-x-h-i-b-i-t/turbocontext.git
cd turbocontext

# Synchronize dependencies with uv
uv sync

# Run FastMCP stdio server
uv run python src/server.py

Python API Usage

import numpy as np
from storage import VectorStore
from indexer import index_file

# Initialize VectorStore with local SQLite + Turbovec 4-bit index
store = VectorStore(db_path="storage.db", dim=768, bit_width=4)

# Index a source file (AST chunking + FastEmbed vectorization + SHA-256 hash skip)
chunks_indexed = index_file("src/server.py", workspace_id="my_project", vector_store=store)

# Search with two-stage vector search + cross-encoder reranking
query_text = "FastMCP stdio server tools"
query_vec = np.random.randn(768).astype(np.float32)  # Generated via FastEmbed

results = store.search(
    query_vector=query_vec,
    workspace_id="my_project",
    top_k=20,          # Oversample 20 candidates from Turbovec
    query_text=query_text,
    final_k=3          # Rerank to top 3 best chunks
)

for res in results:
    print(f"[{res['file_path']}] score={res['rerank_score']:.4f}\n{res['text']}\n")

store.close()

Related MCP server: ContextAtlas

MCP Tools Reference

Connecting AI agents to src/server.py over stdio MCP grants access to 7 tools:

MCP Tool Name	Parameters	Description
`index_workspace`	`workspace_id` (str), `directory_path` (str), `force` (bool)	Recursively scans code files, parses AST chunks, computes SHA-256 hashes, and indexes chunks.
`search_code`	`workspace_id` (str), `query` (str), `top_k` (int=3)	Embeds text query, retrieves candidates via Turbovec allowlist, and cross-encoder reranks top matching chunks.
`add_memory`	`workspace_id` (str), `text` (str)	Injects plain-text notes or architectural decisions into the index without needing a file path.
`get_status`	`workspace_id` (optional str)	Returns diagnostic metrics: chunk counts, file counts, memory counts, DB disk size, and model metadata.
`clear_workspace`	`workspace_id` (str)	Purges all indexed code chunks, memories, and file hashes for a workspace ID and rebuilds vector index.
`start_file_watcher`	`workspace_id` (str), `directory_path` (str)	Starts an asynchronous real-time background file watcher that updates the index on file edits/deletions.
`stop_file_watcher`	`workspace_id` (str)	Stops the asynchronous background file watcher for a workspace ID.

Verified MCP Integration Specs & Schemas

Verified configuration schemas across supported AI agent clients:

1. Claude Code (CLI)

Global registration via CLI:

claude mcp add turbocontext -- uv run /path/to/turbocontext/src/server.py

Or repository-level .mcp.json:

{
  "mcpServers": {
    "turbocontext": {
      "command": "uv",
      "args": ["run", "/path/to/turbocontext/src/server.py"]
    }
  }
}

2. Claude Desktop App

Configuration file path by OS:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "turbocontext": {
      "command": "uv",
      "args": [
        "run",
        "/path/to/turbocontext/src/server.py"
      ],
      "cwd": "/path/to/turbocontext"
    }
  }
}

3. Cursor IDE

Add to .cursor/mcp.json in your workspace root, or configure under Cursor Settings → Features → MCP:

{
  "mcpServers": {
    "turbocontext": {
      "command": "uv",
      "args": [
        "run",
        "/path/to/turbocontext/src/server.py"
      ]
    }
  }
}

4. Cline / Roo Code / CoolCline (VS Code Extensions)

File path: ~/.vscode/extensions/.../cline_mcp_settings.json or roo_code_mcp_settings.json:

{
  "mcpServers": {
    "turbocontext": {
      "command": "uv",
      "args": [
        "run",
        "/path/to/turbocontext/src/server.py"
      ],
      "disabled": false,
      "autoApprove": []
    }
  }
}

5. Continue (VS Code & JetBrains IDEs)

File path: ~/.continue/config.json:

{
  "mcpServers": [
    {
      "name": "turbocontext",
      "command": "uv",
      "args": [
        "run",
        "/path/to/turbocontext/src/server.py"
      ]
    }
  ]
}

6. Aider CLI

Launch via CLI flag:

aider --mcp-server "uv run /path/to/turbocontext/src/server.py"

Or save in .aider.conf.yml:

mcp-servers:
  - "uv run /path/to/turbocontext/src/server.py"

7. Hermes / Open-WebUI Agents

Add to agent tool configuration (mcp_servers.yaml):

mcp_servers:
  turbocontext:
    transport: stdio
    command: uv
    args:
      - run
      - /path/to/turbocontext/src/server.py

Search Speed & Benchmarks

All empirical benchmarks evaluated on Linux with Python 3.12 and CPU-only ONNX execution:

Benchmark Domain	Metric Measured	Result	Evaluation
AST Parsing Speed	Throughput	137,404 files/sec	0.0073 ms/file parsing latency
FastEmbed Embedding	Throughput	130.9 chunks/sec (9.8 KB/s)	Local ONNX CPU execution
Turbovec Quantized Search	Latency (1,000 vectors)	0.318 ms P50 / 0.321 ms P95	Sub-millisecond vector retrieval
Memory Compression	Footprint Ratio	8.0x Reduction (3072 → 384 B/vec)	87.5% memory footprint savings
End-to-End Search Response	`search_code` Response Time	15.7 ms Mean (16.5 ms P95)	Sub-20ms total context retrieval

Compression Footprint Comparison

Corpus Scale	Unquantized Float32	4-Bit Turbovec	Memory Saved
10,000 Chunks	29.3 MB	3.7 MB	-25.6 MB
100,000 Chunks	293.0 MB	36.6 MB	-256.4 MB
1,000,000 Chunks	2.93 GB	366.0 MB	-2.56 GB

How It Works

Turbocontext compresses context retrieval latency and RAM footprint using a 6-stage architectural pipeline:

 1. AST Chunking    -->  2. Dense Embedding  -->  3. 4-Bit Quantization
 (Tree-sitter node)     (FastEmbed 768-dim)     (384 bytes/vector)
                                                        │
 6. MCP Response    <--  5. Cross-Encoder    <--  4. Allowlist SIMD Search
 (Sub-20ms stdio)       (bge-reranker-v2-m3)    (Workspace uint64 IDs)

AST Decomposition: Tree-sitter parses multi-language source code files into semantic definitions (function_definition, class_definition, struct_item) with contextual breadcrumbs (File: [path]\nType: [Class|Function]\n\n[code]).
Local Vector Embedding: FastEmbed ONNX model (jinaai/jina-embeddings-v2-base-code) maps each code block to a 768-dimensional dense vector space.
Random Orthogonal Quantization: turbovec.IdMapIndex applies a random orthogonal rotation matrix to map coordinates to a canonical distribution, quantizing 768 float32 dimensions into 4-bit representations ($384\text{ bytes/vec}$).
Allowlist SIMD Search: turbovec.search() takes a 1D uint64 numpy array allowlist corresponding to workspace_id row IDs in SQLite, executing short-circuited SIMD search with zero cross-workspace data leakage.
Cross-Encoder Precision Reranking: Candidate chunks from vector search are reranked by BAAI/bge-reranker-v2-m3 cross-encoder, scoring raw query text against retrieved code blocks to eliminate false positives.
FastMCP Stdio Transport: Returns structured results over stdio MCP transport to AI agents within ~16.22 ms.

References

TurboQuant: Online Vector Quantization with Near-optimal Distortion Rate (ICLR 2026) — vector quantization algorithm implemented by turbovec
FastEmbed — lightweight local ONNX text embedding library
Model Context Protocol — open standard protocol for connecting AI models to context tools
Tree-sitter — parser generator tool and incremental parsing library

Available Tools

5 tools

add_memoryC

Shortcut tool to store a plain-text memory or note into the index without needing a file path.

ParametersJSON Schema

Name	Required	Description	Default
`text`	Yes
`workspace_id`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

C2.7/5.0

Behavior2/5

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

No annotations provided, so description must disclose behaviors. It mentions storing but lacks details on side effects, authentication, rate limits, or return values. Minimal transparency.

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?

Single sentence, 14 words, front-loaded with purpose. Concise but could benefit from additional structured info.

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?

Simple tool with 2 params and output schema, but description omits return value, idempotency, or overwrite behavior. Incomplete for reliable agent usage.

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

Parameters2/5

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

Schema description coverage is 0%. Description does not explain parameters beyond implying 'text' holds the memory. No detail on 'workspace_id' meaning or format.

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?

Description states verb 'store' and resource 'plain-text memory or note into the index', distinguishing it from sibling tools like index_workspace which likely require file paths. Clear and specific.

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 explicit guidance on when to use this vs alternatives. Only hints at avoiding file paths, but no direct comparison or scenarios.

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

clear_workspaceC

Purges all indexed code chunks, stored memories, and file hashes for workspace_id from storage.

ParametersJSON Schema

Name	Required	Description	Default
`workspace_id`	Yes

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 full burden. It states the tool purges data, which implies destructive behavior, but does not disclose reversibility, required permissions, or any safety mechanisms. The specifics of what is purged are listed, but deeper behavioral context is missing.

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

Conciseness5/5

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

The description is a single, concise sentence that efficiently conveys the tool's action and scope. No unnecessary words or information.

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?

Despite having an output schema (not shown), the description provides no context about return values or side effects. For a destructive tool with minimal additional info (no annotations), this leaves gaps in understanding what happens after the operation.

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

Parameters1/5

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

The input schema has 0% description coverage, meaning no parameter descriptions. The description does not elaborate on the 'workspace_id' parameter beyond its name, so it adds no semantic value beyond the schema. Given the low coverage, this is a significant gap.

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

Purpose5/5

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

The description uses a specific verb 'Purges' and clearly lists the resources (indexed code chunks, stored memories, file hashes) that are affected. It distinguishes itself from sibling tools like index_workspace (which indexes) and search_code (which searches), making its purpose unique and clear.

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 explicit guidance on when to use or not use this tool. No alternatives or prerequisites are mentioned. The description lacks context about when this operation is appropriate or what conditions should be met before calling it.

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

get_statusA

Returns real-time status and statistics about the Turbocontext vector store, database size, chunk counts, unique files, stored memories, and model metadata.

ParametersJSON Schema

Name	Required	Description	Default
`workspace_id`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.9/5.0

Behavior4/5

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

No annotations are provided, so the description carries full burden. It discloses that the tool is a read-only operation returning real-time data, listing specific output categories. This is sufficient transparency for a status tool, though it doesn't mention authentication or rate limits.

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

Conciseness5/5

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

The description is a single, efficient sentence that covers the tool's purpose and output without any wasted words. It is appropriately front-loaded with the core action.

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

Completeness4/5

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

Given the tool's low complexity, the presence of an output schema, and the description listing key output categories, the description is fairly complete. However, it could briefly mention the optional workspace_id parameter for full context.

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

Parameters2/5

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

The input schema has one optional parameter (workspace_id) with 0% description coverage in the schema. The tool description does not mention this parameter at all, failing to add meaning beyond the schema. A higher score would require explaining the parameter's role.

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

Purpose5/5

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

The description clearly states the tool returns real-time status and statistics about the Turbocontext vector store, specifying concrete data like database size, chunk counts, etc. This differentiates it from sibling tools (index_workspace, search_code, etc.) that perform different actions.

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

Usage Guidelines3/5

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

The description implicitly indicates when to use the tool (when needing status or stats), but provides no explicit guidance on when not to use it or alternatives. This is adequate for a simple status tool but lacks depth.

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

index_workspaceB

Recursively finds code files in directory_path and indexes them using Tree-sitter AST chunking,
FastEmbed vector generation, and Turbovec storage. Skips unchanged files automatically unless force=True.

ParametersJSON Schema

Name	Required	Description	Default
`force`	No
`workspace_id`	Yes
`directory_path`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

B3.2/5.0

Behavior3/5

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

No annotations provided, so description carries burden. Discloses recursive file discovery, specific indexing pipeline (Tree-sitter, FastEmbed, Turbovec), and auto-skip behavior. Missing side-effect or permission info.

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?

Two sentences are efficient and focused, no filler. Information is front-loaded.

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?

Has output schema, so return values not needed. However, no error cases, prerequisites, or success conditions described. Adequate but not thorough for 3-param tool.

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

Parameters2/5

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

Schema coverage is 0%, so description should compensate. It mentions force=True meaning and implies directory_path is a folder path, but workspace_id is unexplained beyond name. Minimal parameter guidance.

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?

Description clearly states the tool indexes code files in a directory using specified technologies. It distinguishes from siblings like search_code by being the indexing step, but does not explicitly differentiate.

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

Usage Guidelines3/5

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

Provides guidance on skipping unchanged files and force parameter, but lacks explicit when-to-use vs alternatives like search_code or prerequisites.

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

search_codeA

Embeds the search query using FastEmbed, retrieves candidate chunks from Turbovec vector index,
reranks them using Cross-Encoder, and returns top_k matching code/memory chunks (default top_k=3).

ParametersJSON Schema

Name	Required	Description	Default
`query`	Yes
`top_k`	No
`workspace_id`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.8/5.0

Behavior4/5

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

The description reveals the internal process: embedding with FastEmbed, retrieval from Turbovec, reranking with Cross-Encoder, and returning top_k chunks. This goes beyond a simple 'search' label. However, it does not explicitly state that the tool is read-only or safe, and no annotations are provided to cover those aspects.

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

Conciseness5/5

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

The description is a single, well-structured sentence that efficiently conveys the tool's workflow. No extraneous information.

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?

The description covers the core search process but omits context about the workspace parameter (e.g., search is scoped to a workspace). Given the output schema exists, return values need not be explained, but the workspace context is important for correct usage.

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

Parameters2/5

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

With 0% schema description coverage, the description must explain parameters. It only mentions top_k's default value. The workspace_id and query parameters are not described, leaving ambiguity about their roles and constraints.

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

Purpose5/5

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

The description clearly states it searches code/memory chunks using embedding, retrieval, and reranking. The verb 'search' and resource 'code/memory chunks' are specific. The sibling tools are about indexing, adding, status, and clearing, so this tool is clearly distinguished as the search tool.

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

Usage Guidelines3/5

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

The description implies usage for searching code/memory chunks but does not explicitly state when to use it versus alternatives like index_workspace or get_status. No conditions or exclusions are mentioned.

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. Dates show when Glama detected each change.

5 tool updatesv0.1.0Jul 30, 2026
- First observedadd_memory
- First observedclear_workspace
- First observedget_status
- First observedindex_workspace
- First observedsearch_code

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.6/5.0

Scored 2026-07-30 17:40 across 5 tools

Disambiguation5/5

Each tool targets a distinct operation: indexing code files, searching the index, adding plain-text memories, getting status, and clearing the workspace. There is no functional overlap.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern in snake_case (e.g., index_workspace, search_code). The naming is predictable and easy to understand.

Tool Count5/5

With 5 tools, the server covers the core workflow of indexing, searching, and managing a code/memory vector store without being overly sparse or bloated.

Completeness4/5

The tool set covers indexing, searching, memory addition, status, and full clearing. A minor gap is the lack of granular deletion (e.g., removing specific files or memories without clearing everything), but for most use cases this is sufficient.

Maintenance

ActivityMaintained

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

TeamShared C
io.github.xhad
Shared memory for coding agents. Stop re-explaining your codebase every session.
Knowledge & Memory Developer Tools
1271
developer-tools-mcp-server A
com.thenextgennexus
Search GitHub, npm, PyPI, StackOverflow, ArXiv from one MCP — built for coding agents.
Developer Tools Search
72
memory
com.lodekeep
Portable memory for AI agents: capture once, recall across Claude, Cursor, and any MCP client.
Knowledge & Memory File Systems
1
AI Context FlowOAuth
network.plurality
Universal memory for AI agents and tools. Save, organize and search context anywhere.
Knowledge & Memory Search
22

Related MCP Servers

nexus-mcp-ci
Code Analysis Knowledge & Memory RAG Systems
jaggernaut007
A
license
A
quality
A
maintenance
Unified MCP server combining hybrid search (vector + BM25 + code graph), structural code analysis, and persistent semantic memory. 15 tools, 25+ languages, <350MB RAM, fully local.
Updated 15 days ago (2026-08-25 14:33 UTC)
10
MIT
ContextAtlas
RAG Systems Code Analysis
codefromkarl
A
license
Not graded
quality
D
maintenance
Enables AI coding agents to retrieve and manage code context with hybrid search, project memory, and observability via MCP tools.
Updated 3 months ago (2026-06-02 06:10 UTC)
29
MIT
memory-bank-mcp
Knowledge & Memory Vector Databases Code Analysis
gcorroto
A
license
A
quality
D
maintenance
MCP server for semantic code indexing using vector embeddings, enabling AI agents to maintain persistent memory of codebases through natural language queries and intelligent chunking.
Updated 7 months ago (2026-01-28 21:32 UTC)
19
76
4
MIT
Vectr
Code Analysis Knowledge & Memory
swapnanil
A
license
A
quality
A
maintenance
Semantic codebase search + persistent working memory for AI code editors. Local, zero-config, MCP. No API key.
Updated 3 days ago (2026-09-06 09:22 UTC)
8
23
2
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/e-x-h-i-b-i-t/turbocontext'

If you have feedback or need assistance with the MCP directory API, please join our Discord server