Agile Flow MCP server

MCP Agile Flow is a comprehensive system for managing AI-assisted agile development workflows through a modern, resource-based API built with FastMCP. It offers tools for AI documentation generation, project structure organization, IDE integration, and workflow management with an intuitive RESTful API design.

Installation

Install the package using pip:

pip install mcp-agile-flow

Configuration

Updating Your MCP Client Configuration

If you previously configured MCP Agile Flow, you need to update your configuration as follows:

From:

{
    "name": "mcp-agile-flow",
    "server": {
        "type": "module",
        "module": "mcp_agile_flow.fastmcp_server",
        "entry_point": "run"
    }
}

To:

{
    "name": "mcp-agile-flow",
    "server": {
        "type": "module",
        "module": "mcp_agile_flow",
        "entry_point": "main"
    }
}

Cursor Configuration

For Cursor users, update your mcp.json file (typically at ~/.cursor/mcp.json):

"mcp-agile-flow": {
  "command": "/path/to/python",
  "args": [
    "-m",
    "mcp_agile_flow"
  ],
  "autoApprove": [
    // ...
  ]
}

Basic Usage

You can use MCP Agile Flow in two ways:

1. In Python Code

from mcp_agile_flow import call_tool, call_tool_sync

# Asynchronous interface
result = await call_tool("get-project-settings", {})

# Synchronous interface
result = call_tool_sync("get-project-settings", {})

2. Command Line

Run the server directly from the command line:

# Basic usage (logs disabled by default)
python -m mcp_agile_flow

# Enable normal logging
python -m mcp_agile_flow --verbose

# Debug mode (most verbose logging)
python -m mcp_agile_flow --debug

Available Tools

MCP Agile Flow provides these tools:

• get-project-settings: Get project settings including paths and environment variables
• initialize-ide: Initialize project directory structure for specific IDEs
• initialize-ide-rules: Initialize AI rule files for specific IDEs
• prime-context: Analyze project documentation and build contextual understanding
• migrate-mcp-config: Migrate MCP configuration between different IDEs
• think: Record a thought for complex reasoning and step-by-step analysis
• get-thoughts: Retrieve all thoughts recorded in the current session
• clear-thoughts: Clear all recorded thoughts from the current session
• get-thought-stats: Get statistics about the thoughts recorded in the current session
• process-natural-language: Process natural language commands and route to appropriate tools

Natural Language Commands

MCP Agile Flow supports conversational commands that are automatically mapped to the appropriate tools.

Types of Commands

Migration Commands

process_natural_language("migrate mcp config to claude-desktop")
process_natural_language("migrate config from cursor to claude-desktop")
process_natural_language("copy mcp settings to windsurf")

Note: Valid IDE names are: "cursor", "windsurf-next", "windsurf", "cline", "roo", and "claude-desktop".

Initialization Commands

process_natural_language("initialize ide for claude")
process_natural_language("setup rules for windsurf")

Project Settings Commands

process_natural_language("get project settings")
process_natural_language("show settings")

Context Analysis Commands

process_natural_language("prime context")
process_natural_language("analyze project context")

Thinking Commands

process_natural_language("think about how to improve code quality")

Command Line Natural Language Interface

You can also use natural language commands with the MCP Agile Flow CLI:

python -m mcp_agile_flow process-natural-language "migrate mcp config to claude-desktop"

Usage Examples

Migrating MCP Configuration Between IDEs

from mcp_agile_flow import call_tool_sync

# Migrate configuration from Cursor to Claude Desktop
result = call_tool_sync("migrate-mcp-config", {
    "source_ide": "cursor",
    "target_ide": "claude-desktop"
})

# Or use natural language
from mcp_agile_flow import process_natural_language
result = process_natural_language("migrate mcp config from cursor to claude-desktop")

Initializing IDE Rules

# Initialize rules for Windsurf
result = call_tool_sync("initialize-ide-rules", {
    "ide": "windsurf"
})

# Or use natural language
result = process_natural_language("initialize rules for windsurf")

Getting Project Settings

# Get comprehensive project settings
settings = call_tool_sync("get-project-settings", {})
print(f"Project root: {settings['project_root']}")
print(f"Environment variables: {settings['env_vars']}")

# Or use natural language
settings = process_natural_language("get project settings")

How to add this MCP server to Cursor

There are two ways to add an MCP server to Cursor. The most common way is to add the server globally in the ~/.cursor/mcp.json file so that it is available in all of your projects.

If you only need the server in a single project, you can add it to the project instead by creating or adding it to the .cursor/mcp.json file.

Adding an MCP server to Cursor globally

To add a global MCP server go to Cursor Settings > MCP and click "Add new global MCP server".

When you click that button the ~/.cursor/mcp.json file will be opened and you can add your server like this:

{
    "mcpServers": {
        "cursor-rules-mcp": {
            "command": "npx",
            "args": [
                "-y",
                "cursor-rules-mcp"
            ]
        }
    }
}

Adding an MCP server to a project

To add an MCP server to a project you can create a new .cursor/mcp.json file or add it to the existing one. This will look exactly the same as the global MCP server example above.

How to use the MCP server

Once the server is installed, you might need to head back to Settings > MCP and click the refresh button.

The Cursor agent will then be able to see the available tools the added MCP server has available and will call them when it needs to.

You can also explictly ask the agent to use the tool by mentioning the tool name and describing what the function does.