MANDATORY STEP 1: Create a new project in the memory system before starting any work.

CRITICAL: You MUST call this tool FIRST before writing any code or creating files. This establishes the project in CoordMCP for tracking decisions, changes, and context.

WHEN TO USE:

• Starting ANY new project or application

• User says "Create a todo app", "Build an API", "Make a website", etc.

• Beginning work in a new repository or codebase

• Starting a new feature that deserves its own project tracking

WORKFLOW:

1. Call create_project() FIRST

2. Then register_agent()

3. Then start_context()

4. Then begin coding

Get comprehensive information about a project from CoordMCP memory.

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE:

• Before starting work to understand project context and history

• To check existing tech stack and architectural decisions

• To see recent changes made by other agents

• When resuming work on an existing project

• To understand the project structure before making changes

This retrieves: project metadata, tech stack, recent decisions, file dependencies, and change history.

CRITICAL: Record important architectural and technical decisions for future reference.

MANDATORY: Call this whenever you make significant technical choices. This builds the project's decision history and helps maintain consistency across the codebase.

WHEN TO USE (Always save decisions for):

• Choosing a framework or library (React vs Vue, Flask vs FastAPI, etc.)

• Database selection (PostgreSQL vs MongoDB, Redis vs Memcached)

• Architecture patterns (Microservices vs Monolith, MVC vs Clean Architecture)

• API design choices (REST vs GraphQL, authentication methods)

• Infrastructure decisions (Cloud provider, containerization, CI/CD approach)

• Security implementations (auth strategy, encryption methods)

• Performance optimizations (caching strategy, database indexing)

• Any decision that affects the project's direction or maintainability

WHY THIS MATTERS:

• Other agents (or you later) will understand WHY choices were made

• Prevents inconsistent approaches across the codebase

• Documents the evolution of the architecture

• Helps onboard new team members

Retrieve all recorded architectural and technical decisions for a project.

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE:

• Before making new technical decisions to see what was already decided

• When you're unsure about the project's architectural direction

• To understand why certain patterns or technologies are used

• Before contradicting an existing approach - check if there's already a decision

• When joining an existing project to understand its evolution

RECOMMENDED: Call this at the start of work to understand the project's decision history. This prevents you from unknowingly contradicting previous architectural choices.

Search through recorded decisions by keywords or metadata.

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE:

• Looking for decisions about specific topics (e.g., "authentication", "database")

• Checking if a particular technology or pattern was already decided upon

• Finding decisions made by specific approaches or requirements

• Researching the history of a specific feature or component

USEFUL FOR: Quickly finding relevant decisions without reading through all of them.

CRITICAL: Record the technology stack used in this project.

MANDATORY: Call this whenever you add or change a major technology in the project. This creates a central registry of all technologies used.

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE:

• Setting up a new project - record ALL technologies you plan to use

• Adding a new dependency or framework

• Changing versions of existing technologies

• Adding infrastructure tools (Docker, Kubernetes, etc.)

• Setting up databases, message queues, or external services

• Adding testing frameworks, build tools, or CI/CD pipelines

CATEGORIES TO TRACK:

• "backend": Python/Node/Java frameworks, runtime environments

• "frontend": React/Vue/Angular, CSS frameworks, build tools

• "database": PostgreSQL, MongoDB, Redis, Elasticsearch

• "infrastructure": Docker, Kubernetes, AWS services, monitoring

• "testing": Jest, Pytest, Cypress, etc.

• "devops": CI/CD tools, deployment platforms

BEST PRACTICE: Always link to a decision via decision_ref when the tech choice was based on a documented decision.

Retrieve the complete technology stack for a project.

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE:

• At the start of work to understand what technologies are already in use

• Before adding new dependencies to avoid conflicts or duplicates

• To check version compatibility when upgrading

• When onboarding or explaining the project to others

• To ensure consistency with existing technology choices

RECOMMENDED: Call this early in your workflow to understand the technical landscape.

CRITICAL: Log every significant code change for project tracking and history.

MANDATORY: Call this AFTER completing any substantial file modification, creation, or deletion. This maintains a complete audit trail of all changes made to the project.

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE (Always log changes for):

