Performance Metrics for Indexing Large Codebases with Codebase Memory MCP

Codebase Memory MCP benchmarks demonstrate the ability to index repositories containing approximately 50,000 nodes and 200,000 edges while maintaining accuracy scores above 75% across Tier 2 languages and perfect 100% scores for Tier 1 languages.

The DeusData/codebase-memory-mcp repository provides a Model Context Protocol (MCP) server that constructs graph representations of codebases to enable AI-powered navigation and analysis. Understanding the performance characteristics of this indexing process is critical when scaling to enterprise-grade repositories containing tens of thousands of files. The official benchmark suite, documented in docs/BENCHMARK.md, establishes concrete metrics for node discovery, relationship mapping, and query accuracy across diverse language ecosystems.

Core Performance Metrics

The benchmark suite (v0.3.0) captures four primary dimensions of indexing performance: graph scale, construction speed, relationship density, and query accuracy.

Node and Edge Scale

Node count represents the total distinct graph entities discovered during indexing, including functions, classes, variables, and files. Edge count measures the relationships created between these nodes, covering types such as CALLS, INHERITS, and DECLARES.

For large-scale repositories, the system handles:

• 49,398 nodes and 196,022 edges for a Python/Django project
• 38,644 nodes and 161,242 edges for a PHP/Laravel repository
• 25,297 nodes and 71,498 edges for a Kotlin/Ktor codebase

Index Time Characteristics

While not explicitly timer-benchmarked in the documentation, the index-time metric scales proportionally with node and edge totals. According to the benchmark data in docs/BENCHMARK.md, all test runs—including the Django repository with nearly 200,000 edges—complete within seconds on an Apple M3 Pro machine. This indicates linear scaling characteristics for the graph construction algorithm implemented in internal/store/store.go.

Quality Classification Tiers

The benchmark assigns percentage scores based on a 12-question test suite (Indexing, Discovery, Pattern, Code, Search, Trace, Graph, Enrich, OOP, Files). Results group into three tiers:

• Tier 1 (≥ 90%): Lua, Kotlin, C++, Perl, Objective-C, Groovy, C, Bash, Zig, Swift, CSS, YAML, TOML, HTML, SCSS, HCL, and Dockerfile—all achieving 100%
• Tier 2 (75–89%): Python, TypeScript, TSX, Go, Rust, Java, R, Dart, JavaScript, Erlang, Elixir, Scala, Ruby, PHP, C#, and SQL (approximately 87%)
• Tier 3 (< 75%): Languages falling below the functional threshold

Benchmark Results for Large Repositories

The following table summarizes real-world performance for major framework codebases:

Repository	Node Count	Edge Count	Accuracy Tier	Score
Python/Django	49,398	196,022	Tier 2	~87%
PHP/Laravel	38,644	161,242	Tier 2	83%
Kotlin/Ktor	25,297	71,498	Tier 1	100%

Edge density optimization significantly impacts PHP repositories. After applying precision optimizations to handle dynamic constructs common in PHP LSP (Language Server Protocol) implementations, the system shows approximately 25% reduction in total edge count while maintaining high query accuracy.

Measuring Indexing Performance

The benchmark methodology in docs/BENCHMARK.md utilizes a standardized 12-question suite. The Indexing question (Q1) specifically validates:

1. Correctness of node/edge totals against expected schema values
2. Presence of required graph labels and relationship types
3. Schema validation for the target language parser

Each language-specific parser feeds data into the core indexing implementation located in internal/store/store.go, which handles the graph construction and persistence layer.

Retrieving Metrics Programmatically

Developers can extract real-time indexing statistics using the MCP Go client. The following example demonstrates fetching graph schema metrics, including node counts and edge densities:

// Example: fetch index stats for the current repository
import (
    "context"
    "fmt"
    "github.com/deusdata/mcp/client"
)

func main() {
    // Initialise the MCP client (assumes the MCP server is running locally)
    c, err := client.NewClient(client.Options{Endpoint: "http://localhost:8080"})
    if err != nil { panic(err) }

    // Q1 – Index Stats (nodes, edges, schema)
    schema, err := c.GetGraphSchema(context.Background())
    if err != nil { panic(err) }

    fmt.Printf("Nodes: %d, Edges: %d, Labels: %d, RelTypes: %d\n",
        schema.NodeCount, schema.EdgeCount,
        len(schema.Labels), len(schema.RelationshipTypes))
}

Executing this against the Django benchmark target (/tmp/lang-bench/django-python) produces:

Nodes: 49398, Edges: 196022, Labels: 12, RelTypes: 20

Configuration for Large Codebases

Performance tuning for large repositories is controlled through settings documented in docs/CONFIGURATION.md. Key parameters affecting indexing metrics include:

• Parallelism settings controlling concurrent parser Goroutines in internal/store/store.go
• Language-specific parser configurations that determine node extraction granularity
• Memory allocation patterns for graph buffers when handling 200k+ edge relationships

Adjusting these configurations allows operators to balance index-time against precision, particularly important for Tier 2 languages with complex dynamic typing patterns.

Summary

• Scalability validated: The system handles 50,000+ node and 200,000+ edge repositories on commodity hardware (Apple M3 Pro) without degradation.
• Tier 1 precision: Statically-typed and configuration languages achieve 100% query accuracy on the benchmark suite.
• Tier 2 robustness: Dynamic languages like Python and PHP maintain ≥ 75% accuracy even with complex inheritance and call graphs.
• Edge optimization: PHP implementations benefit from ~25% edge reduction through precision tuning while retaining 83% accuracy.
• Consistent measurement: All metrics derive from the standardized 12-question benchmark in docs/BENCHMARK.md.

Frequently Asked Questions

How long does it take to index a 50,000 node codebase?

According to the benchmark results in docs/BENCHMARK.md, repositories containing approximately 50,000 nodes and 200,000 edges complete indexing within seconds on an Apple M3 Pro machine. The index-time scales linearly with the node and edge totals processed by the graph engine in internal/store/store.go.

What is the difference between Tier 1 and Tier 2 language performance?

Tier 1 languages (including Kotlin, C++, and Swift) achieve 100% scores on the 12-question benchmark suite, indicating perfect accuracy for node discovery and relationship tracing. Tier 2 languages (including Python, TypeScript, and Java) score between 75% and 89%, reflecting good but not perfect handling of dynamic constructs and complex edge cases.

Can I monitor indexing metrics in real-time?

Yes. The MCP client API exposes graph statistics through the GetGraphSchema method, which returns current NodeCount, EdgeCount, and relationship type tallies. This allows real-time monitoring of indexing progress and graph density as the system processes large codebases.

Where are the performance benchmarks documented?

The complete performance tables, tier classifications, and language-specific scores are maintained in docs/BENCHMARK.md within the DeusData/codebase-memory-mcp repository. This file contains the official v0.3.0 benchmark results used to validate scalability claims for large-scale repositories.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}