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., "@GID MCP Server What breaks if I change UserService?"
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.
Model Context Protocol server for Graph-Indexed Development
Give AI assistants structural awareness of your codebase. GID represents software systems as typed, directed graphs — so AI can reason about architecture, not just syntax.
AI can generate code, but it can't answer:
"What breaks if I change UserService?"
"Which components implement the auth feature?"
"What's the dependency path from Controller to Database?"
GID fills this gap by providing a graph-based map of your software architecture that AI assistants can query and update.
Two workflows:
Top-down: Describe what you want to build → GID generates the architecture graph → AI implements against it
Bottom-up: Extract a graph from existing code → Use it for impact analysis, safe refactoring, and planning new changes
The graph evolves with your project. Every time you add a feature or refactor, the graph updates — so AI always has the current map.
Dogfooding: GID's own architecture is defined as a GID graph. We used GID to build GID — tracking components, querying impact before refactoring, and planning new features. See the self-referential graph.
Related MCP server: Axon Pro
Tool | Description |
| Analyze what components and features are affected by changing a node |
| Get dependencies or dependents of a node (with depth control) |
| Find shared dependencies between two nodes (useful for debugging) |
| Find dependency path between two nodes |
| Deep analysis of a file (functions, classes, complexity) |
| Structured file analysis for AI summarization |
| Graph health score, validation issues, and improvement suggestions |
| Get the GID graph schema with dynamic relations |
Tool | Description |
| Read graph structure (YAML, JSON, or summary) |
| Initialize a new GID graph in a project |
| Add, update, or delete nodes, edges, and relation types |
| Rename, move, or delete nodes with cascade |
| Version history — list, diff, or restore previous versions |
Tool | Description |
| Generate a graph from natural language requirements |
| Extract dependency graph from existing code (TypeScript/JavaScript) |
| Propose semantic upgrades — map files to components, assign layers, detect features |
| Analyze docs to identify gaps and suggest graph additions |
| Generate interactive D3.js HTML visualization |
Resource | Description |
| Current dependency graph (YAML) |
| Health score and validation results |
| List of all features in the graph |
Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"gid": {
"command": "npx",
"args": ["graph-indexed-development-mcp"]
}
}
}claude mcp add gid -- npx graph-indexed-development-mcpAdd to your MCP settings:
{
"gid": {
"command": "npx",
"args": ["graph-indexed-development-mcp"]
}
}Install the MCP server (see above)
Initialize a graph in your project:
You: "Initialize a GID graph for this project"
→ Claude uses gid_initExtract dependencies from your code:
You: "Extract the dependency graph from the codebase"
→ Claude uses gid_extractStart querying:
You: "What would break if I change UserService?"
→ Claude uses gid_query_impact
You: "Design the architecture for a notification feature"
→ Claude uses gid_design
You: "Show me the project health score"
→ Claude uses gid_adviseYou: "Design an e-commerce backend with auth, payments, and order tracking"
Claude uses gid_design →
Created 4 features: UserAuth, Payment, OrderTracking, ProductCatalog
Created 8 components across 4 layers
Created 15 dependency edges
Health score: 95/100
You: "Now implement the AuthService based on the graph"
Claude uses gid_query_deps →
AuthService depends on: UserRepository, TokenManager
Implements: UserAuth feature
Layer: application
Claude generates code that fits the architecture.You: "Extract the dependency graph from this project"
Claude uses gid_extract →
Found 42 files, 156 dependencies
Grouped into 12 components across 4 layers
You: "I need to refactor UserService. What would break?"
Claude uses gid_query_impact →
Direct dependents: AuthController, ProfileController, OrderService
Affected features: UserRegistration, OrderPayment
5 components impacted, 2 features at risk
You: "Why do OrderService and PaymentService keep failing together?"
Claude uses gid_query_common_cause →
Shared dependency: DatabaseService
Both services depend on it — that's likely the root cause.You: "I just added a NotificationService. Update the graph."
Claude uses gid_edit_graph →
Added node: NotificationService (Component, application layer)
Added edges: depends_on EmailClient, implements Notifications feature
You: "Check the project health"
Claude uses gid_advise →
Health: 87/100
Warning: NotificationService has no tests
Warning: EmailClient has 6 dependents (high coupling)
Suggestion: Consider splitting EmailClient into smaller modulesYou: "Visualize the current project architecture"
Claude uses gid_visual → Generates an interactive D3.js HTML file
GID uses a YAML-based graph format (.gid/graph.yml):
nodes:
UserAuth:
type: Feature
description: User authentication and authorization
priority: core
status: active
AuthService:
type: Component
layer: application
description: Handles authentication logic
path: src/services/auth.ts
AuthController:
type: Component
layer: interface
path: src/controllers/auth.ts
edges:
- from: AuthService
to: UserAuth
relation: implements
- from: AuthController
to: AuthService
relation: depends_onNode types: Feature, Component, Interface, Data, File, Test, Decision
Relation types: implements, depends_on, calls, reads, writes, tested_by, defined_in, enables, blocks, requires, precedes, refines, validates, related_to, decided_by — plus custom relations you define.
Nodes can have an optional tasks field for inline step tracking:
webhook-push:
type: Component
layer: infrastructure
status: in_progress
description: "Webhook push notifications HMAC-SHA256"
tasks:
- "[x] Implement HMAC signing"
- "[x] DM webhook events"
- "[ ] Run migration 011 on prod"
- "[ ] Add retry logic"Convention: When all tasks are done, remove the tasks field and set status: active.
Tool | Description |
| Query tasks across the graph. No args = all pending. |
| Toggle task completion: |
| Now shows tasks inline in summary output |
webhook-push [Component, infrastructure, in_progress]
"Webhook push notifications HMAC-SHA256"
Tasks: 2/4 done
✅ Implement HMAC signing
✅ DM webhook events
☐ Run migration 011 on prod
☐ Add retry logicNode.js >= 20.0.0
GID Methodology — Specification, examples, and dogfood graph
GID CLI — Command line interface
GID Paper — Formal methodology (Zenodo)
AGPL-3.0 — See LICENSE for details.
For commercial licensing, see COMMERCIAL-LICENSE.md.
Toni Tang — @tonioyeme
Validate graph and get improvement suggestions. Returns health score + issues + suggestions.
Inputs: level, graphPath, threshold.
Analyze file, function, or class. Returns structured JSON for AI consumption.
Inputs: filePath (required), class, function, includePatterns.
Analyze existing graph and documentation to identify gaps and suggest semantic layer additions. Returns structured context for AI to complete the graph with gid_edit_graph.
Inputs: docsPath, graphPath, docContent.
Generate semantic graph from natural language requirements. Creates Features, Components, layers, and relationships.
Inputs: requirements (required), outputPath.
Directly add, update, or delete nodes, edges, and relation types in the graph. Supports dynamic relation schema.
Inputs: operations (required), dryRun, graphPath.
Extract dependency graph from existing code (TypeScript/JavaScript) with optional enrichment
Inputs: group, paths, dryRun, enrich, +5 more.
Get structured file analysis ready for AI to generate a summary description
Inputs: filePath (required), includeContent.
Get the GID graph schema with dynamic relations. If a graph exists, includes custom/discovered relations from that graph.
Inputs: graphPath, includeExample.
Manage graph version history (list, diff, restore)
Inputs: force, action, version, graphPath.
Initialize a new GID graph in a project
Inputs: path, force, template.
Find shared dependencies between two nodes (useful for debugging)
Inputs: nodeA (required), nodeB (required), graphPath.
Get dependencies or dependents of a node
Inputs: node (required), depth, reverse, graphPath.
Analyze what components and features are affected by changing a node
Inputs: node (required), graphPath.
Find dependency path between two nodes
Inputs: to (required), from (required), graphPath.
Read and return the current graph structure or summary
Inputs: format, graphPath.
Preview or apply graph changes to codebase (rename, move, split, merge nodes)
Inputs: nodeId (required), operation (required), dryRun, newName, +2 more.
Propose semantic upgrades: map files to components, assign layers, detect features. Use returnContext: true for AI semantic analysis (reads docs + code names).
Inputs: scope, dryRun, graphPath, returnContext.
Query tasks across the graph. Shows nodes with pending (or all) tasks.
Inputs: done, node, graphPath.
Toggle task completion on a node. Marks [ ] ↔ [x]. If all tasks become done, prompts to update status.
Inputs: node (required), task (required), done, graphPath.
Generate static HTML visualization of the dependency graph. Returns self-contained HTML that can be saved and opened in a browser.
Inputs: graphPath, outputPath.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 20 tools
Each tool has a clear and distinct purpose, with descriptions that differentiate them well. For example, gid_analyze focuses on file/function/class analysis, gid_extract extracts dependency graphs from code, and gid_semantify proposes semantic upgrades. There is no significant overlap.
All tools follow a consistent 'gid_verb_noun' pattern in snake_case. The verbs are imperative and descriptive (e.g., gid_init, gid_query_deps, gid_edit_graph), and there is no mixing of conventions.
With 20 tools, the server covers a broad range of graph management operations. While slightly above the typical 3-15 range, each tool serves a specific function and the count is justified by the comprehensive feature set.
The tool set covers the full lifecycle: initialization, reading, editing, version history, code extraction, analysis, design from requirements, multiple query types (dependencies, impact, path, common cause), task management, and visualization. There are no obvious gaps for the stated domain.
AI Agent with Architectural Memory. Impact analysis (free), tests and code from the graph (pro).
AI knowledge graph for architecture, portfolio, and digital strategy management.
Code intelligence platform for AI agents. 20 tools for architecture, security & impact analysis.
Give your AI agent a persistent map of your project's structure, dependencies, and bugs.