• Creating new files or components

• Modifying existing functionality

• Refactoring code

• Deleting files or features

• Any change that affects the project's behavior or structure

CHANGE TYPES:

• "create": New files, new components, new features

• "modify": Updates to existing code, bug fixes, enhancements

• "delete": Removing files, features, or code

• "refactor": Restructuring code without changing behavior

ARCHITECTURE IMPACT:

• "none": Simple changes, bug fixes, formatting (default)

• "minor": Small API changes, new utility functions, config updates

• "significant": New architectural patterns, major refactoring, breaking changes

BEST PRACTICES:

• Always log after the change is complete and tested

• Link to related decisions when changes implement architectural decisions

• Be descriptive in the description field

• Use code_summary to briefly explain what the code does

Retrieve recent changes made to a project for context and continuity.

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE:

• At the start of a session to see what was recently worked on

• Before making changes to understand the current state

• To check if another agent has been working on the same files

• To review the evolution of the codebase

• After being away from the project for a while

• To identify patterns in recent development

RECOMMENDED: Call this when resuming work or joining an active project to understand recent activity and avoid conflicts.

Track important file metadata for project understanding and dependency management.

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE:

• After creating new files to document their purpose and relationships

• When you understand a file's dependencies on other files

• To update complexity assessments as files grow

• To organize files into logical modules

• When refactoring changes file dependencies

RECOMMENDED FOR: Key architectural files, complex modules, files with many dependencies. This helps build a dependency graph and understand the codebase structure.

FILE TYPES:

• "source": Production code files (default)

• "test": Test files and test suites

• "config": Configuration files (package.json, .env, etc.)

• "doc": Documentation files (README, docs, etc.)

COMPLEXITY LEVELS:

• "low": Simple files, straightforward logic, minimal dependencies

• "medium": Moderate complexity, some business logic, several dependencies

• "high": Complex files, intricate logic, many dependencies, high cognitive load

Analyze file dependencies to understand the impact of changes.

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE:

• Before modifying a file to see what else might break

• When refactoring to understand the ripple effects

• To find all files affected by a bug fix

• To understand the codebase architecture and relationships

• When deleting files to ensure nothing depends on them

• To identify circular dependencies

IMPORTANT: This helps prevent breaking changes and understand refactoring impact. Always check dependencies before making significant modifications.

DIRECTIONS:

• "dependencies": What this file imports/uses (downstream)

• "dependents": What imports/uses this file (upstream) - USE THIS BEFORE DELETING

• "both": Complete dependency graph in both directions

Retrieve comprehensive information about a logical module in the project.

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE:

• To understand the structure and purpose of a specific module

• Before working on a module to see its responsibilities and files

• To check module dependencies and avoid circular dependencies

• When planning module refactoring or restructuring

• To understand the relationship between modules

USEFUL FOR: Getting a high-level view of a specific component or subsystem.

MANDATORY STEP 2: Register yourself as an agent in the CoordMCP system.

CRITICAL: You MUST call this tool AFTER create_project() but BEFORE starting any work. This establishes your identity for multi-agent coordination and enables:

• Context tracking across sessions

• File locking to prevent conflicts

• Change attribution

• Session history and logging

WHEN TO USE:

• At the start of EVERY new session or conversation

• When beginning work on a new project

• When you haven't yet registered in the current session

• After restarting or reconnecting to CoordMCP

WORKFLOW:

1. create_project() - Create project

2. register_agent() - Register yourself (THIS STEP)

3. start_context() - Start working context

4. Begin coding

SAVE THE AGENT_ID: You'll need it for ALL subsequent operations.

Retrieve a list of all registered agents and their current status.

WHEN TO USE:

• At the start of work to see who else is working on this project

• To check if other agents are currently active

• To understand the capabilities of other agents in the system

• When coordinating multi-agent work

• To see the history of agents that have worked on this project

USEFUL FOR: Multi-agent coordination and understanding the project's agent ecosystem.

Retrieve detailed profile information about a specific agent.

WHEN TO USE:

• To check your own registration details and capabilities

• To understand what another agent is working on

• To verify an agent's identity and permissions

• When coordinating work between multiple agents

