home / mcp / roberto mcp server

Roberto MCP Server

A fast, language-agnostic MCP server in Rust for symbol lookups, references, and semantic code search across large codebases.

Installation

Add the following to your MCP client configuration file.

Configuration

View docs

{
  "mcpServers": {
    "kensave-roberto-mcp": {
      "command": "./target/release/roberto-mcp",
      "args": [],
      "env": {
        "RUST_LOG": "info",
        "ROBERTO_CACHE_DIR": "~/.cache/roberto-mcp",
        "ROBERTO_MAX_MEMORY_MB": "1024",
        "ROBERTO_EVICTION_THRESHOLD": "0.8"
      }
    }
  }
}

Roberto MCP is a high-performance, language-agnostic code analysis server. Built in Rust, it delivers fast symbol lookups, reference tracking, and semantic code search across large codebases, with robust concurrency and incremental updates to keep up with your development workflow.

How to use

You will run Roberto MCP locally and connect your MCP client to it to index your codebase, search for symbols, and explore references. Start the server, index a repository or directory, and then perform queries such as finding symbols by name, retrieving symbol details with source, and performing full-text code searches. The client can issue these actions using the MCP protocol; your job is to start Roberto MCP and point the client at the running process.

Practical use patterns include: indexing a project directory, querying for all references to a symbol, discovering the outline of a file, and performing BM25-based searches across all indexed code content. You can also request a directory-wide overview to understand the API surface and architecture of your codebase.

How to install

Prerequisites you need before building and running Roberto MCP:

Rust 1.70+
Cargo

Step-by-step commands to clone, build, and run the server locally:

# Clone the project
git clone https://github.com/kensave/roberto-mcp.git
cd roberto-mcp

# Build in release mode
cargo build --release

# Run the server (stdio-based, local process)
./target/release/roberto-mcp

Configuration and running locally

The server runs as a local process using standard input/output (stdio). You start the binary directly and then communicate with it using the MCP protocol over stdio. You can customize memory usage and logging with environment variables when starting the server.

Environment variables shown for configuring the server are: - ROBERTO_MAX_MEMORY_MB: maximum memory in MB to use - ROBERTO_EVICTION_THRESHOLD: memory pressure threshold for LRU eviction - ROBERTO_CACHE_DIR: location of the cache on disk - RUST_LOG: logging level and module filters (e.g., info, debug, trace)

Troubleshooting

If the server does not respond or you encounter errors, check the following common areas: verify the binary path is correct and executable, ensure memory limits are appropriate for your repository size, and review logs for any initialization or IO errors. If you enable debug or trace logs, you can pinpoint bottlenecks or failing components.

Testing & validation

To validate behavior locally, run unit and integration tests and perform manual commands against the running server. Use the provided tooling to simulate indexing, symbol queries, and code searches to confirm correct responses.

Available tools

index_code

Index source code to build the symbol table used for fast lookups.

get_symbol

Retrieve symbol information by name with optional source inclusion.

get_symbol_references

Find all references to a symbol across the codebase.

find_symbols

Search symbols by query with exact or fuzzy matching and optional type filtering.

code_search

BM25-based full-text search across all indexed code content.

get_file_outline

Get a structured outline of symbols within a specific file.

get_directory_outline

Get a high-level overview of symbols across a directory.