Skip to main content
Glama
meimingqi222

Fast Context MCP

by meimingqi222
OverviewSchemaSourceRelated ServersDiscussionsAdmin
Python
Local

Fast Context MCP

AI-driven semantic code search via reverse-engineered Windsurf protocol (Python implementation).

Python License: MIT MCP

Overview

Fast Context MCP provides an AI-powered semantic code search tool through the Model Context Protocol (MCP). It leverages a reverse-engineered Windsurf protocol to deliver intelligent code context retrieval for LLMs and development workflows.

Related MCP server: code-rag-mcp

Features

  • AI-Powered Semantic Search: Natural language queries to find relevant code

  • MCP Server Integration: Compatible with MCP-enabled clients (Claude Desktop, etc.)

  • Protobuf Protocol: Efficient binary communication with Windsurf API

  • Tree-based Context: Includes directory structure for better code understanding

  • Multi-language Support: Works with any codebase (Python, JavaScript, Go, etc.)

Installation

From PyPI (Recommended)

pip install fast-context-mcp

From Source

git clone https://github.com/YOUR_USERNAME/fast-context-mcp-py.git
cd fast-context-mcp-py
pip install -e .

Usage

As an MCP Server

Add to your Claude Desktop configuration (claude_desktop_config.json):

{
  "mcpServers": {
    "fast-context": {
      "command": "python",
      "args": ["-m", "fast_context_mcp.server"]
    }
  }
}

Programmatic Usage

from fast_context_mcp.search import search_with_content

result = search_with_content(
    query="Find the authentication middleware",
    project_root="/path/to/your/project"
)
print(result)

Available Tools

search_code

Search for relevant code in a codebase using AI-powered semantic search.

Parameters:

  • query (string): Natural language description of what you're looking for

  • project_root (string): Absolute path to the project root directory

Returns: JSON-formatted search results with relevant file paths and line ranges.

Architecture

fast_context_mcp/
├── core.py        # Core search implementation & API communication
├── search.py      # Search orchestration and result formatting
├── server.py      # MCP server implementation
├── protobuf.py    # Protobuf encoding/decoding
├── executor.py    # Tool execution with context management
└── rg_installer.py # Ripgrep auto-installer

Protocol Details

The project implements a reverse-engineered version of Windsurf's internal protocol:

  1. Connect Frame: Binary protobuf handshake with magic bytes (0x0001)

  2. Session Management: UUID-based session tracking

  3. Tool Definitions: JSON Schema-based tool specifications

  4. Response Streaming: Chunked protobuf responses with gzip compression

Development

Setup

# Install development dependencies
pip install -e ".[dev]"

Running Tests

pytest

Linting

ruff check .
ruff format .

License

MIT License - see LICENSE file for details.

Acknowledgments

Disclaimer

This project is a reverse-engineered implementation for educational purposes. It is not affiliated with or endorsed by Codeium/Windsurf.

Available Tools

1 tool
search_codeB

Search for relevant code in a codebase using AI-powered semantic search.

Args: query: Natural language description of what you're looking for. project_root: Absolute path to the project root directory.

ParametersJSON Schema
NameRequiredDescriptionDefault
queryYes
project_rootYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

B3.1/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 behavioral burden, yet it discloses nothing about result count limits, ranking, whether the search is read-only against an index, latency, or how the project root is used (indexed vs scanned). For a search tool with zero annotation coverage this is thin.

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?

Purpose is front-loaded in a single sentence, followed by a compact Args block. The structure is efficient, with the only mild redundancy being the restatement of parameter names already visible in the schema.

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?

An output schema exists, so return values need not be explained, and both parameters are described. However, with no annotations and no coverage of result limits, ranking, or index prerequisites, an agent still lacks enough context to predict what the call will do at scale.

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

Parameters4/5

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

Schema description coverage is 0% — the properties carry only titles — so the description must compensate, and it does: it explains 'query' is a natural-language description and 'project_root' must be an absolute path. That is meaningful added detail for both required parameters, though it omits format examples or constraints.

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?

States a specific verb and resource ('Search for relevant code in a codebase') and adds the retrieval mechanism ('AI-powered semantic search'), which tells an agent this is not a literal/textual grep. No siblings exist to differentiate against, so it cannot reach 5 on that criterion.

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 when-to-use guidance, no statement of when this is preferable to a conventional text or symbol search, and no prerequisites or exclusions. The phrase 'semantic search' only implicitly hints at the right context.

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.

  1. 1 tool updatev1.0.0
    • First observedsearch_code
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 across 1 tool

Disambiguation5/5

Only one tool exists, so there is no possibility of confusion with any other tool in this server.

Naming Consistency5/5

The single tool name 'search_code' follows a clear verb_noun convention, though consistency across a set cannot be meaningfully evaluated with one tool.

Tool Count2/5

A single tool for an entire MCP server is thin; even for a narrow semantic search service, users would likely expect at least indexing or context-management operations.

Completeness2/5

The surface is severely limited: there is no indexing, no result retrieval beyond search, no configuration, and no way to manage or refresh the codebase context.

Maintenance

ActivityInactive
ResponsivenessNo issues

Resources

Related MCP Connectors

Related MCP Servers

  • mcp-deepcontext

    jmerelnyc
    A
    license
    Not graded
    quality
    D
    maintenance
    MCP server enabling symbol-aware semantic search in Claude Code, allowing precise location of functions, types, and implementations via a symbol graph and embeddings.
    9
    MIT

  • code-rag-mcp

    qduc
    A
    license
    A
    quality
    D
    maintenance
    Enables semantic search over codebases using natural language queries, returning relevant code snippets with source locations. Integrates with Claude Code for automatic codebase exploration.
    1
    1
    MIT

  • Cortex

    Remskill
    A
    license
    Not graded
    quality
    D
    maintenance
    Enables AI coding assistants to semantically search and retrieve relevant code patterns, documentation, and implementations from a codebase via MCP tools.
    8
    MIT

  • code-context-v2

    enzodevs
    A
    license
    Not graded
    quality
    A
    maintenance
    Enables semantic code search across indexed codebases using natural language queries, with support for CLI and MCP interfaces.
    1
    MIT