MANDATORY STEP 3: Start a new work context before beginning any coding task.

CRITICAL: You MUST call this tool AFTER create_project() and register_agent(). This establishes your current objective and enables:

• Context tracking for the current task

• File locking coordination

• Session logging and history

• Conflict prevention with other agents

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE:

• At the beginning of every coding session or task

• When switching to a new objective or feature

• When the user's request changes significantly

• After completing one task and starting another

• When you need to establish clear boundaries for your current work

WORKFLOW:

1. create_project() - Create project (if new)

2. register_agent() - Register yourself

3. start_context() - Start work context (THIS STEP)

4. lock_files() - Lock files you plan to modify (recommended)

5. Begin coding

PRIORITY LEVELS:

• "critical": Production outage, security vulnerability, critical bug fix

• "high": Important features, significant refactoring, blocking issues

• "medium": Standard development work (default)

• "low": Documentation, minor optimizations, nice-to-have features

Get comprehensive onboarding context when entering a project.

Returns a complete 'situation report' including project info, recent activity, active agents, key decisions, and personalized context for the agent.

WHEN TO USE:

• When entering a project to understand the current state

• Before starting work to see what others are doing

• When returning to a project after some time

• To get a full overview of project context

Get phase-by-phase workflow guidance for development tasks.

This tool provides structured, step-by-step instructions for working on a project. It combines project-specific workflows with the standard CoordMCP workflow.

WHEN TO USE:

• At the start of any new task to understand the recommended workflow

• When you want to follow best practices for this project

• To understand what tools to use and in what order

• New agents should always call this to understand the expected workflow

AVAILABLE WORKFLOWS:

• "test-first": Test-Driven Development (write tests before code)

• "feature-branch": Feature branch workflow with code review

• "review-then-commit": Peer review before committing

• "default": Standard workflow for any task

Validate your workflow state and get warnings about missing steps.

This tool checks your current workflow state and provides warnings about any steps you may have missed. Use this to ensure you're following the recommended CoordMCP workflow.

WHEN TO USE:

• At any point during development to check if you're following the workflow

• Before ending a context to make sure you've logged changes

• When you want to know what steps to complete next

• If you're unsure what to do next

WORKFLOW STEPS:

1. register_agent() - Register your agent

2. start_context() - Start a work context

3. lock_files() - Lock files before editing

4. Make your code changes

5. log_change() - Document your changes

6. unlock_files() - Unlock files after editing

7. end_context() - End your work session

Get the CoordMCP system prompt with mandatory workflow instructions.

This tool returns the complete system prompt that agents should use as their system prompt for proper CoordMCP integration.

WHEN TO USE:

• At agent startup to get the system prompt

• To understand the mandatory CoordMCP workflow

• As reference for best practices

This returns a comprehensive guide including:

• Mandatory workflow steps (in order)

• Tool usage examples

• Best practices and quick reference

Returns: Dictionary with system_prompt content

Example: >>> result = await get_system_prompt_tool() >>> # Returns the full system prompt for use as agent system prompt

Retrieve your current work context and session information.

WHEN TO USE:

• At the start of a conversation to check if you have an active context

• To verify your current objective and project

• To see what files you have locked

• To understand what you were working on in a previous session

• When resuming work after an interruption

RECOMMENDED: Call this at the beginning of each conversation to establish context and understand your current state in the system.

Switch your work context to a different project or objective.

WHEN TO USE:

• When the user asks you to work on something different

• When switching from one task to another in the same conversation

• When moving between multiple projects

• After completing one objective and starting a new one

IMPORTANT: This will end your current context and start a new one. Make sure to complete or document any pending work in the current context first.

WORKFLOW:

1. Complete current work and log changes

2. unlock_files() - Release any locked files

3. switch_context() - Switch to new objective (THIS STEP)

4. lock_files() - Lock files for new work (if needed)

5. Begin new work

End your current work context and session.

WHEN TO USE:

• At the end of a conversation or coding session

• When you've completed the current objective

• Before switching to a completely different task

• When you want to release all file locks and close the session

IMPORTANT: This will:

• Release all file locks you hold

• Log the end of your session

• Clear your current context

