What Programming Languages Does Codebase-Memory-MCP Support? A Complete Polyglot Guide

The DeusData codebase-memory-mcp repository supports six primary programming languages: C for the core engine, C++ for preprocessor utilities, Python for CLI tooling, TypeScript for the frontend UI, Go for wrapper binaries, and Shell for build automation.

The codebase-memory-mcp project by DeusData is a polyglot codebase that leverages multiple languages to optimize for performance, developer experience, and cross-platform compatibility. Each language serves a specific architectural role, from low-level system operations to user-facing interfaces. Understanding this language distribution helps contributors navigate the repository and deploy the MCP server effectively across different environments.

Core Language Architecture

The project intentionally separates concerns across language boundaries. Performance-critical components run in native code, while higher-level automation uses dynamic languages.

C: The Core Engine

C powers the heart of the system. The MCP server implementation, SQLite integration, file-watching mechanisms, and the analysis pipeline all reside in C source files.

In src/main.c, the entry point initializes the custom allocator and starts the JSON-RPC server:

int main(int argc, char **argv) {
    /* Initialize allocator, parse command‑line, then run server */
    cbm_alloc_init();
    mcp_run();              // blocks on stdin/stdout JSON‑RPC
    return 0;
}

Additional critical C components include src/watcher/watcher.c for Git workspace monitoring and src/pipeline/pipeline.h for coordinating LSP analyses.

C++: Preprocessor Utilities

C++ appears primarily in vendored utilities. The repository includes a lightweight C++ preprocessor via internal/cbm/vendored/simplecpp/simplecpp.cpp to handle header file analysis.

Typical usage patterns involve creating a preprocessor instance and managing include paths:

#include "simplecpp.h"

int main() {
    SimplePP pp;
    pp.add_include_path("/usr/include");
    pp.process_file("example.cpp");
    return 0;
}

Python: CLI and Packaging

Python handles the PyPI package distribution and command-line interface entry points. The pkg/pypi/src/codebase_memory_mcp/_cli.py module exposes a Pythonic API for running tools programmatically:

from codebase_memory_mcp import _cli

# Equivalent to:   codebase-memory-mcp cli tool '{"key":"value"}'

result = _cli.run_cli(['tool', '{"key":"value"}'])
print(result)

This layer enables CI/CD integration and allows Python-based build systems to invoke the native MCP server without shelling out directly to binaries.

TypeScript: Frontend UI

TypeScript drives the graph visualization interface built with Vite. The graph-ui/vite.config.ts configures the build pipeline, while RPC clients in graph-ui/src/api/rpc.ts communicate with the backend:

import { rpc } from "./api/rpc";

async function loadGraph(projectId: string) {
  const graph = await rpc.request("graph/get", { projectId });
  console.log(graph.nodes.length, "nodes loaded");
}

Go: Binary Wrapper

Go provides an optional command-line wrapper around the compiled MCP binary. Located at pkg/go/cmd/codebase-memory-mcp/main.go, this wrapper simplifies process management for Go-centric toolchains:

package main

import (
    "os"
    "os/exec"
)

func main() {
    cmd := exec.Command("./codebase-memory-mcp", os.Args[1:]...)
    cmd.Stdout = os.Sstdout
    cmd.Stderr = os.Stderr
    cmd.Run()
}

Shell: Build Orchestration

Shell scripts (Bash) automate the complex build process across these languages. The scripts/install.sh script coordinates submodule initialization, native compilation, and UI bundling:

#!/usr/bin/env bash
set -e
./scripts/setup.sh          # pulls submodules, builds native components

./scripts/install.sh --ui   # compiles the TypeScript UI

Language-Specific Implementation Details

Each language tier integrates with specific vendored dependencies:

• C: Vendors sqlite3.c, mimalloc, zstd, and lz4 for database operations and compression
• C++: Includes simplecpp for header preprocessing without external dependencies
• Python: Exposes the _cli module for standardized tool invocation
• TypeScript: Uses Vite for fast development builds of the graph-ui components
• Go: Acts as a thin wrapper, forwarding arguments to the native binary
• Shell: Provides the glue between CMake builds, npm builds, and Python packaging

Summary

• C implements the MCP server core, file watcher, and SQLite integration in src/main.c and src/watcher/watcher.c
• C++ provides preprocessor functionality via vendored code in internal/cbm/vendored/simplecpp/
• Python powers the PyPI package and CLI interface through pkg/pypi/src/codebase_memory_mcp/_cli.py
• TypeScript builds the visualization UI using Vite configurations in graph-ui/vite.config.ts
• Go offers an alternative launcher at pkg/go/cmd/codebase-memory-mcp/main.go
• Shell scripts automate cross-language builds in scripts/install.sh and scripts/setup.sh

Frequently Asked Questions

Does codebase-memory-mcp require all six languages to build?

No. The core MCP server only requires C and the vendored C libraries to compile. The Python, TypeScript, and Go components are optional packaging layers that enhance usability but are not required to run the native server binary.

Why use C instead of Rust or Go for the core engine?

The choice of C enables maximum compatibility with existing C libraries like SQLite and minimizes binary size. According to the source code in src/main.c, the project uses a custom allocator (cbm_alloc_init()) and direct stdin/stdout JSON-RPC handling that benefits from C's minimal runtime overhead and predictable memory layout.

Can I extend the MCP server using Python?

Yes. While the core server runs as a compiled C binary, the Python package in pkg/pypi/src/codebase_memory_mcp/ wraps the binary and provides _cli.run_cli() for programmatic access. You can import this module in Python scripts to integrate codebase-memory-mcp into existing Python-based build pipelines or analysis tools.

Is the TypeScript UI mandatory for using the tool?

No. The TypeScript frontend in graph-ui/ is optional. The MCP server functions entirely via JSON-RPC over stdin/stdout. The web UI provides graph visualization convenience but does not affect the core code analysis capabilities implemented in the C backend.

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