Skip to main content
Glama
LogicMap MCP Server

LogicMap MCP Server

by Sim-xia

LogicMap MCP Server

An MCP server implementation that provides semantic knowledge graph tools for understanding project structure, business logic, and code relationships.

Features

  • Semantic Knowledge Graph: Record business logic and conceptual relationships, not just code structure

  • Multi-Project Management: Manage multiple project knowledge graphs simultaneously

  • Rich Node Types: Support for concepts, flows, modules, components, data entities, and external dependencies

  • Relationship Modeling: Express various logical relationships (calls, depends, implements, flows_to, uses_data, triggers, extends)

  • Powerful Query Tools: Search nodes, query relationships, and explore graph structure

  • Language Agnostic: No dependency on specific language parsers, works with any codebase

  • Progressive Construction: Build knowledge graphs incrementally, starting with core flows

Related MCP server: RAG MCP Server

Tools

Project Management

  • createProject: Create a new project with metadata

  • updateProject: Update project information

  • deleteProject: Remove a project

  • listProjects: List all available projects

Node Management

  • addNode: Add a semantic node to the knowledge graph

    • Types: concept, flow, module, component, data, external

    • Supports tags, file associations, and custom metadata

  • updateNode: Update existing node information

  • removeNode: Remove a node and optionally cascade delete related edges

Relationship Management

  • linkNodes: Create relationships between nodes

    • Types: calls, depends, implements, flows_to, uses_data, triggers, extends

    • Supports relationship strength and descriptions

  • unlinkNodes: Remove relationships between nodes

Query Tools

  • queryNode: Get detailed node information with relationships

    • Supports neighbor traversal with configurable depth

  • searchNodes: Search nodes by criteria

    • Filter by type, tags, files, or text content

    • Configurable result limits

Usage

LogicMap is designed for:

  • Understanding complex codebases and business logic

  • Documenting system architecture and data flows

  • Impact analysis before making changes

  • Onboarding new team members

  • AI-assisted code comprehension

  • Cross-team knowledge sharing

Configuration

Usage with Claude Desktop

Add this to your claude_desktop_config.json:

{
  "mcpServers": {
    "logicmap": {
      "command": "node",
      "args": [
        "/absolute/path/to/logicmap-mcp-server/dist/index.js"
      ]
    }
  }
}

Usage with Kiro (compatible with other vscode based IDE)

Add the configuration to your MCP configuration file. Open the Command Palette (Ctrl + Shift + P or Cmd + Shift + P) and run MCP: Open User Configuration. This will open your user mcp.json file where you can add the server configuration.

User Configuration (Recommended):

{
  "mcpServers": {
    "logicmap": {
      "command": "node",
      "args": [
        "/absolute/path/to/logicmap-mcp-server/dist/index.js"
      ]
    }
  }
}

Workspace Configuration:

Alternatively, create .kiro/settings/mcp.json in your workspace:

{
  "mcpServers": {
    "logicmap": {
      "command": "node",
      "args": [
        "/absolute/path/to/logicmap-mcp-server/dist/index.js"
      ]
    }
  }
}

For more details about MCP configuration, see the Kiro MCP documentation.

Configuration Example

See mcp-config-example.json for a complete configuration example.

Installation

From Source

# Clone the repository
git clone https://github.com/yourusername/logicmap-mcp-server.git
cd logicmap-mcp-server

# Install dependencies
npm install

# Build the project
npm run build

Verify Installation

After building, test the server:

# Run tests
npm test

# Check build output
ls dist/

Development

# Development mode (watch for changes)
npm run dev

# Run tests
npm test

# Run tests with coverage
npm run test:coverage

# Lint code
npm run lint

# Format code
npm run format

# Clean build output
npm run clean

Example Usage

Creating a Knowledge Graph

// 1. Create a project
await createProject({
  name: "My Web App",
  description: "E-commerce platform",
  workspacePath: "/path/to/project"
});

// 2. Add semantic nodes
await addNode({
  id: "user-auth-flow",
  type: "flow",
  name: "User Authentication Flow",
  description: "Handles user login, token validation, and permission checks",
  files: ["src/auth/controller.ts", "src/auth/service.ts"],
  tags: ["core", "security"]
});

await addNode({
  id: "payment-service",
  type: "module",
  name: "Payment Service",
  description: "Integrates with Stripe and PayPal for payment processing",
  files: ["src/payment/processor.ts"],
  tags: ["core", "third-party"]
});