BEST PRACTICE: Always call this before ending a conversation to ensure clean state for the next session.

WORKFLOW:

1. Complete all work and log changes with log_change()

2. unlock_files() - Release all locked files

3. end_context() - End session (THIS STEP)

CRITICAL: Lock files before modifying them to prevent conflicts with other agents.

MANDATORY: Always lock files BEFORE making changes. This prevents:

• Multiple agents editing the same file simultaneously

• Lost changes and merge conflicts

• Race conditions in multi-agent environments

WHEN TO USE:

• Before editing any existing file

• Before creating files in shared directories

• Before refactoring code that spans multiple files

• When you plan to modify files over an extended period

WORKFLOW:

1. lock_files() - Lock the files you plan to modify (THIS STEP)

2. Make your changes

3. log_change() - Log the changes made

4. unlock_files() - Release the locks when done

CONFLICT HANDLING: If files are already locked by another agent, you'll receive conflict information including which agent has the lock and when it expires. You should either:

• Wait for the lock to be released

• Coordinate with the other agent

• Work on different files first

Release file locks after you've completed your changes.

WHEN TO USE:

• Immediately after completing changes to files

• When you're done working on a specific file or set of files

• Before switching to work on different files

• At the end of a task or session

IMPORTANT: Always unlock files as soon as you're done with them. This allows other agents to work on those files and prevents unnecessary blocking.

WORKFLOW:

1. Complete your changes and test them

2. log_change() - Log what you changed

3. unlock_files() - Release the locks (THIS STEP)

Check which files are currently locked and by whom.

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE:

• Before planning your work to see what files are unavailable

• When you encounter conflicts and need to understand the situation

• To coordinate with other agents working on the same project

• To check if a specific file is available for editing

USEFUL FOR: Understanding the current state of file locks and planning your work accordingly.

Retrieve your recent file operation history and context entries.

WHEN TO USE:

• To review what files you've recently worked on

• To understand the sequence of operations in your current session

• When you need to remember what you did earlier in the conversation

• To track the evolution of your work

USEFUL FOR: Understanding your recent activity and maintaining continuity.

Retrieve your complete session log with events and activities.

WHEN TO USE:

• To review the full history of your current and past sessions

• To understand when contexts were started, switched, or ended

• To track the duration and details of your work sessions

• For debugging or understanding session state

USEFUL FOR: Getting a comprehensive view of your session activity and timeline.

Retrieve all agents currently active in a specific project.

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE:

• To check who else is working on this project right now

• Before starting work to understand the current activity level

• When coordinating multi-agent work

• To see what other agents are focused on

USEFUL FOR: Multi-agent coordination and understanding project activity.

RECOMMENDED: Analyze and understand the current project architecture.

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE:

• At the start of work on an existing project to understand the architecture

• Before making significant architectural changes

• To identify potential improvements or issues in the codebase

• When onboarding to a new codebase

• To get an overview of modules, dependencies, and complexity

THIS PROVIDES:

• Overview of project structure and modules

• Dependency analysis

• Complexity metrics

• Potential architectural issues

• Recommendations for improvement

RECOMMENDED: Call this early when working on an existing project to understand the architectural landscape before making changes.

RECOMMENDED: Get expert architectural guidance before implementing major features.

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE:

• Before implementing significant new features or capabilities

• When you're unsure about the best architectural approach

• For complex features that affect multiple parts of the system

• When choosing between different implementation strategies

• To ensure consistency with existing architecture

• Before making structural changes to the codebase

HIGHLY RECOMMENDED FOR:

• New major features

• Significant refactoring efforts

• Integration with external systems

• Changes to core architecture

• Performance-critical implementations

THIS PROVIDES:

• Recommended approach and design patterns

• File structure and organization suggestions

• Technology and library recommendations

• Implementation steps and considerations

• Rationale for the recommendations

AFTER RECEIVING RECOMMENDATIONS:

1. Review the suggested approach

2. Save the decision with save_decision() if you adopt the recommendation

3. Implement following the suggested structure

4. Update architecture tracking with update_architecture()

Validate that your code structure follows the project's architectural guidelines.

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE:

