Vibe-Coder MCP Server

A Model Context Protocol server that implements a structured development workflow for LLM-based coding.

Overview

This MCP server helps LLMs build features in an organized, clean, and safe manner by providing:

A structured feature clarification process with guided questions
PRD and implementation plan generation
Phased development with task tracking
Progress tracking and status reporting
Document storage and retrieval capabilities

Features

Resources

Feature details, PRDs, and implementation plans
Progress reports and status tracking
Phase and task details

Tools

start_feature_clarification - Begin the feature clarification process
provide_clarification - Answer clarification questions about a feature
generate_prd - Generate a Product Requirements Document and implementation plan
create_phase - Create a development phase for a feature
add_task - Add tasks to a development phase
update_phase_status - Update the status of a phase
update_task_status - Update the completion status of a task
get_next_phase_action - Get guidance on what to do next
get_document_path - Get the path of a generated document
save_document - Save a document to a specific location

Prompts

feature-planning - A prompt template for planning feature development

Document Storage

The server includes a hybrid document storage system that:

Automatically saves generated documents (PRDs, implementation plans) to files
Maintains an in-memory copy for quick access
Allows clients to retrieve document paths and save to custom locations

Default Storage Location

Documents are stored in the documents/{featureId}/ directory by default, with filenames based on document type:

documents/{featureId}/prd.md - Product Requirements Document
documents/{featureId}/implementation-plan.md - Implementation Plan

Custom Storage

You can use the save_document tool to save documents to custom locations:

{
  "featureId": "feature-123",
  "documentType": "prd",
  "filePath": "/custom/path/feature-123-prd.md"
}

Path Retrieval

To get the path of a document, use the get_document_path tool:

{
  "featureId": "feature-123",
  "documentType": "prd"
}

This returns both the path and whether the document has been saved to disk.

Development

Install dependencies:

npm install

Build the server:

npm run build

For development with auto-rebuild:

npm run watch

Installation

To use with compatible MCP clients:

On MacOS: ~/Library/Application Support/Claude/claude_desktop_config.json On Windows: %APPDATA%/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "vibe-coder-mcp": {
      "command": "/path/to/vibe-coder-mcp/build/mcp-server.js"
    }
  }
}

Debugging

Since MCP servers communicate over stdio, debugging can be challenging. We recommend using the MCP Inspector, which is available as a package script:

npm run inspector

The Inspector will provide a URL to access debugging tools in your browser.

Implementation Notes

This server is implemented using the high-level McpServer class from the Model Context Protocol TypeScript SDK, which simplifies the process of creating MCP servers by providing a clean API for defining resources, tools, and prompts.

import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

// Create an MCP server
const server = new McpServer({
  name: "Vibe-Coder",
  version: "0.3.0"
});

// Add a resource
server.resource(
  "features-list",
  "features://list",
  async (uri) => ({ /* ... */ })
);

// Add a tool
server.tool(
  "start_feature_clarification",
  { /* parameters schema */ },
  async (params) => ({ /* ... */ })
);

// Add a prompt
server.prompt(
  "feature-planning",
  { /* parameters schema */ },
  (params) => ({ /* ... */ })
);

// Start the server
const transport = new StdioServerTransport();
await server.connect(transport);

Workflow

The Vibe-Coder MCP server is designed to guide the development process through the following steps:

Feature Clarification: Start by gathering requirements and understanding the feature's purpose, target users, and constraints
Documentation: Generate a PRD and implementation plan based on the clarified requirements
Phased Development: Break down the implementation into logical phases with clear tasks
Progress Tracking: Monitor the completion of tasks and phases to guide development
Completion: Verify that all requirements have been implemented and the feature is ready for use

Integrations