mcp-config.json

{
  "tools": {
    "fullstack-starter-kit-generator": {
      "description": "Generates full-stack project starter kits with custom tech stacks (e.g., frontend framework, backend language, database).",
      "use_cases": [
        "project scaffolding",
        "tech stack setup",
        "application boilerplate",
        "new project",
        "starter kit"
      ],
      "input_patterns": [
        "create starter kit for {use_case}",
        "generate {type} project",
        "scaffold {application_type} app",
        "setup boilerplate for {project}",
        "generate starter kit for {use_case}",
        "generate fullstack app for {purpose}",
        "create react nodejs starter",
        "generate vue python starter kit",
        "create angular dotnet scaffold",
        "generate microservices starter",
        "create serverless project template",
        "generate mobile app starter",
        "create ai platform scaffold",
        "generate ecommerce starter kit",
        "create saas boilerplate",
        "generate jamstack starter",
        "create blockchain app scaffold",
        "generate progressive web app starter",
        "create graphql api starter",
        "generate monorepo scaffold",
        "create docker-based starter",
        "generate kubernetes-ready project",
        "create full project with {features}"
      ]
    },
    "research-manager": {
      "description": "Performs comprehensive research on any technical topic including frameworks, libraries, packages, tools, and best practices using Perplexity Sonar.",
      "use_cases": [
        "research {any topic}",
        "find latest {technology} packages",
        "explore {framework} ecosystem",
        "investigate UI/UX libraries",
        "discover CLI tools and frameworks",
        "analyze development trends",
        "compare {tool} alternatives",
        "best practices for {domain}",
        "explain {concept}",
        "technical deep dive",
        "learn about {topic}",
        "research packages and libraries",
        "investigate framework options"
      ],
      "input_patterns": [
        "research {query}",
        "perform research on {query}",
        "investigate {query}",
        "explore {query}",
        "find {query} alternatives",
        "discover {query} options",
        "compare {query}",
        "best practices for {query}",
        "explain {query}",
        "latest {query} packages",
        "research best practices for {query}",
        "analyze market trends in {query}",
        "research security implications of {query}",
        "investigate performance of {query}",
        "explore alternatives to {query}",
        "research implementation patterns for {query}",
        "analyze competitive landscape for {query}",
        "research user needs for {query}",
        "investigate technical feasibility of {query}",
        "explore integration options for {query}",
        "research compliance requirements for {query}",
        "analyze cost implications of {query}",
        "research scaling strategies for {query}",
        "investigate migration path for {query}",
        "explore emerging trends in {query}",
        "research case studies for {query}",
        "analyze technical debt in {query}"
      ]
    },
    "prd-generator": {
      "description": "Creates comprehensive Product Requirements Documents (PRDs) based on a feature or product description.",
      "use_cases": [
        "product requirements",
        "feature documentation",
        "prd",
        "feature specification",
        "document feature"
      ],
      "input_patterns": [
        "create prd for {productDescription}",
        "document requirements for {productDescription}",
        "generate prd for {productDescription}",
        "write product requirements for {productDescription}",
        "create product specification for {productDescription}",
        "generate requirements document for {productDescription}",
        "write prd with market analysis for {productDescription}",
        "create detailed prd for {productDescription}",
        "document product vision for {productDescription}",
        "generate prd for mvp of {productDescription}",
        "create technical prd for {productDescription}",
        "write user-focused prd for {productDescription}",
        "generate prd with competitive analysis",
        "create prd for {productDescription}",
        "document feature requirements for {productDescription}",
        "generate prd with success metrics",
        "write prd for {productDescription}",
        "create agile prd for {productDescription}",
        "generate prd with user personas",
        "document api requirements for {productDescription}"
      ]
    },
    "user-stories-generator": {
      "description": "Generates user stories with acceptance criteria based on a feature or requirement.",
      "use_cases": [
        "user stories",
        "workflow definition",
        "agile planning",
        "acceptance criteria",
        "feature breakdown"
      ],
      "input_patterns": [
        "create stories for {productDescription}",
        "define workflow for {productDescription}",
        "generate user stories for {productDescription}",
        "write user stories for {productDescription}",
        "define acceptance criteria for {productDescription}",
        "create agile stories for {productDescription}",
        "generate stories with gherkin scenarios",
        "write stories for {productDescription}",
        "create story cards for {productDescription}",
        "generate stories from prd",
        "create stories with story points",
        "write stories for api {productDescription}",
        "generate stories for ui {productDescription}",
        "create backend stories for {productDescription}",
        "write stories with dependencies",
        "generate stories for integration",
        "create stories for migration",
        "write performance stories",
        "generate security stories",
        "create stories for testing"
      ]
    },
    "task-list-generator": {
      "description": "Produces development task lists with dependencies from requirements or user stories.",
      "use_cases": [
        "task breakdown",
        "sprint planning",
        "project tasks",
        "development plan"
      ],
      "input_patterns": [
        "plan tasks for {productDescription}",
        "break down {productDescription} into tasks",
        "create task list for {productDescription}",
        "generate task list for {productDescription}",
        "create tasks for {productDescription}",
        "plan sprint tasks for {productDescription}",
        "generate development tasks for {productDescription}",
        "create implementation tasks for {productDescription}",
        "list tasks with dependencies for {productDescription}",
        "generate tasks with time estimates",
        "create technical tasks for {productDescription}",
        "plan tasks for {productDescription}",
        "generate deployment tasks",
        "create testing tasks for {productDescription}",
        "break down {productDescription} into subtasks",
        "generate tasks for code review",
        "create devops tasks",
        "plan refactoring tasks for {productDescription}",
        "generate migration tasks",
        "create tasks for documentation",
        "plan performance optimization tasks",
        "generate security audit tasks"
      ]
    },
    "rules-generator": {
      "description": "Creates project-specific development rules, standards, or guidelines.",
      "use_cases": [
        "coding standards",
        "project guidelines",
        "linting rules",
        "style guide",
        "development rules"
      ],
      "input_patterns": [
        "setup rules for {productDescription}",
        "define standards for {productDescription}",
        "create style guide for {productDescription}",
        "generate rules for {productDescription}",
        "create coding standards for {productDescription}",
        "define guidelines for {productDescription}",
        "generate style guide for {productDescription}",
        "create linting rules for {productDescription}",
        "define commit message rules",
        "generate security guidelines",
        "create api design rules",
        "define database naming conventions",
        "generate testing standards",
        "create code review checklist",
        "define branch naming rules",
        "generate documentation standards",
        "create accessibility guidelines",
        "define performance benchmarks",
        "generate deployment rules",
        "create error handling guidelines",
        "define logging standards",
        "generate ci/cd rules",
        "create architecture principles"
      ]
    },
    "run-workflow": {
      "description": "Runs a predefined sequence of tool calls (a workflow) based on a workflow name and input parameters.",
      "use_cases": [
        "run workflow",
        "execute plan",
        "start process",
        "automate sequence",
        "execute workflow",
        "run automation"
      ],
      "input_patterns": [
        "run workflow {workflowName}",
        "start {workflowName} workflow with input {workflowInput}",
        "execute the {workflowName} plan",
        "run workflow {workflow_name}",
        "execute {workflow_name} workflow",
        "start {workflow_name} with {parameters}",
        "run planning workflow for {project}",
        "execute full stack workflow",
        "start development workflow",
        "run deployment workflow",
        "execute testing workflow",
        "start ci/cd workflow",
        "run migration workflow",
        "execute analysis workflow",
        "start documentation workflow",
        "run security audit workflow",
        "execute performance workflow",
        "start refactoring workflow"
      ]
    },
    "get-job-result": {
      "description": "Retrieves the status and result of a background job previously initiated by another tool.",
      "use_cases": [
        "job status",
        "check job",
        "get job result",
        "task progress",
        "background task status"
      ],
      "input_patterns": [
        "get result for job {jobId}",
        "check status of job {jobId}",
        "what is the result of {jobId}",
        "get result for job {job_id}",
        "check status of job {job_id}",
        "retrieve job {job_id} output",
        "what is the status of {job_id}",
        "show job {job_id} progress",
        "get job completion status",
        "check if job {job_id} is done",
        "retrieve background task result",
        "show job execution details",
        "get job error details",
        "check job queue status",
        "retrieve all job results",
        "show failed jobs",
        "get job execution time",
        "check job dependencies"
      ]
    },
    "map-codebase": {
      "description": "Indexes and maps a codebase structure, providing class/function maps, comments, and Mermaid diagrams for AI consumption. Captures doc-strings and inline comments for semantic context.",
      "use_cases": [
        "map codebase",
        "analyze code structure",
        "understand project architecture",
        "generate code documentation map",
        "index project symbols",
        "visualize code dependencies",
        "semantic code map"
      ],
      "input_patterns": [
        "map codebase {path}",
        "map the codebase {path}",
        "map the codebase for {path}",
        "generate a code map for project {projectName}",
        "analyze the structure of {directory}",
        "show me a semantic map of the codebase",
        "create architecture diagram for {path}",
        "map codebase at {path}",
        "generate code map for {project_path}",
        "analyze structure of {directory}",
        "create semantic map of codebase",
        "show architecture diagram for {path}",
        "map {language} project at {path}",
        "visualize dependencies in {project_path}",
        "extract class hierarchy from {path}",
        "show function call graph for {project}",
        "generate method sequence diagram",
        "analyze imports in {project_path}",
        "map codebase excluding {patterns}",
        "create architecture overview",
        "index symbols in {directory}",
        "extract documentation from {path}",
        "show file dependencies for {project}",
        "analyze {framework} project structure",
        "map microservices architecture",
        "generate component diagram",
        "extract api endpoints from {path}"
      ]
    },
    "vibe-task-manager": {
      "description": "Production-ready AI-agent-native task management system with recursive decomposition design (RDD) methodology. Features natural language processing, multi-agent coordination, artifact parsing (PRD/task list integration), session persistence, and comprehensive CLI. Supports project creation, task decomposition, dependency management, and autonomous development workflows with 99.9% test success rate.",
      "use_cases": [
        "task management",
        "project planning",
        "task decomposition",
        "dependency tracking",
        "agent coordination",
        "recursive task breakdown",
        "atomic task detection",
        "development workflow",
        "project organization",
        "artifact parsing",
        "PRD integration",
        "task list integration",
        "natural language commands",
        "session persistence",
        "orchestration workflows"
      ],
      "input_patterns": [
        "create project {projectName}",
        "decompose task {taskId}",
        "list projects",
        "run task {taskId}",
        "check status of {projectName}",
        "refine task {taskId}",
        "manage tasks for {projectName}",
        "break down {requirement} into atomic tasks",
        "coordinate agents for {projectName}",
        "parse prd {fileName}",
        "import artifact {type} {filePath}",
        "vibe-task-manager {naturalLanguageCommand}",
        "orchestrate workflow for {projectName}",
        "create project for {project_name}",
        "create a new project for building {app_type}",
        "list all my projects",
        "show project status for {project_name}",
        "decompose {project_name} into tasks",
        "decompose {feature} into atomic tasks",
        "refine task {task_id} with {refinement}",
        "create task for {feature} in project {project_name}",
        "list pending tasks for {project_name}",
        "run task {task_id}",
        "parse prd for {project_name}",
        "import prd from {file_path}",
        "parse task list for {project_name}",
        "import tasks from document",
        "show progress for {project_name}",
        "assign task to agent {agent_id}",
        "create epic for {feature_area}",
        "track velocity for {project_name}",
        "generate dependency graph",
        "orchestrate agents for {project_name}"
      ]
    },
    "curate-context": {
      "description": "Intelligently analyzes codebases and curates comprehensive context packages for AI-driven development tasks. Generates refined prompts, relevance-ranked files, and meta-prompts for downstream AI agents. Supports automatic task type detection, file relevance scoring, content optimization, and XML output formatting for seamless integration with AI development workflows.",
      "use_cases": [
        "context curation",
        "codebase analysis",
        "AI task preparation",
        "file relevance ranking",
        "meta-prompt generation",
        "task decomposition",
        "development context",
        "code understanding",
        "AI workflow preparation"
      ],
      "input_patterns": [
        "curate context for {prompt}",
        "analyze codebase for {prompt}",
        "prepare context for {prompt}",
        "generate meta-prompt for {prompt}",
        "rank files for {prompt}",
        "create context package for {prompt}",
        "prepare context for adding {prompt}",
        "analyze codebase for {prompt}",
        "curate context for bug fix in {prompt}",
        "prepare refactoring context for {prompt}",
        "optimize context for {prompt} development",
        "create performance optimization context",
        "curate security review context",
        "prepare migration context for {prompt}",
        "generate ai-ready context for {prompt}",
        "select relevant files for {prompt}",
        "create focused context for {prompt}",
        "prepare debugging context for {prompt}",
        "curate testing context for {prompt}",
        "generate deployment context",
        "create integration context for {prompt}",
        "prepare architecture review context"
      ]
    },
    "register-agent": {
      "description": "Multi-agent coordination and registration system for distributed development workflows. Supports agent registration with capability-based matching, multi-transport support (stdio, SSE, WebSocket, HTTP), and real-time agent coordination.",
      "use_cases": [
        "agent registration",
        "multi-agent coordination",
        "capability matching",
        "agent management",
        "distributed workflows",
        "agent orchestration",
        "transport configuration"
      ],
      "input_patterns": [
        "register agent {agentId} with capabilities {capabilities}",
        "register {transportType} agent for {project}",
        "add agent {agentId} to coordination system",
        "setup agent with {capabilities}",
        "register agent {agent_id}",
        "register {transport_type} agent",
        "add agent with capabilities {capabilities}",
        "setup agent for {project}",
        "register coding agent",
        "add testing agent to pool",
        "register deployment agent",
        "setup review agent",
        "add agent with {skills}",
        "register agent on port {port}",
        "setup websocket agent",
        "register sse agent",
        "add agent to coordination system",
        "setup distributed agent",
        "register specialized agent for {task_type}"
      ]
    },
    "get-agent-tasks": {
      "description": "Task polling and retrieval system for AI agents. Provides capability-based task polling, intelligent task queue management, priority-based task assignment, and real-time task availability notifications.",
      "use_cases": [
        "task polling",
        "agent task retrieval",
        "capability-based assignment",
        "task queue management",
        "agent coordination",
        "task distribution"
      ],
      "input_patterns": [
        "get tasks for agent {agentId}",
        "poll tasks with capabilities {capabilities}",
        "retrieve available tasks",
        "check task queue for {agentId}",
        "get tasks for agent {agent_id}",
        "poll tasks for {capabilities}",
        "check task queue for agent",
        "get next task for agent",
        "poll high priority tasks",
        "retrieve tasks matching {skills}",
        "get pending agent tasks",
        "check for new assignments",
        "poll tasks for review agent",
        "get tasks by capability",
        "retrieve urgent tasks",
        "check task availability",
        "get task batch for agent",
        "poll continuous tasks"
      ]
    },
    "submit-task-response": {
      "description": "Task completion and response handling system. Supports task completion status tracking (DONE, ERROR, PARTIAL), detailed completion metadata, automatic job status updates, and SSE notifications for real-time updates.",
      "use_cases": [
        "task completion",
        "response submission",
        "status tracking",
        "completion metadata",
        "agent response handling",
        "task workflow"
      ],
      "input_patterns": [
        "submit response for task {taskId}",
        "complete task {taskId} with status {status}",
        "report task completion",
        "submit task result",
        "submit response for task {task_id}",
        "complete task {task_id}",
        "mark task as done",
        "submit error for task {task_id}",
        "report partial completion",
        "submit task with status {status}",
        "complete task with output",
        "report task failure",
        "submit review results",
        "complete testing task",
        "submit deployment status",
        "report task progress",
        "submit task metrics"
      ]
    },
    "process-request": {
      "description": "Processes natural language requests, determines the best tool using semantic matching and fallbacks, and either asks for confirmation or executes the tool directly.",
      "use_cases": [
        "natural language processing",
        "tool routing",
        "semantic matching",
        "request interpretation",
        "automatic tool selection",
        "smart request handling"
      ],
      "input_patterns": [
        "process {natural_language_request}",
        "handle {user_query}",
        "route {request}",
        "interpret {user_input}",
        "what tool should I use for {request}",
        "process {request}",
        "route {natural_language_request}",
        "what tool for {request}",
        "help me with {task}",
        "i need to {action}",
        "can you {action}",
        "please {action}",
        "execute {command}",
        "run {natural_language_command}",
        "do {task} for me",
        "assist with {requirement}",
        "support {development_task}",
        "automate {process}"
      ]
    }
  }
}