Skip to main content
Glama
Parado-xy

Seroost Search MCP Server

by Parado-xy
OverviewSchemaSourceRelated ServersDiscussionsAdmin
JavaScript
Local

Seroost Search MCP Server

A Model Context Protocol (MCP) server that provides AI agents with powerful codebase search capabilities using the Seroost semantic search engine.

Features

  • Semantic Code Search: Find functions, classes, and code patterns using natural language queries

  • Ranked Results: Get relevance-scored search results with line numbers and file paths

  • Fast Indexing: Quick indexing of entire codebases including dependencies

  • MCP Integration: Works with any MCP-compatible AI system (Claude, VS Code Copilot, etc.)

  • JSON API: Structured responses perfect for programmatic use

Related MCP server: Acemcp

Prerequisites

  • Node.js 18+

  • Seroost installed and built in release mode

  • TypeScript (for development)

Installation

  1. Install Seroost (if not already installed):

    # Clone and build Seroost
git clone https://github.com/Parado-xy/seroost
cd seroost
cargo build --release
# Make sure the binary is in your PATH

  2. Clone this repository:

    git clone https://github.com/Parado-xy/semantic-search-mcp
cd search-mcp

  3. Install dependencies:

    npm install

  4. Build the project:

    npm run build

Usage

As an MCP Server

Configure your MCP client to use this server:

{
  "mcpServers": {
    "seroost-search": {
      "command": "node",
      "args": ["/path/to/search-mcp/build/index.js"]
    }
  }
}

Available Tools

seroost_set_index

Configure the target directory for indexing.

Parameters:

  • path (string): Absolute path to the directory to index

Example:

{
  "name": "seroost_set_index",
  "arguments": {
    "path": "/home/user/my-project"
  }
}

seroost_index

Build the search index for the configured directory.

Parameters: None (uses path set by seroost_set_index)

Example:

{
  "name": "seroost_index",
  "arguments": {}
}

seroost_search

Search through the indexed codebase.

Parameters:

  • query (string): Search term, function name, or natural language description

Example:

{
  "name": "seroost_search",
  "arguments": {
    "query": "user authentication functions"
  }
}

Response:

{
  "query": "user authentication functions",
  "results": [
    {
      "rank": 1,
      "path": "/home/user/project/src/auth.js",
      "score": 0.8543,
      "line_matches": [
        {
          "line": 42,
          "content": "function authenticateUser(credentials) {"
        }
      ]
    }
  ]
}

Workflow

  1. Set Index Path: Use seroost_set_index to configure which directory to search

  2. Build Index: Run seroost_index to process and index all files

  3. Search: Use seroost_search to find relevant code with natural language queries

Example Searches

  • "function createUser" - Find user creation functions

  • "error handling" - Find error handling patterns

  • "database connection" - Find database-related code

  • "React components" - Find React component definitions

  • "API endpoints" - Find REST API route definitions

Development

Building

npm run build

Project Structure

src/
├── index.ts        # MCP server setup and tool definitions
├── commands.ts     # Seroost command wrappers
build/              # Compiled JavaScript output

How It Works

This MCP server acts as a bridge between AI agents and the Seroost search engine:

  1. Indexing: Seroost processes your codebase and creates a searchable index

  2. Querying: AI agents send search queries through the MCP protocol

  3. Results: Seroost returns ranked, relevant code snippets with metadata

  4. Integration: AI agents can use these results to understand and work with your code

Benefits for AI Agents

  • Faster Code Discovery: Find relevant code without reading entire files

  • Semantic Understanding: Search by intent, not just exact text matches

  • Contextual Results: Get ranked results with relevance scores

  • Large Codebase Support: Handle projects with thousands of files

  • Cross-File Analysis: Find usage patterns across the entire project

License

ISC

Contributing

Contributions welcome! Please feel free to submit issues and pull requests.

Related Projects

Available Tools

3 tools
seroost_indexA

Build the search index for the previously configured directory path. This processes all files in the target directory and creates a searchable index. Must run after setting the index path with seroost_set_index. Indexing may take time for large codebases but enables fast subsequent searches.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

A4.6/5.0
Behavior4/5

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

With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: it's a processing operation that creates a searchable index, has a prerequisite dependency on another tool, may have significant execution time for large inputs, and enables subsequent fast searches. It doesn't mention error conditions or specific performance characteristics, keeping it from a perfect score.

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?

Three well-structured sentences with zero waste: first states the core purpose, second explains the processing scope and output, third provides crucial usage guidance and performance context. Every sentence earns its place by adding distinct value.

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?

For a zero-parameter tool with no annotations or output schema, the description provides excellent context about purpose, prerequisites, behavioral characteristics, and relationship to siblings. It doesn't specify exact return values or error conditions, but given the tool's simplicity, this is reasonably complete.

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?

