System Requirements for Running codebase-memory-mcp: Cross-Platform Guide

codebase-memory-mcp is a fully static, single-binary tool with zero runtime dependencies that runs natively on macOS (Intel/Apple Silicon), Linux (x86_64/arm64), and Windows (amd64), requiring only a standard C runtime environment to execute.

The DeusData/codebase-memory-mcp repository distributes a high-performance code indexing tool written in Pure C. Understanding the system requirements for running codebase-memory-mcp ensures optimal performance whether you are installing pre-built binaries from the releases page or compiling the source from internal/cbm/ using Makefile.cbm.

Supported Platforms and Operating Systems

The project maintains native binaries for three major desktop operating systems. According to the README.md badge documentation, platform support is comprehensive across standard architectures.

macOS

• Apple Silicon (arm64 architecture)
• Intel (amd64 architecture)

Both architectures receive native binary support without requiring Rosetta translation.

Linux

• x86_64 (standard 64-bit Intel/AMD processors)
• arm64 (ARM 64-bit architecture, including AWS Graviton and Raspberry Pi 4+)

Windows

• amd64 (64-bit Windows environments)

Windows support is provided via native binaries without requiring WSL or Cygwin.

Runtime Dependencies

Zero runtime dependencies are required to execute the pre-built binary. As documented in the repository's README.md, the tool compiles to a fully static executable that interfaces directly with the OS kernel. This design eliminates dynamic linking issues, DLL hell, and library version conflicts across different system configurations.

Build-from-Source Prerequisites

If compiling from the source code located in internal/cbm/, you need the following toolchain components listed in the build prerequisites table:

• C compiler (gcc or clang)
• C++ compiler (g++ or clang++)
• zlib development headers (zlib1g-dev on Debian/Ubuntu systems, zlib-devel on RHEL/Fedora)
• Git (for cloning the repository; pre-installed on most modern systems)
• Node.js 22+ (only required if building the optional UI variant)

The build orchestration uses Makefile.cbm to handle tree-sitter integration and graph construction logic.

Memory and CPU Requirements

The indexing pipeline loads the entire code graph into RAM for maximum query performance. Based on benchmarks documented in docs/BENCHMARK.md:

• A full index of the Linux kernel (approximately 28 million lines of code) completes in roughly 3 minutes on modern workstation hardware
• This operation consumes 4–6 GB of RAM during peak usage
• Memory consumption scales linearly with repository size

To constrain memory usage on resource-limited systems, set the CBM_MEM_BUDGET_MB environment variable before execution. Configuration details are available in docs/CONFIGURATION.md.

Network Requirements

Network connectivity is only required during installation. You need internet access to run the one-line installer (curl on Unix systems or Invoke-WebRequest on Windows via install.ps1) or to download pre-built releases from GitHub. Once the binary is present on your system, codebase-memory-mcp operates fully offline without external API calls or cloud dependencies.

Optional UI Variant Requirements

The optional 3-D visualization interface imposes additional system requirements:

• A graphical environment (X11 or Wayland on Linux, macOS WindowServer, or Windows desktop)
• The separate UI binary (installed via the --ui flag in install.sh)
• Node.js 22+ if building from source with UI support enabled

The UI variant is not required for core CLI functionality like indexing or querying.

Installation and Verification

Use the automated installers to deploy the binary and verify your system meets the runtime requirements:

# Install pre-built binary (macOS/Linux)

curl -fsSL https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/install.sh | bash

# Verify installation and platform compatibility

codebase-memory-mcp --version

To install with the optional graphical interface:

curl -fsSL https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/install.sh | bash -s -- --ui

When indexing large repositories on memory-constrained systems, specify a memory limit:

CBM_MEM_BUDGET_MB=4096 codebase-memory-mcp cli index_repository '{"repo_path":"/path/to/project"}'

Execute graph queries against the indexed codebase:

codebase-memory-mcp cli query_graph '{"project":"my-project","query":"MATCH (f:Function) RETURN f.name LIMIT 5"}'

Summary

• codebase-memory-mcp runs natively on macOS, Linux, and Windows without runtime dependencies or containerization
• Pre-built static binaries require only the OS kernel; building from source requires C/C++ compilers, zlib headers, and Git
• Indexing large codebases (28M+ LOC) requires 4–6 GB RAM, configurable via the CBM_MEM_BUDGET_MB environment variable
• The tool operates offline after installation; network is only needed for initial binary download
• Optional UI features require a graphical environment and Node.js 22+ when building from source

Frequently Asked Questions

Does codebase-memory-mcp require Docker or containerization?

No. The tool is distributed as a native static binary with no containerization required. You can run it directly on your host operating system after installation via the provided install.sh or install.ps1 scripts, or by downloading the appropriate release asset for your platform.

Can I run codebase-memory-mcp on a headless server without a GUI?

Yes. The core indexing and query functionality operates entirely via command-line interface as implemented in internal/cbm/. The UI variant is optional; the CLI tool runs on headless Linux servers, remote SSH sessions, and CI/CD pipelines without X11, Wayland, or desktop environment dependencies.

How much RAM do I need for a medium-sized repository?

For repositories under 5 million lines of code, 2–4 GB of RAM is typically sufficient. The tool respects the CBM_MEM_BUDGET_MB environment variable to cap consumption if you encounter memory pressure. Refer to docs/BENCHMARK.md for detailed performance metrics relative to specific codebase sizes.

Is Apple Silicon natively supported or does it require Rosetta?

Native Apple Silicon (arm64) is fully supported without Rosetta translation. The project provides separate binaries for both Apple Silicon and Intel architectures in the releases page, ensuring optimal performance on M1, M2, M3, and M4 Macs.

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