# What Database Technology Is Used for Graph Storage in codebase-memory-mcp?

> Explore codebase-memory-mcp and discover its graph storage solution. It leverages an embedded SQLite database for a lightweight, file-based graph store without external servers.

- Repository: [Martin Vogel/codebase-memory-mcp](https://github.com/DeusData/codebase-memory-mcp)
- Tags: database-technology
- Published: 2026-07-05

---

**The graph storage in codebase-memory-mcp uses an embedded SQLite database, utilizing a vendored copy of SQLite to provide a lightweight, file-based graph store without requiring an external server.**

The DeusData/codebase-memory-mcp module persists graph data using an embedded SQLite database rather than external graph databases. This architectural choice embeds a complete SQLite engine directly into the package through vendored source files, enabling zero-configuration deployment while maintaining ACID compliance for graph operations. Understanding what database technology is used for graph storage in this module reveals a design optimized for local development and CI/CD environments.

## Embedded SQLite as the Graph Storage Engine

The module implements graph persistence through an **embedded SQLite database** shipped as a vendored dependency. Unlike client-server architectures requiring separate database installations, the repository includes complete SQLite source code in the `vendored/sqlite3/` directory.

Specifically, the [`vendored/sqlite3/sqlite3.h`](https://github.com/DeusData/codebase-memory-mcp/blob/main/vendored/sqlite3/sqlite3.h) header file and [`vendored/sqlite3/sqlite3.c`](https://github.com/DeusData/codebase-memory-mcp/blob/main/vendored/sqlite3/sqlite3.c) implementation file compile directly into the package. This bundling strategy eliminates external dependencies while providing full SQL capabilities for graph storage operations.

## How the Graph Database Path Is Configured

Graph data storage location is controlled through the **`CBM_CACHE_DIR`** environment variable. When set, this variable designates the directory where the SQLite database file is created and accessed.

In [`tests/windows/mcp_stdio.py`](https://github.com/DeusData/codebase-memory-mcp/blob/main/tests/windows/mcp_stdio.py) at line 30, test code demonstrates this configuration by isolating the graph database to a specific cache directory. The library uses this path to initialize the SQLite connection, treating the designated folder as the container for the graph storage file.

## Working with the SQLite-Backed Graph Store

You can interact with the graph storage by configuring the cache directory and invoking the CLI. The following example demonstrates how to isolate the graph database and execute Cypher-like queries against the embedded SQLite store:

```python
import os
import subprocess

# 1️⃣ Isolate the graph database directory for a test run

cache_dir = "/tmp/graph-cache"
env = os.environ.copy()
env["CBM_CACHE_DIR"] = cache_dir   # ← points the module to a SQLite file in this folder

# 2️⃣ Run the CLI that accesses the graph (the CLI internally opens the SQLite DB)

result = subprocess.run(
    ["codebase-mcp", "query_graph", "--query", "MATCH (n) RETURN n LIMIT 5"],
    env=env,
    capture_output=True,
    text=True,
)
print(result.stdout)   # → JSON-encoded rows from the embedded SQLite graph DB

```

This workflow illustrates how the module uses the `CBM_CACHE_DIR` environment variable to locate the SQLite file, with the `codebase-mcp` CLI entry point handling the database connection internally via the bundled SQLite library.

## Key Source Files Confirming SQLite Implementation

Several critical files in the DeusData/codebase-memory-mcp repository confirm the SQLite-based architecture:

- **[`vendored/sqlite3/sqlite3.h`](https://github.com/DeusData/codebase-memory-mcp/blob/main/vendored/sqlite3/sqlite3.h)** – The header file defining the SQLite C API used for graph storage operations.
- **[`vendored/sqlite3/sqlite3.c`](https://github.com/DeusData/codebase-memory-mcp/blob/main/vendored/sqlite3/sqlite3.c)** – The complete SQLite engine implementation compiled into the module.
- **[`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)** – The CLI entry point that initializes connections to the SQLite-backed graph store.
- **[`tests/windows/mcp_stdio.py`](https://github.com/DeusData/codebase-memory-mcp/blob/main/tests/windows/mcp_stdio.py)** – Contains test utilities demonstrating the `CBM_CACHE_DIR` environment variable configuration at line 30.

These files collectively establish that **SQLite** serves as the underlying database technology for graph storage, implemented as an embedded, zero-dependency solution.

## Summary

- **SQLite** is the database technology used for graph storage in codebase-memory-mcp, implemented as an embedded engine rather than a client-server architecture.
- The repository includes a **vendored copy of SQLite** in `vendored/sqlite3/`, compiling the database engine directly into the package.
- Graph storage location is configured via the **`CBM_CACHE_DIR`** environment variable, which specifies the SQLite file path.
- The CLI interface in [`_cli.py`](https://github.com/DeusData/codebase-memory-mcp/blob/main/_cli.py) handles database connections automatically, allowing querying via standard subprocess calls without manual connection management.
- This architecture provides a **lightweight, file-based graph store** suitable for local development and automated testing environments.

## Frequently Asked Questions

### Does codebase-memory-mcp require an external database server?

No, codebase-memory-mcp does not require an external database server. The module uses an **embedded SQLite database** that compiles directly into the package from the vendored source files in `vendored/sqlite3/`. This design provides self-contained graph storage using local files, eliminating the need for separate database installation or network configuration.

### How do I specify where the graph database is stored?

Set the **`CBM_CACHE_DIR`** environment variable to designate the directory for the SQLite database file. As shown in [`tests/windows/mcp_stdio.py`](https://github.com/DeusData/codebase-memory-mcp/blob/main/tests/windows/mcp_stdio.py) at line 30, this variable points the module to the specific filesystem location where graph data persists. The CLI and library internals automatically create and manage the SQLite file within this directory.

### What type of queries can I run against the graph storage?

The codebase-memory-mcp CLI supports **Cypher-like graph queries** executed against the embedded SQLite backend. As demonstrated in the code example, you can invoke `codebase-mcp query_graph` with `--query` parameters containing pattern matching syntax such as `MATCH (n) RETURN n LIMIT 5`. The query processor translates these graph operations into SQLite operations while maintaining the property graph model.

### Why does the repository include SQLite source code instead of using a dependency?

The repository includes SQLite as a **vendored dependency** in `vendored/sqlite3/` to ensure consistent behavior across platforms and eliminate external build requirements. By compiling [`sqlite3.c`](https://github.com/DeusData/codebase-memory-mcp/blob/main/sqlite3.c) directly into the package, the module guarantees that the specific SQLite version supporting its graph storage features is always available, regardless of system-level package managers or installation constraints.