LogicMap MCP Server
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@LogicMap MCP Server Create a project 'MyApp' and add a node for user authentication flow."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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,externalSupports 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,extendsSupports 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 buildVerify 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 cleanExample 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.jsonData Storage
LogicMap stores project data in ~/.logicmap/projects/ as JSON files:
~/.logicmap/
└── projects/
└── {project-id}/
└── graph.json # Complete knowledge graphEach 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/ directoryContributing
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.
Links
Available Tools
11 toolsaddNodeB
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
Scored across 11 tools
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.
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.
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.
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
Shared context for your codebase: a hosted code knowledge graph over MCP. Free plan, OAuth sign-up.
A private graph database you query in plain English or Cypher. Hosted, nothing to install.
Deterministic context layer for your codebase: change impact, blast radius, answers with receipts.
Ask who calls a route, what a change breaks or who reads a field, across a system's repos.
Related MCP Servers
FlicenseNot gradedqualityNot gradedmaintenanceEnables 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 npm6-- AlicenseCqualityDmaintenanceCombines 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.13MIT
- AlicenseAqualityDmaintenanceEnables AI to analyze, query, and manage a graph-based representation of software architecture for impact analysis, dependency tracking, and design.201AGPL 3.0
- FlicenseAqualityDmaintenanceEnables AI assistants to deeply understand codebases via Knowledge Graphs, supporting fuzzy search, architecture layer queries, call chain tracing, impact analysis, and domain knowledge with multi-project support.182-