The tool has zero parameters with 100% schema description coverage, so the baseline would be 4. The description adds value by explaining that parameters come from 'previously configured directory path' set via 'seroost_set_index', providing important context about how configuration flows between tools.

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 specific action ('Build the search index'), resource ('previously configured directory path'), and scope ('processes all files in the target directory'). It distinguishes from sibling tools by mentioning the prerequisite relationship with 'seroost_set_index' and contrasting with 'seroost_search' through its indexing function.

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

Usage Guidelines5/5

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

Explicitly states when to use ('Must run after setting the index path with seroost_set_index') and provides context about alternatives by contrasting with 'seroost_search' (this tool builds the index while the sibling searches it). It also gives practical guidance about timing considerations ('may take time for large codebases').

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

seroost_set_indexA

Configure the target directory for Seroost indexing. This sets the root path that will be indexed when the index command is run. Must be called before indexing to specify which codebase directory to search.

ParametersJSON Schema
NameRequiredDescriptionDefault
pathYesAbsolute path to the directory containing the codebase to index. This directory and all its subdirectories will be searchable after indexing.

TDQS

A4.2/5.0
Behavior3/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 states the tool configures a directory for indexing, implying a write/mutation operation, but doesn't disclose behavioral details like whether this overwrites previous settings, requires specific permissions, or has side effects. The description adds basic context about the tool's role in the indexing process but lacks richer behavioral transparency.

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 two sentences, front-loaded with the core purpose, followed by a crucial usage guideline. Every sentence earns its place by providing essential information without redundancy or fluff, making it highly efficient and well-structured.

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 moderate complexity (a configuration step with one parameter), no annotations, and no output schema, the description is largely complete. It explains the purpose, usage timing, and relationship to other tools. However, it could improve by mentioning what happens if called multiple times or error conditions, slightly reducing completeness.

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 schema already fully documents the single 'path' parameter. The description adds no additional parameter semantics beyond what the schema provides (e.g., no extra syntax, format, or usage details), meeting the baseline score when schema coverage is high.

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 specific action ('Configure the target directory') and resource ('Seroost indexing'), distinguishing it from sibling tools like 'seroost_index' (which presumably runs indexing) and 'seroost_search' (which searches the index). It explicitly defines the tool's role in setting the root path for indexing operations.

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

Usage Guidelines5/5

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

The description provides explicit usage guidance: 'Must be called before indexing to specify which codebase directory to search.' This clearly indicates when to use this tool (as a prerequisite step) versus its siblings, establishing a workflow sequence without ambiguity.

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. 3 tool updatesv1.0.0
    • First observedseroost_index
    • First observedseroost_search
    • First observedseroost_set_index
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

A4.4/5.0

Scored across 3 tools

Disambiguation5/5

Each tool has a clearly distinct purpose with no overlap: seroost_set_index configures the directory, seroost_index builds the index, and seroost_search performs searches. The descriptions clearly differentiate the setup, indexing, and querying phases of the workflow, making misselection unlikely.

Naming Consistency5/5

All tool names follow a consistent 'seroost_' prefix with descriptive action-object patterns (set_index, index, search). The naming is uniform and predictable, using snake_case throughout without any deviations or mixed conventions.

Tool Count5/5

With 3 tools, the server is well-scoped for its purpose of code search indexing and querying. Each tool earns its place by covering essential steps: configuration, indexing, and searching, which is appropriate for a focused search functionality without unnecessary bloat.

Completeness5/5

The tool set provides complete coverage for the search domain, including configuration (set_index), index building (index), and querying (search). There are no obvious gaps—agents can fully manage the search workflow from setup to execution without dead ends.

Maintenance

ActivityInactive
ResponsivenessNo issues

Resources

Related MCP Connectors

Related MCP Servers

  • MCP Indexer

    gkatechis
    A
    license
    Not graded
    quality
    D
    maintenance
    Enables semantic code search across multiple repositories using natural language queries. Provides intelligent code discovery, symbol lookups, and cross-repo dependency analysis for AI coding agents.
    MIT

  • Acemcp

    qy527145
    A
    license
    A
    quality
    F
    maintenance
    Enables semantic code search across codebases with automatic incremental indexing. Searches return relevant code snippets with file paths and line numbers based on natural language queries.
    1
    805
    Apache 2.0

  • PAMPA

    tecnomanu
    A
    license
    Not graded
    quality
    C
    maintenance
    Provides semantic code search and retrieval capabilities for AI agents, enabling them to query codebases using natural language with automatic learning, hybrid search, and intelligent chunking of functions and classes.
    13 npm
    30
    ISC

  • codebase-mcp

    theunreal
    F
    license
    Not graded
    quality
    D
    maintenance
    Enables AI agents to semantically search and navigate code repositories using natural language, with support for multiple repos, incremental indexing, and no local install needed.
    -

Appeared in Searches