// 3. Create relationships
await linkNodes({
  from: "user-auth-flow",
  to: "payment-service",
  type: "depends",
  description: "Payment requires authenticated user session"
});

// 4. Query the graph
const result = await queryNode({
  id: "user-auth-flow",
  includeNeighbors: true,
  depth: 2
});

// 5. Search nodes
const searchResults = await searchNodes({
  tags: ["core"],
  types: ["flow", "module"],
  limit: 10
});

Project Structure

logicmap-mcp-server/
├── src/
│   ├── index.ts              # Entry point
│   ├── types/                # TypeScript type definitions
│   ├── schemas/              # JSON Schema validation
│   ├── services/             # Core business logic
│   │   ├── NodeService.ts    # Node CRUD operations
│   │   ├── EdgeService.ts    # Relationship management
│   │   └── QueryService.ts   # Graph queries
│   ├── storage/              # Data persistence
│   │   └── StorageManager.ts # File-based storage with locking
│   └── mcp/                  # MCP protocol implementation
│       └── MCPServerHandler.ts
├── tests/                    # Test files
├── dist/                     # Build output
└── package.json

Data Storage

LogicMap stores project data in ~/.logicmap/projects/ as JSON files:

~/.logicmap/
└── projects/
    └── {project-id}/
        └── graph.json        # Complete knowledge graph

Each graph file contains:

  • Project metadata

  • Node dictionary (for O(1) lookups)

  • Edge list

  • Timestamps

Tech Stack

  • Runtime: Node.js >= 18.0.0

  • Language: TypeScript 5.3+

  • Protocol: Model Context Protocol (MCP)

  • Validation: Ajv (JSON Schema)

  • Storage: JSON files with proper-lockfile

  • Testing: Vitest + fast-check

Building

# Build TypeScript to JavaScript
npm run build

# Output will be in dist/ directory

Contributing

Contributions are welcome! Please see CONTRIBUTING.md for guidelines.

License

This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.

Available Tools

11 tools
addNodeB

Add a new node to the knowledge graph

Inputs: id (required), name (required), type (required), description (required), +4 more.

createProjectB

Create a new project with metadata

Inputs: name (required), description (required), workspacePath (required).

deleteProjectC

Delete a project

Inputs: id (required).

linkNodesC

Create a relationship between two nodes

Inputs: to (required), from (required), type (required), metadata, +3 more.

listProjectsA

List all projects

Inputs: no named parameters.

queryNodeB

Query a node and its relationships

Inputs: id (required), depth, projectId, includeNeighbors.

removeNodeB

Remove a node from the knowledge graph

Inputs: id (required), cascade, projectId.

searchNodesC

Search nodes by criteria

Inputs: tags, files, limit, query, +2 more.

unlinkNodesB

Remove a relationship between two nodes

Inputs: to (required), from (required), type, projectId.

updateNodeC

Update an existing node in the knowledge graph

Inputs: id (required), name, tags, files, +3 more.

updateProjectC

Update project metadata

Inputs: id (required), name, description, workspacePath.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.6/5.0

    Scored across 11 tools

    Disambiguation5/5

    Each tool targets a distinct resource and action: project lifecycle tools (create, update, delete, list) are clearly separate from knowledge graph operations (add, update, remove, link, unlink, query, search). No two tools appear to overlap in purpose.

    Naming Consistency5/5

    All tool names follow a consistent verbNoun camelCase pattern: createProject, updateProject, deleteProject, listProjects, addNode, updateNode, removeNode, linkNodes, unlinkNodes, queryNode, searchNodes. The pattern is uniform and predictable.

    Tool Count5/5

    With 11 tools, the set is well-scoped for a server managing both projects and a knowledge graph. Each tool serves a distinct purpose and the count feels appropriate, not bloated or sparse.

    Completeness5/5

    The surface provides full CRUD coverage for projects (create, update, delete, list) and comprehensive graph operations for nodes (add, update, remove, link, unlink, query, search). The lifecycle is complete with no obvious dead ends or missing core functionality.

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      Not graded
      maintenance
      Enables building and querying code knowledge graphs for project analysis, with tools for exploring code relationships, managing workflows, and automating development tasks. Integrates with Git and GitHub for branch management and pull request creation.
      42 npm
      6
      -
    • A
      license
      C
      quality
      D
      maintenance
      Combines a knowledge graph with RAG (Retrieval-Augmented Generation) capabilities for semantic code indexing and search. Enables creating entity relationships, managing observations, and performing semantic searches across indexed codebases.
      13
      MIT