How ArcLume's MCP Server Gives Your IDE Cross-Repo Context

Your AI coding tool sees one repository at a time. Maybe it indexes the files in your current workspace. Maybe it does a decent job with embeddings-based search within that single repo. But the moment your question spans two services — "what consumes this endpoint?" or "which repo handles the webhook for this event?" — it's guessing.

ArcLume's codebase MCP server solves this by giving your IDE access to a pre-built knowledge graph that spans all your connected repositories. Through the Model Context Protocol, your AI assistant can search code semantically, trace dependencies across service boundaries, and understand how your system fits together — all without leaving your editor.

What the MCP server provides

The ArcLume MCP server exposes a set of tools that any MCP-compatible client can call. These tools query the ArcLume backend, which maintains a continuously updated structural index of your connected repositories.

Here's what your AI assistant gets access to:

• search_code — Semantic search across all indexed repositories. Find code by intent, not just keywords. Filter by language, symbol type, or specific repo.
• ask_codebase — Natural language Q&A grounded in your actual code via RAG. Ask "how does authentication work?" and get an answer with file paths and function signatures.
• get_interfaces — Query detected cross-service interfaces: REST endpoints, Kafka topics, BullMQ queues, gRPC services. See which services produce and consume each interface.
• get_codebase_overview — High-level summary: repo count, file type distribution, symbol counts, index freshness.
• list_repos — See all connected and indexed repositories with metadata.
• get_outline — Get a structural outline of any file: exported symbols, imports, function signatures.
• trigger_index — Request a re-index of a repository after significant changes.

Setup: 5 minutes, any MCP client

The MCP server ships as an npm package. You configure it once in your editor's MCP settings with your API key and organization ID. No local database, no background process, no Docker container.

Prerequisites

• An ArcLume account with at least one connected and indexed repository
• An API key from Settings → MCP Setup in the ArcLume dashboard
• Node.js 18+ installed

Claude Code

Add to your ~/.claude/settings.json:

{
  "mcpServers": {
    "arclume": {
      "command": "npx",
      "args": ["-y", "@arclume/mcp-server"],
      "env": {
        "ARCLUME_API_KEY": "efk_your_api_key",
        "ARCLUME_ORG_ID": "your-org-id",
        "ARCLUME_API_URL": "https://arclume.dev/api/"
      }
    }
  }
}

MCP server for Cursor

Add to .cursor/mcp.json in your project root:

{
  "servers": {
    "arclume": {
      "command": "npx",
      "args": ["-y", "@arclume/mcp-server"],
      "env": {
        "ARCLUME_API_KEY": "efk_your_api_key",
        "ARCLUME_ORG_ID": "your-org-id",
        "ARCLUME_API_URL": "https://arclume.dev/api/"
      }
    }
  }
}

VS Code (with GitHub Copilot)

Add the same configuration to .vscode/mcp.json. The format is identical to Cursor.

Verify the connection

After restarting your editor, ask your AI assistant: "Use the ArcLume tools to get a codebase overview." If the connection is working, you'll see a summary of your indexed repositories, total embeddings, and file type distribution.

Cross-repo context in practice

The real value of a cross-repo MCP server shows up when your questions span service boundaries. Here are real workflows that become possible:

Tracing API consumers

You're about to change the response shape of GET /api/orders/:id. Before you do, you need to know which other services consume this endpoint.

Ask your AI assistant: "Which services call the orders endpoint? Use ArcLume to check cross-repo interfaces." The get_interfaces tool returns every detected consumer — even in repositories you don't have open locally.

Understanding event flows

Your team uses Kafka for async communication between services. You need to understand what happens when an order.completed event is published.

Ask: "What services consume the order.completed Kafka topic?" ArcLume's interface map shows you the producers and consumers, the handler functions, and the file paths — across all indexed repositories. For more on this specific use case, see Mapping Kafka Consumers Across Repositories with AST Parsing.

Finding existing implementations

Before building a new feature, you want to check if something similar already exists. Semantic search across a single repo might miss it if the implementation lives in a shared library or a different service.

Ask: "Search all repos for retry logic with exponential backoff." The search_code tool searches across every indexed repository, returning results ranked by semantic relevance with full file paths and dependency information.

Onboarding to unfamiliar services

You're picking up a ticket that involves a service you've never worked in. Instead of reading through the entire repo, ask your AI assistant to query ArcLume:

• "Give me an overview of the notification-service repo"
• "What are the main API endpoints in the notification service?"
• "How does the notification service receive events from the order service?"

Each answer is grounded in actual code, with specific file paths and function signatures you can navigate to immediately.

How it stays up to date

ArcLume automatically re-indexes repositories when you push to your default branch via the GitHub App webhook. The structural graph, embeddings, and interface maps update within minutes of a push. For branches or manual triggers, you can use the trigger_index MCP tool or the re-index button in the dashboard.

This means your MCP tools always reflect the current state of your system — not a stale snapshot from last week.

Beyond search: structural context

The key difference between ArcLume's MCP server and a generic code search tool is structural context. When search_code returns results, each result includes not just the code snippet but also:

• The symbol's imports and importers (what it depends on and what depends on it)
• The file's structural outline (sibling functions, class hierarchy)
• Detected interfaces the symbol participates in (REST endpoints it handles, events it publishes)

This structural metadata is what enables your AI assistant to generate code that integrates correctly with your existing system, rather than code that merely looks right. It's the foundation of what we call structural scoping — grounding every AI interaction in the real architecture of your codebase.

Get started

The MCP server is available to all ArcLume accounts. Connect your repositories, generate an API key, and follow the setup above. Your AI coding tools will never work blind again.

For a detailed walkthrough of using the MCP server with Lovable, see our guide: How to Use ArcLume with Lovable via MCP.