• Before finalizing a new file or component structure

• When creating significant new modules or services

• To ensure consistency with existing codebase patterns

• When you're unsure if your approach follows project conventions

• Before committing major structural changes

USEFUL FOR: Catching architectural violations early and maintaining codebase consistency.

VALIDATION CHECKS:

• Directory structure conventions

• Naming conventions

• Import/export patterns

• Dependency management

• Architectural pattern compliance

Browse the catalog of available design patterns and architectural approaches.

WHEN TO USE:

• When designing new features and considering architectural patterns

• To learn about different design approaches and their use cases

• When evaluating which pattern fits your current requirements

• To understand best practices for common problems

• As reference when making architectural decisions

USEFUL FOR: Understanding available architectural patterns and when to apply them.

Returns: Dictionary with catalog of design patterns including descriptions and best use cases

Update the project architecture tracking after implementing recommendations.

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE:

• After implementing architectural recommendations from get_architecture_recommendation()

• When completing significant structural changes to the codebase

• To document what was actually built vs. what was recommended

• To keep the architecture documentation in sync with the code

IMPORTANT: Call this after implementing architectural recommendations to:

• Log the implementation details

• Track files created and modified

• Update architecture history

• Document any deviations from recommendations

WORKFLOW:

1. get_architecture_recommendation() - Get guidance

2. Implement the recommendation

3. log_change() - Log each file change

4. update_architecture() - Update architecture tracking (THIS STEP)

Discover a CoordMCP project by searching from a directory path.

ESSENTIAL FOR: Joining existing projects, auto-discovering context

This tool searches for a project associated with the given directory. It first checks for an exact match, then searches up to 3 parent directories.

WHEN TO USE:

• Starting work in a project directory and want to see if it's tracked

• Navigating to a subdirectory and finding the parent project

• Auto-discovering projects when you don't know the project_id

• First step when joining an existing project

WORKFLOW:

1. discover_project() - Find the project

2. register_agent() - Register yourself

3. get_project_info() - Get full project details

4. get_active_agents() - See who's working on it

5. start_context() - Begin working

Get project information by ID, name, or workspace path.

ESSENTIAL FOR: Flexible project lookup when you have partial information

This tool provides flexible project lookup. You can specify any combination of identifiers, and it will resolve to the matching project.

Priority: project_id > workspace_path > project_name

WHEN TO USE:

• You know the project_id and want full details

• You only know the project name

• You have the workspace path and want to find the project

• Validating that multiple identifiers point to the same project

List all CoordMCP projects with optional filtering.

ESSENTIAL FOR: Browsing available projects, finding work to join

This tool provides a comprehensive view of all projects in the system. Useful for browsing available projects before selecting one to work on.

WHEN TO USE:

• See all projects in the system

• Find projects under a specific directory

• Check which projects are active vs archived

• Get an overview of all tracked work

Get information about active agents.

ESSENTIAL FOR: Understanding team activity and coordination

This tool shows which agents are currently working, optionally filtered by a specific project. Useful for understanding team activity and coordinating with other agents.

WHEN TO USE:

• See all active agents across all projects

• Check who's working on a specific project before joining

• Monitor team activity and coordination opportunities

• Find collaborators or check for potential conflicts

Create a new task in a project.

Use this to track work that needs to be done. Tasks can be assigned to agents, have dependencies, and be organized in a tree structure.

Get task details.

Assign a task to an agent.

Update task status.

Get all tasks for a project.

Get all tasks assigned to an agent.

Mark a task as completed.

Delete (soft delete) a task.

Send a message to another agent (or broadcast to all).

Use this to communicate with other agents working on the same project. Messages can be targeted to specific agents or broadcast to everyone.

Get messages for an agent.

Retrieve messages sent to you by other agents.

Get messages sent by an agent.

View messages you've sent to others.

Mark a message as read.

Broadcast a message to all agents in a project.

Send a message to all agents working on the project.

Get comprehensive project health dashboard.

Provides a complete overview of project status including health score, task statistics, agent activity, file locks, and actionable recommendations.

WHEN TO USE:

• To check overall project health

• To see what needs attention

• To monitor team progress

• To identify bottlenecks