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

> Discover the system requirements for codebase-memory-mcp. This static binary tool runs on macOS Linux and Windows with zero runtime dependencies needing only a standard C runtime.

- Repository: [Martin Vogel/codebase-memory-mcp](https://github.com/DeusData/codebase-memory-mcp)
- Tags: getting-started
- Published: 2026-07-27

---

**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](https://github.com/DeusData/codebase-memory-mcp/blob/main/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`](https://github.com/DeusData/codebase-memory-mcp/blob/main/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](https://github.com/DeusData/codebase-memory-mcp/blob/main/README.md):

- **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`](https://github.com/DeusData/codebase-memory-mcp/blob/main/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`](https://github.com/DeusData/codebase-memory-mcp/blob/main/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`](https://github.com/DeusData/codebase-memory-mcp/blob/main/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:

```bash

# 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:

```bash
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:

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

```

Execute graph queries against the indexed codebase:

```bash
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`](https://github.com/DeusData/codebase-memory-mcp/blob/main/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`](https://github.com/DeusData/codebase-memory-mcp/blob/main/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.