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., "@mcp-graph-loop Set up a task DAG for my project and run validation loops until all tasks pass."
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.
A specialized MCP (Model Context Protocol) server for graph-based task orchestration with automated validation and self-healing retry loops.
flowchart TD
subgraph AI["🤖 AI Agent (Claude / Cursor / IDE)"]
A1[1. Initialize Graph] --> A2[2. Query Ready Tasks]
A2 --> A3[3. Start Task & Write Code]
A3 --> A4[4. Call validate_task_loop]
end
subgraph MCP["⚙️ BRD Graph Loop MCP Server"]
M1[(State Management: nodes, dependencies, status)]
M2[Dependency Resolver & DAG Engine]
M3[Command Executor & Output Capture]
M4[Loop Controller: Retries, Max Attempts, Error Logging]
end
A1 -->|init_project_graph| M1
A2 -->|get_ready_tasks| M2
A3 -->|start_task| M1
A4 -->|validate_task_loop| M3
M3 -->|Pass: exitCode 0| M4
M3 -->|Fail: exitCode != 0| M4
M4 -->|Unlock Next Tasks| M2
M4 -->|Return Error Context| AIRelated MCP server: Orchestrator Python MCP Server
Each task node moves through deterministic states based on its prerequisites and validation results:
stateDiagram-v2
[*] --> PENDING : Initial state with unresolved dependencies
PENDING --> READY : All 'depends_on' tasks reach COMPLETED
READY --> IN_PROGRESS : AI calls 'start_task'
state "Validation Loop" as Loop {
IN_PROGRESS --> VALIDATING : AI calls 'validate_task_loop'
VALIDATING --> RETRYING : Command fails (exitCode != 0 & attempts < max)
RETRYING --> IN_PROGRESS : AI reads error logs and fixes code
}
VALIDATING --> COMPLETED : Command passes (exitCode 0)
VALIDATING --> FAILED : Command fails & max_attempts exceeded
COMPLETED --> [*] : Unlocks downstream PENDING nodes
FAILED --> [*] : Can be reset with 'reset_task_node'Tasks have explicit dependencies (depends_on: ["task_a", "task_b"]). The server automatically ensures tasks only become READY when all their prerequisite tasks are COMPLETED.
Instead of hoping code works, each node specifies a validation_command (e.g., npm test, tsc --noEmit, pytest, eslint):
Pass (exitCode: 0): Loop status becomes PASSED, node becomes COMPLETED, and dependent nodes automatically switch to READY.
Fail (exitCode != 0): The server logs full stdout/stderr and exit codes in error_logs, increments current_attempt, and returns the error output to the AI.
Self-Correction: The AI analyzes the error, modifies code, and calls validate_task_loop again until it passes or hits max_attempts.
scaffold_project_docs)Before initializing the graph, the AI agent can generate standard project documentation (Architecture, Phase-wise Tasks, and Test Cases) based on the user's requirements:
{
"targetDirectory": "./",
"architectureContent": "# Project Architecture\n...",
"phaseTasks": [
{ "fileName": "PHASE_1.md", "content": "# Phase 1 Tasks\n..." }
],
"testCasesContent": "# Integration Tests\n..."
}init_project_graph)The AI agent creates a task graph for a project:
{
"projectName": "Auth Feature",
"projectRoot": "/path/to/your/project/dir",
"nodes": [
{
"id": "schema",
"title": "Define User Database Schema",
"description": "Create Prisma schema and migration scripts",
"depends_on": [],
"validation_command": "npx prisma validate",
"max_attempts": 3
},
{
"id": "jwt_service",
"title": "Build JWT Token Service",
"description": "Implement sign, verify, and refresh token functions",
"depends_on": ["schema"],
"validation_command": "npm run test -- jwt.test.ts",
"max_attempts": 3
},
{
"id": "login_route",
"title": "Build API Login Endpoint",
"description": "Express POST /api/login endpoint with validation",
"depends_on": ["jwt_service"],
"validation_command": "npm run test -- auth.test.ts",
"max_attempts": 3
}
]
}get_ready_tasks)The agent asks what to work on next:
{
"ready_count": 1,
"ready_tasks": [
{
"id": "schema",
"title": "Define User Database Schema",
"status": "READY"
}
]
}(Notice jwt_service and login_route remain PENDING because their dependencies aren't done yet).
start_task)The agent claims the task:
{ "nodeId": "schema" }Node status transitions to IN_PROGRESS.
validate_task_loop)After the agent writes the schema files, it triggers the validation loop:
{ "nodeId": "schema" }If it passes:
schema status becomes COMPLETED.
jwt_service automatically becomes READY!
If it fails:
MCP returns:
{
"validation_passed": false,
"message": "Validation failed on attempt 1/3. Node 'schema' is in RETRYING status.",
"result": {
"exitCode": 1,
"error": "Syntax error at line 14: invalid relation syntax"
}
}The AI reviews the error, fixes line 14, and re-calls validate_task_loop.
Add this to your MCP settings file (~/.cursor/mcp.json, Claude Desktop config, or .gemini/config/mcp_config.json):
{
"mcpServers": {
"brd-graph-loop": {
"command": "node",
"args": [
"/Volumes/DATA/html work/mcp-graph-loop-server/build/index.js"
]
}
}
}Add a new task node dynamically into the active workflow graph with optional phase and category. Validates dependency references and checks for cycles before inserting.
Inputs: id (required), title (required), description (required), validation_command (required), +9 more.
Reset all FAILED (and optionally IN_PROGRESS) nodes in a phase back to PENDING, skipping COMPLETED nodes.
Inputs: phase (required), includeInProgress.
Retrieve current workflow graph state, including visual ASCII progress table, Mermaid diagram, phase progress, nodes, error logs, and execution timeline.
Inputs: includeMermaid, includeAsciiTable.
Get chronological execution timeline for a node, including timestamped attempts, exit codes, error logs, and duration in milliseconds.
Inputs: nodeId (required).
Get phase progress summary, completion percentages, phase gate statuses (BLOCKED, IN_PROGRESS, COMPLETED), and blocking reasons.
Inputs: phase.
Get all task nodes whose dependencies and phase gates are satisfied and are ready to be worked on.
Inputs: no named parameters.
Initialize a new project workflow graph with task nodes, phase milestones, dependencies, and validation commands.
Inputs: nodes (required), projectName (required), phase_order, projectRoot, +1 more.
Load a workflow graph state from a JSON file on disk with full Zod schema validation.
Inputs: filePath (required).
Reset a task node status to PENDING and clear its error logs, allowing a fresh retry from the beginning.
Inputs: nodeId (required).
Persist the current workflow state to disk using atomic write (write-to-temp then rename) to prevent corruption.
Inputs: filePath.
Generate standard project documentation files (Architecture/ER Diagram, Phase-wise Tasks, and Test Cases) in the project workspace based on provided project requirements. Useful for initializing a project plan before creating the graph.
Inputs: phaseTasks, targetDirectory, testCasesContent, architectureContent, +1 more.
Mark a task node as IN_PROGRESS to start working on it. Enforces phase gates before allowing execution.
Inputs: nodeId (required).
Switch the active project context to a different project that was previously initialized with init_project_graph. Lists available projects if the requested one is not found.
Inputs: projectName (required).
Update an existing task node properties, phase, status, or validation command. Re-validates dependency references and cycle-checks after update.
Inputs: nodeId (required), tags, phase, title, +10 more.
Run validation commands for multiple READY/IN_PROGRESS tasks concurrently with atomic sequential state accumulation (race-condition free).
Inputs: nodeIds (required), cwd, timeoutMs.
Execute the validation command for a task node with duration tracking and attempt error logging. Streams live output via progress notifications when supported.
Inputs: nodeId (required), cwd, timeoutMs, commandOverride.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 16 tools
Most tools have distinct purposes with clear descriptions. get_graph_state and get_phase_status both provide state information but differ in scope (overall graph vs phase-level). validate_task_loop and validate_parallel_tasks are similar but clearly distinguished by single vs parallel execution.
Tool names consistently use snake_case with a verb_noun pattern (get_graph_state, start_task, add_task_node). Minor variation in verb choice (init vs initialize, scaffold, switch) is still predictable and does not undermine the overall pattern.
At 16 tools, the set is slightly above the comfortable range but each tool serves a distinct function in the workflow graph lifecycle. The complexity of the domain justifies the count, and there is no redundancy.
The tool set covers graph initialization, task management (add/update/start/reset), validation (single/parallel), state inspection, persistence, and project switching. Missing an explicit delete_task_node or mark_completed is a minor gap, but the core workflow is covered and workarounds exist.
Build, validate, and deploy multi-agent AI solutions from any AI environment.
Task manager for AI agents. Orchestrate agents to achieve large goals in unified control plane.
Design, build and run teams of AI agents with checked handoffs between them.
AI work orchestration for plans, tasks, teams, and coding-agent dispatch.
