cuemap-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kaan Demirel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# CueMap MCP Server
+
+The [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server for CueMap, allowing AI coding assistants (like Claude Desktop, Cursor, Windsurf, and Antigravity) to instantly recall codebase context using the CueMap engine.
+
+## Zero-Config Deployment
+
+The CueMap MCP Server is designed to work completely out-of-the-box. When started, it automatically manages a high-performance Rust instance of the CueMap Server in the background.
+
+You do **not** need to install or run the CueMap CLI manually. The correct pre-compiled binary for your operating system is automatically downloaded via optional NPM dependencies.
+
+## Installation
+
+```bash
+# Global installation makes the `cuemap-mcp` command available
+npm install -g @cuemap/mcp-server
+```
+
+*(Note: Ensure your package manager is configured to download `optionalDependencies` so the local Rust binary is included).*
+
+## Configuration (Environment Variables)
+
+By default, the embedded engine runs on port `8080`. You can customize the server behavior by passing the following environment variables in your MCP configuration:
+
+- `CUEMAP_PORT`: Override the port the embedded engine binds to (default: `8080`).
+- `CUEMAP_CONFIG_PATH`: Absolute path to a custom `server_config.toml` to configure advanced Engine tuning, background jobs, and RAG search parameters.
+- `CUEMAP_URL`: If you prefer to bypass the embedded engine and connect to a remotely hosted or separately running CueMap server, specify its URL here (e.g. `http://localhost:8080`).
+
+## Using with AI Agents
+
+To use this MCP server with your AI assistant, add it to your assistant's MCP configuration file.
+
+### Example Configuration (Claude Desktop)
+
+```json
+{
+  "mcpServers": {
+    "cuemap": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@cuemap/mcp-server"
+      ],
+      "env": {
+        "CUEMAP_PORT": "8080"
+      }
+    }
+  }
+}
+```
+
+## Available Tools
+
+- **`cuemap_init`**: Autonomously initializes a CueMap project for a given local repository path. This triggers the Self-Learning Agent to instantly ingest the codebase so `cuemap_recall` can be used.
+  - `path` (string): Absolute path to the local repository.
+  - `projectName` (string, optional): The ID of the project to create. Defaults to the folder name of the path.
+
+- **`cuemap_recall`**: Recalls context about a codebase from your CueMap integrated brain. Uses natural language and semantic search to find relevant information.
+  - `query` (string): The natural language query to search for.
+  - `limit` (number, optional): Maximum results to return (default: 10).
+  - `projects` (string[], optional): List of project IDs to scope the search to. Multiple enables cross-project queries.
+  - `cues` (string[], optional): Specific cue tags to filter the search.
+  - `depth` (number, optional): Depth of multi-hop recall expander (default: 1).
+  - `auto_reinforce` (boolean, optional): Automatically reinforce retrieved memories (default: false).
+  - `min_intersection` (number, optional): Minimum required cue intersection count (default: 0).
+  - `explain` (boolean, optional): Include scoring explanation data in results (default: false).
+  - `disable_pattern_completion` (boolean, optional): Skip pattern completion inference.
+  - `disable_salience_bias` (boolean, optional): Disable salience scoring bias.
+  - `disable_systems_consolidation` (boolean, optional): Skip returning summary/consolidated memories.
+  - `disable_alias_expansion` (boolean, optional): Disable lexicon synonym injection during querying.
+
+## License
+
+MIT - See the [LICENSE](LICENSE) file for more details.

package/build/index.js

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const zod_1 = require("zod");
+const cuemap_1 = __importDefault(require("cuemap"));
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_1 = __importDefault(require("fs"));
+let engineProcess = null;
+let CUEMAP_URL = process.env.CUEMAP_URL;
+let client;
+const server = new mcp_js_1.McpServer({
+    name: "cuemap-mcp",
+    version: "1.0.0",
+});
+function getCuemapBinaryPath() {
+    if (process.env.CUEMAP_BIN)
+        return process.env.CUEMAP_BIN;
+    // Check optional dependencies dynamically
+    try {
+        const platform = os_1.default.platform();
+        const arch = os_1.default.arch();
+        const pkgName = `@cuemap/engine-${platform}-${arch}`;
+        const resolved = require.resolve(`${pkgName}/package.json`);
+        const binPath = path_1.default.join(path_1.default.dirname(resolved), "bin", "cuemap");
+        if (fs_1.default.existsSync(binPath))
+            return binPath;
+    }
+    catch (e) {
+        // Ignored
+    }
+    // Fallback: Check locally built binary (for development)
+    const localPath = path_1.default.resolve(__dirname, "../../rust_engine/target/release/cuemap");
+    if (fs_1.default.existsSync(localPath))
+        return localPath;
+    return null;
+}
+async function startEngine() {
+    if (CUEMAP_URL) {
+        console.error(`Using external CueMap engine at ${CUEMAP_URL}`);
+        return;
+    }
+    const binPath = getCuemapBinaryPath();
+    if (!binPath) {
+        console.error("Could not find cuemap binary. Please install the correct optional dependency, set CUEMAP_BIN, or set CUEMAP_URL to an existing instance.");
+        console.error("Falling back to expecting 'cuemap' in PATH.");
+    }
+    const execPath = binPath || "cuemap";
+    const port = process.env.CUEMAP_PORT || "8080";
+    CUEMAP_URL = `http://127.0.0.1:${port}`;
+    const args = ["start", "--port", port];
+    if (process.env.CUEMAP_CONFIG_PATH) {
+        args.push("--config", process.env.CUEMAP_CONFIG_PATH);
+        console.error(`Using custom config at ${process.env.CUEMAP_CONFIG_PATH}`);
+    }
+    console.error(`Starting Embedded CueMap Engine on port ${port}...`);
+    engineProcess = (0, child_process_1.spawn)(execPath, args, {
+        stdio: "ignore",
+        env: { ...process.env, CUEMAP_PORT: port }
+    });
+    engineProcess.on("error", (err) => {
+        console.error("Failed to start embedded engine:", err);
+    });
+    engineProcess.on("exit", (code) => {
+        console.error(`Embedded engine exited with code ${code}`);
+    });
+    process.on("SIGINT", () => {
+        if (engineProcess)
+            engineProcess.kill("SIGINT");
+        process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        if (engineProcess)
+            engineProcess.kill("SIGTERM");
+        process.exit(0);
+    });
+    // Wait slightly to ensure startup
+    await new Promise(resolve => setTimeout(resolve, 2000));
+}
+async function main() {
+    await startEngine();
+    client = new cuemap_1.default({ url: CUEMAP_URL });
+    server.registerTool("cuemap_init", {
+        description: "Initialize a CueMap project for a given local repository path. This triggers the Self-Learning Agent to ingest the codebase. Call this if the user hasn't set up the project yet or if cuemap_recall returns empty.",
+        inputSchema: zod_1.z.object({
+            path: zod_1.z.string().describe("Absolute path to the local repository."),
+            projectName: zod_1.z.string().optional().describe("The ID of the project to create. Defaults to the folder name of the path.")
+        })
+    }, async (args) => {
+        try {
+            const pName = args.projectName || path_1.default.basename(args.path);
+            const projects = await client.listProjects();
+            if (!projects.includes(pName)) {
+                await client.createProject(pName);
+            }
+            await client.setProjectWatchDir(pName, args.path);
+            console.error(`Started ingestion for project ${pName} at ${args.path}`);
+            // Polling for job completion
+            let isComplete = false;
+            let checks = 0;
+            while (!isComplete && checks < 60) {
+                const status = await client.jobsStatus(pName);
+                if (status.phase === "idle") {
+                    isComplete = true;
+                    break;
+                }
+                checks++;
+                await new Promise(r => setTimeout(r, 1000));
+            }
+            if (isComplete) {
+                return {
+                    content: [{ type: "text", text: `Successfully initialized and ingested project ${pName}. You can now use cuemap_recall.` }]
+                };
+            }
+            else {
+                return {
+                    content: [{ type: "text", text: `Project ${pName} initialized, but ingestion is still actively running in the background. Partial results may be returned by cuemap_recall.` }]
+                };
+            }
+        }
+        catch (error) {
+            console.error("Error initializing CueMap project", error);
+            return {
+                content: [{ type: "text", text: `Error initializing project: ${error?.message || "Unknown error"}` }],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("cuemap_recall", {
+        description: "Recall context about a codebase from a CueMap integerated brain. Uses natural language and semantic search to find relevant information.",
+        inputSchema: zod_1.z.object({
+            query: zod_1.z.string().describe("The natural language query to search the codebase memory for."),
+            limit: zod_1.z.number().optional().describe("Optional limit on the number of results to return. Default is 10."),
+            projects: zod_1.z.array(zod_1.z.string()).optional().describe("Optional list of project IDs to scope the search to. Provide multiple for cross-project recall. If not provided, searches the default project."),
+            cues: zod_1.z.array(zod_1.z.string()).optional().describe("Optional list of specific cues/tags to filter the search."),
+            depth: zod_1.z.number().optional().describe("Depth of multi-hop recall. Default is 1."),
+            auto_reinforce: zod_1.z.boolean().optional().describe("Automatically reinforce retrieved memories. Default is false."),
+            min_intersection: zod_1.z.number().optional().describe("Minimum intersection count for retrieval. Default is 0."),
+            explain: zod_1.z.boolean().optional().describe("Include explain component for debug information in results. Default is false."),
+            disable_pattern_completion: zod_1.z.boolean().optional().describe("Disable pattern completion inference. Default is false."),
+            disable_salience_bias: zod_1.z.boolean().optional().describe("Disable salience bias scoring. Default is false."),
+            disable_systems_consolidation: zod_1.z.boolean().optional().describe("Disable systems consolidation (exclude summaries). Default is false."),
+            disable_alias_expansion: zod_1.z.boolean().optional().describe("Disable alias expansion during querying. Default is false."),
+        }),
+    }, async (args) => {
+        try {
+            const { query, limit = 10, projects, cues, depth = 1, auto_reinforce = false, min_intersection, explain = false, disable_pattern_completion = false, disable_salience_bias = false, disable_systems_consolidation = false, disable_alias_expansion = false } = args;
+            const results = await client.recall(query, cues, projects, limit, depth, auto_reinforce, min_intersection, explain, disable_pattern_completion, disable_salience_bias, disable_systems_consolidation, disable_alias_expansion);
+            let items = [];
+            if (results.results && Array.isArray(results.results)) {
+                if (results.results.length > 0 && results.results[0].project_id) {
+                    results.results.forEach((projectRes) => {
+                        if (projectRes.results && Array.isArray(projectRes.results)) {
+                            items = items.concat(projectRes.results.map((r) => ({ ...r, project_id: projectRes.project_id })));
+                        }
+                    });
+                }
+                else {
+                    items = results.results;
+                }
+            }
+            if (!items || items.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No results found for the query in CueMap.",
+                        },
+                    ],
+                };
+            }
+            let formattedText = `CueMap found ${items.length} relevant results:\n\n`;
+            items.forEach((r, i) => {
+                const scoreStr = r.score !== undefined ? ` (Score: ${Number(r.score).toFixed(2)})` : '';
+                formattedText += `### Result ${i + 1}${scoreStr}\n`;
+                const projectId = r.project_id || (projects && projects.length === 1 ? projects[0] : null);
+                if (projectId)
+                    formattedText += `*Project: ${projectId}*\n`;
+                if (r.timestamp) {
+                    const date = new Date(r.timestamp);
+                    formattedText += `*Timestamp: ${date.toISOString()}*\n`;
+                }
+                else if (r.created_at) {
+                    const date = new Date(r.created_at * 1000);
+                    formattedText += `*Timestamp: ${date.toISOString()}*\n`;
+                }
+                formattedText += `${r.content}\n\n`;
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formattedText,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error("Error calling CueMap engine", error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error executing cuemap_recall tool: ${error?.message || "Unknown error"}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error("CueMap MCP server running on stdio");
+}
+main().catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "cuemap-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for CueMap",
+  "main": "build/index.js",
+  "bin": {
+    "cuemap-mcp": "./build/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node build/index.js",
+    "dev": "tsc --watch"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "cuemap",
+    "memory",
+    "rag"
+  ],
+  "author": "Kaan Demirel",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cuemap-dev/cuemap-mcp.git"
+  },
+  "type": "commonjs",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "cuemap": "^0.6.4",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "typescript": "^5.9.3"
+  },
+  "optionalDependencies": {
+    "@cuemap/engine-darwin-arm64": "^0.6.4",
+    "@cuemap/engine-darwin-x64": "^0.6.4",
+    "@cuemap/engine-linux-x64": "^0.6.4",
+    "@cuemap/engine-win32-x64": "^0.6.4"
+  }
+}

package/src/index.ts

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import CueMap from "cuemap";
+import { spawn, ChildProcess } from "child_process";
+import path from "path";
+import os from "os";
+import fs from "fs";
+
+let engineProcess: ChildProcess | null = null;
+let CUEMAP_URL = process.env.CUEMAP_URL;
+let client: CueMap;
+
+const server = new McpServer({
+    name: "cuemap-mcp",
+    version: "1.0.0",
+});
+
+function getCuemapBinaryPath(): string | null {
+    if (process.env.CUEMAP_BIN) return process.env.CUEMAP_BIN;
+
+    // Check optional dependencies dynamically
+    try {
+        const platform = os.platform();
+        const arch = os.arch();
+        const pkgName = `@cuemap/engine-${platform}-${arch}`;
+        const resolved = require.resolve(`${pkgName}/package.json`);
+        const binPath = path.join(path.dirname(resolved), "bin", "cuemap");
+        if (fs.existsSync(binPath)) return binPath;
+    } catch (e) {
+        // Ignored
+    }
+
+    // Fallback: Check locally built binary (for development)
+    const localPath = path.resolve(__dirname, "../../rust_engine/target/release/cuemap");
+    if (fs.existsSync(localPath)) return localPath;
+
+    return null;
+}
+
+async function startEngine(): Promise<void> {
+    if (CUEMAP_URL) {
+        console.error(`Using external CueMap engine at ${CUEMAP_URL}`);
+        return;
+    }
+
+    const binPath = getCuemapBinaryPath();
+    if (!binPath) {
+        console.error("Could not find cuemap binary. Please install the correct optional dependency, set CUEMAP_BIN, or set CUEMAP_URL to an existing instance.");
+        console.error("Falling back to expecting 'cuemap' in PATH.");
+    }
+
+    const execPath = binPath || "cuemap";
+    const port = process.env.CUEMAP_PORT || "8080";
+    CUEMAP_URL = `http://127.0.0.1:${port}`;
+
+    const args = ["start", "--port", port];
+    if (process.env.CUEMAP_CONFIG_PATH) {
+        args.push("--config", process.env.CUEMAP_CONFIG_PATH);
+        console.error(`Using custom config at ${process.env.CUEMAP_CONFIG_PATH}`);
+    }
+
+    console.error(`Starting Embedded CueMap Engine on port ${port}...`);
+    engineProcess = spawn(execPath, args, {
+        stdio: "ignore",
+        env: { ...process.env, CUEMAP_PORT: port }
+    });
+
+    engineProcess.on("error", (err) => {
+        console.error("Failed to start embedded engine:", err);
+    });
+
+    engineProcess.on("exit", (code) => {
+        console.error(`Embedded engine exited with code ${code}`);
+    });
+
+    process.on("SIGINT", () => {
+        if (engineProcess) engineProcess.kill("SIGINT");
+        process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        if (engineProcess) engineProcess.kill("SIGTERM");
+        process.exit(0);
+    });
+
+    // Wait slightly to ensure startup
+    await new Promise(resolve => setTimeout(resolve, 2000));
+}
+
+async function main() {
+    await startEngine();
+
+    client = new CueMap({ url: CUEMAP_URL });
+
+    server.registerTool(
+        "cuemap_init",
+        {
+            description: "Initialize a CueMap project for a given local repository path. This triggers the Self-Learning Agent to ingest the codebase. Call this if the user hasn't set up the project yet or if cuemap_recall returns empty.",
+            inputSchema: z.object({
+                path: z.string().describe("Absolute path to the local repository."),
+                projectName: z.string().optional().describe("The ID of the project to create. Defaults to the folder name of the path.")
+            })
+        },
+        async (args) => {
+            try {
+                const pName = args.projectName || path.basename(args.path);
+
+                const projects = await client.listProjects();
+                if (!projects.includes(pName)) {
+                    await client.createProject(pName);
+                }
+
+                await client.setProjectWatchDir(pName, args.path);
+                console.error(`Started ingestion for project ${pName} at ${args.path}`);
+
+                // Polling for job completion
+                let isComplete = false;
+                let checks = 0;
+                while (!isComplete && checks < 60) {
+                    const status = await client.jobsStatus(pName);
+                    if (status.phase === "idle") {
+                        isComplete = true;
+                        break;
+                    }
+                    checks++;
+                    await new Promise(r => setTimeout(r, 1000));
+                }
+
+                if (isComplete) {
+                    return {
+                        content: [{ type: "text" as const, text: `Successfully initialized and ingested project ${pName}. You can now use cuemap_recall.` }]
+                    };
+                } else {
+                    return {
+                        content: [{ type: "text" as const, text: `Project ${pName} initialized, but ingestion is still actively running in the background. Partial results may be returned by cuemap_recall.` }]
+                    };
+                }
+            } catch (error: any) {
+                console.error("Error initializing CueMap project", error);
+                return {
+                    content: [{ type: "text" as const, text: `Error initializing project: ${error?.message || "Unknown error"}` }],
+                    isError: true,
+                };
+            }
+        }
+    );
+
+    server.registerTool(
+        "cuemap_recall",
+        {
+            description: "Recall context about a codebase from a CueMap integerated brain. Uses natural language and semantic search to find relevant information.",
+            inputSchema: z.object({
+                query: z.string().describe("The natural language query to search the codebase memory for."),
+                limit: z.number().optional().describe("Optional limit on the number of results to return. Default is 10."),
+                projects: z.array(z.string()).optional().describe("Optional list of project IDs to scope the search to. Provide multiple for cross-project recall. If not provided, searches the default project."),
+                cues: z.array(z.string()).optional().describe("Optional list of specific cues/tags to filter the search."),
+                depth: z.number().optional().describe("Depth of multi-hop recall. Default is 1."),
+                auto_reinforce: z.boolean().optional().describe("Automatically reinforce retrieved memories. Default is false."),
+                min_intersection: z.number().optional().describe("Minimum intersection count for retrieval. Default is 0."),
+                explain: z.boolean().optional().describe("Include explain component for debug information in results. Default is false."),
+                disable_pattern_completion: z.boolean().optional().describe("Disable pattern completion inference. Default is false."),
+                disable_salience_bias: z.boolean().optional().describe("Disable salience bias scoring. Default is false."),
+                disable_systems_consolidation: z.boolean().optional().describe("Disable systems consolidation (exclude summaries). Default is false."),
+                disable_alias_expansion: z.boolean().optional().describe("Disable alias expansion during querying. Default is false."),
+            }),
+        },
+        async (args) => {
+            try {
+                const {
+                    query, limit = 10, projects, cues,
+                    depth = 1, auto_reinforce = false, min_intersection,
+                    explain = false, disable_pattern_completion = false,
+                    disable_salience_bias = false, disable_systems_consolidation = false,
+                    disable_alias_expansion = false
+                } = args;
+
+                const results = await client.recall(
+                    query,
+                    cues,
+                    projects,
+                    limit,
+                    depth,
+                    auto_reinforce,
+                    min_intersection,
+                    explain,
+                    disable_pattern_completion,
+                    disable_salience_bias,
+                    disable_systems_consolidation,
+                    disable_alias_expansion
+                );
+
+                let items: any[] = [];
+
+                if (results.results && Array.isArray(results.results)) {
+                    if (results.results.length > 0 && results.results[0].project_id) {
+                        results.results.forEach((projectRes: any) => {
+                            if (projectRes.results && Array.isArray(projectRes.results)) {
+                                items = items.concat(projectRes.results.map((r: any) => ({ ...r, project_id: projectRes.project_id })));
+                            }
+                        });
+                    } else {
+                        items = results.results;
+                    }
+                }
+
+                if (!items || items.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text" as const,
+                                text: "No results found for the query in CueMap.",
+                            },
+                        ],
+                    };
+                }
+
+                let formattedText = `CueMap found ${items.length} relevant results:\n\n`;
+                items.forEach((r: any, i: number) => {
+                    const scoreStr = r.score !== undefined ? ` (Score: ${Number(r.score).toFixed(2)})` : '';
+                    formattedText += `### Result ${i + 1}${scoreStr}\n`;
+                    const projectId = r.project_id || (projects && projects.length === 1 ? projects[0] : null);
+                    if (projectId) formattedText += `*Project: ${projectId}*\n`;
+                    if (r.timestamp) {
+                        const date = new Date(r.timestamp);
+                        formattedText += `*Timestamp: ${date.toISOString()}*\n`;
+                    } else if (r.created_at) {
+                        const date = new Date(r.created_at * 1000);
+                        formattedText += `*Timestamp: ${date.toISOString()}*\n`;
+                    }
+
+                    formattedText += `${r.content}\n\n`;
+                });
+
+                return {
+                    content: [
+                        {
+                            type: "text" as const,
+                            text: formattedText,
+                        },
+                    ],
+                };
+            } catch (error: any) {
+                console.error("Error calling CueMap engine", error);
+                return {
+                    content: [
+                        {
+                            type: "text" as const,
+                            text: `Error executing cuemap_recall tool: ${error?.message || "Unknown error"}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+    );
+
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("CueMap MCP server running on stdio");
+}
+
+main().catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "CommonJS",
+        "moduleResolution": "Node",
+        "rootDir": "./src",
+        "outDir": "./build",
+        "esModuleInterop": true,
+        "strict": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "include": [
+        "src/**/*"
+    ]
+}