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

> Discover the programming languages supported by DeusData codebase-memory-mcp. This guide covers C, C++, Python, TypeScript, Go, and Shell for comprehensive polyglot development.

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

---

**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`](https://github.com/DeusData/codebase-memory-mcp/blob/main/src/main.c), the entry point initializes the custom allocator and starts the JSON-RPC server:

```c
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`](https://github.com/DeusData/codebase-memory-mcp/blob/main/src/watcher/watcher.c) for Git workspace monitoring and [`src/pipeline/pipeline.h`](https://github.com/DeusData/codebase-memory-mcp/blob/main/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`](https://github.com/DeusData/codebase-memory-mcp/blob/main/internal/cbm/vendored/simplecpp/simplecpp.cpp) to handle header file analysis.

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

```cpp
#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`](https://github.com/DeusData/codebase-memory-mcp/blob/main/pkg/pypi/src/codebase_memory_mcp/_cli.py) module exposes a Pythonic API for running tools programmatically:

```python
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`](https://github.com/DeusData/codebase-memory-mcp/blob/main/graph-ui/vite.config.ts) configures the build pipeline, while RPC clients in [`graph-ui/src/api/rpc.ts`](https://github.com/DeusData/codebase-memory-mcp/blob/main/graph-ui/src/api/rpc.ts) communicate with the backend:

```ts
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`](https://github.com/DeusData/codebase-memory-mcp/blob/main/pkg/go/cmd/codebase-memory-mcp/main.go), this wrapper simplifies process management for Go-centric toolchains:

```go
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`](https://github.com/DeusData/codebase-memory-mcp/blob/main/scripts/install.sh) script coordinates submodule initialization, native compilation, and UI bundling:

```bash
#!/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`](https://github.com/DeusData/codebase-memory-mcp/blob/main/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`](https://github.com/DeusData/codebase-memory-mcp/blob/main/src/main.c) and [`src/watcher/watcher.c`](https://github.com/DeusData/codebase-memory-mcp/blob/main/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`](https://github.com/DeusData/codebase-memory-mcp/blob/main/pkg/pypi/src/codebase_memory_mcp/_cli.py)
- **TypeScript** builds the visualization UI using Vite configurations in [`graph-ui/vite.config.ts`](https://github.com/DeusData/codebase-memory-mcp/blob/main/graph-ui/vite.config.ts)
- **Go** offers an alternative launcher at [`pkg/go/cmd/codebase-memory-mcp/main.go`](https://github.com/DeusData/codebase-memory-mcp/blob/main/pkg/go/cmd/codebase-memory-mcp/main.go)
- **Shell** scripts automate cross-language builds in [`scripts/install.sh`](https://github.com/DeusData/codebase-memory-mcp/blob/main/scripts/install.sh) and [`scripts/setup.sh`](https://github.com/DeusData/codebase-memory-mcp/blob/main/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`](https://github.com/DeusData/codebase-memory-mcp/blob/main/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.