# Data Sources for MCP Tool Definitions in Codebase Memory MCP

> Discover MCP tool definitions directly compiled as a static C array in DeusData codebase-memory-mcp. Learn about their JSON schemas embedded in the binary.

- Repository: [Martin Vogel/codebase-memory-mcp](https://github.com/DeusData/codebase-memory-mcp)
- Tags: how-to-guide
- Published: 2026-07-03

---

**MCP tool definitions are hard-coded as a static C array in [`src/mcp/mcp.c`](https://github.com/DeusData/codebase-memory-mcp/blob/main/src/mcp/mcp.c), containing 14 tools with their JSON schemas compiled directly into the binary.**

In the DeusData/codebase-memory-mcp repository, understanding where tool metadata originates is critical for developers extending the Memory-Code-Project (MCP) server. Unlike configuration-driven architectures, the data sources for MCP tool definitions are embedded directly in the source code, eliminating external dependencies and ensuring consistent RPC responses.

## The Static TOOLS Array

The primary data source for all MCP tool definitions is the **`TOOLS`** array declared in [`src/mcp/mcp.c`](https://github.com/DeusData/codebase-memory-mcp/blob/main/src/mcp/mcp.c) (lines 311-395).

This static `TOOL_DEF_T` structure contains complete metadata for 14 distinct tools, including:

- **name**: The tool identifier used in RPC calls
- **title**: Human-readable label for the tool
- **description**: Detailed explanation of functionality
- **input_schema**: Raw JSON string defining parameters

### Structure of TOOL_DEF_T

Each entry in the `TOOLS` array follows this pattern:

```c
typedef struct {
    const char *name;
    const char *title;
    const char *description;
    const char *input_schema;  /* JSON string literal */
} TOOL_DEF_T;

```

The array is initialized with string literals at compile time, meaning the `input_schema` fields contain embedded JSON like `{"type":"object","properties":{...}}` directly in the C source.

## JSON Schemas and Output Definitions

The codebase separates input validation schemas from output specifications.

### Input Schemas

Each tool's input validation rules are stored as **raw JSON strings** within the `TOOLS` array entries. These schemas define required parameters, property types, and constraints. For example, the `search_graph` tool includes an input schema requiring a `project` parameter.

### Generic Output Schema

All 14 tools share a uniform output definition via the constant **`MCP_TOOL_OUTPUT_SCHEMA`** located at lines 500-502 in [`src/mcp/mcp.c`](https://github.com/DeusData/codebase-memory-mcp/blob/main/src/mcp/mcp.c):

```c
#define MCP_TOOL_OUTPUT_SCHEMA "{\"type\":\"object\",\"additionalProperties\":true}"

```

This generic schema is attached to every tool definition at runtime, allowing flexible return objects while maintaining MCP protocol compliance.

## How Tool Definitions Are Exposed

Static data becomes dynamic through helper functions that transform the compiled array into JSON-RPC responses.

### RPC Interface (tools/list)

When clients call the `tools/list` method, the server invokes **`cbm_mcp_tools_list()`**, which internally uses **`cbm_mcp_tools_list_range()`** (lines 514-560) to iterate the `TOOLS` array. The function **`mcp_add_tool_def`** serializes each struct into JSON format, injecting the constant output schema alongside the hard-coded input schemas.

### CLI Helper Functions

For command-line interfaces, **`cbm_mcp_tool_input_schema()`** (lines 668-680) provides direct lookup capabilities:

```c
const char *cbm_mcp_tool_input_schema(const char *name);

```

This function searches the static `TOOLS` array by name and returns the raw `input_schema` JSON string, enabling per-tool help generation without RPC overhead.

## Code Examples

### Listing All Tools Programmatically

Retrieve the complete tool catalog as a JSON string:

```c
#include "mcp.h"

char *json = cbm_mcp_tools_list();
/* Returns:
{
  "tools": [
    {
      "name": "index_repository",
      "title": "Index repository",
      "description": "...",
      "inputSchema": {...},
      "outputSchema": {"type":"object","additionalProperties":true}
    },
    ...
  ]
}
*/
free(json);

```

### Retrieving a Specific Input Schema

Access the raw JSON schema for individual tool validation:

```c
const char *schema = cbm_mcp_tool_input_schema("search_graph");
/* Returns: {"type":"object","properties":{...},"required":["project"]} */

```

### RPC Client Usage

Query the tool list via JSON-RPC:

```json
POST /jsonrpc
{
  "jsonrpc": "2.0",
  "method": "tools/list",
  "id": 1,
  "params": {}
}

```

The server processes this through `cbm_mcp_tools_list()` and returns the compiled tool definitions.

## Summary

- **Data sources for MCP tool definitions** are compiled directly into the binary via the static `TOOLS` array in [`src/mcp/mcp.c`](https://github.com/DeusData/codebase-memory-mcp/blob/main/src/mcp/mcp.c)
- **14 tools** are defined with hard-coded metadata and JSON input schemas at lines 311-395
- **Output schemas** are generic and defined by the `MCP_TOOL_OUTPUT_SCHEMA` constant (lines 500-502)
- **No external configuration** files, databases, or runtime data sources are consulted
- **Helper functions** `cbm_mcp_tools_list()` and `cbm_mcp_tool_input_schema()` expose the static data to RPC and CLI interfaces

## Frequently Asked Questions

### Are MCP tool definitions configurable via external files?

No. According to the DeusData/codebase-memory-mcp source code, there are no external JSON files, databases, or configuration files feeding the tool definitions. All metadata is embedded as string literals in the `TOOLS` array within [`src/mcp/mcp.c`](https://github.com/DeusData/codebase-memory-mcp/blob/main/src/mcp/mcp.c) and requires recompilation to modify.

### How many tools are defined in the hard-coded array?

The static `TOOLS` array contains **14 distinct MCP tools**, each with complete name, title, description, and input schema definitions located between lines 311 and 395 in [`src/mcp/mcp.c`](https://github.com/DeusData/codebase-memory-mcp/blob/main/src/mcp/mcp.c).

### Where is the output schema defined for MCP tools?

The output schema is defined by the **`MCP_TOOL_OUTPUT_SCHEMA`** macro at lines 500-502 in [`src/mcp/mcp.c`](https://github.com/DeusData/codebase-memory-mcp/blob/main/src/mcp/mcp.c). This constant contains a generic JSON schema (`{"type":"object","additionalProperties":true}`) that is attached to every tool definition in the `tools/list` RPC response.

### Can I modify tool definitions without recompiling?

No. Because the data sources for MCP tool definitions are static C arrays compiled into the binary, any changes to tool metadata, descriptions, or input schemas require editing [`src/mcp/mcp.c`](https://github.com/DeusData/codebase-memory-mcp/blob/main/src/mcp/mcp.c) and recompiling the project. There is no runtime configuration mechanism provided.