Config MCP Server

An MCP (Model Context Protocol) server providing developer documentation search, configuration helpers, and settings search tools for AI assistants and development workflows.

Features

🔍 Documentation Search

• searchDocs: Search markdown, MDX, and text files in your workspace
• Supports custom glob patterns for targeted searches
• Perfect for finding documentation, README files, and guides

⚙️ Configuration Management

• getConfig: Read configuration files (JSON/JSONC/YAML/TOML)
• setConfig: Update configuration files safely with dot-notation key paths
• listConfigs: Discover all configuration files in your workspace

🎛️ Settings Search

• searchSettings: Search through JSON/JSONC settings files
• Ideal for VS Code settings, application configs, and more
• Customizable file patterns for different types of settings

Requirements

• Node.js 18.17+ (20+ recommended)
• MCP-compatible client (Claude Desktop, Continue.dev, etc.)

Installation & Setup

1. Install Dependencies

npm install

2. Build the Server

npm run build

3. Install VS Code MCP Extension (Recommended)

For the best experience with GitHub Copilot, install the MCP extension for VS Code:

1. Open VS Code
2. Go to Extensions (Ctrl/Cmd + Shift + X)
3. Search for "Model Context Protocol" or "MCP"
4. Install the official MCP extension
5. Reload VS Code

4. Configure Your MCP Client

Add to your MCP client configuration:

VS Code with GitHub Copilot (.vscode/settings.json):

{
  "mcp.servers": {
    "config-mcp-server": {
      "command": "node",
      "args": ["${workspaceFolder}/path/to/Config-MCP-Server/dist/index.js"],
      "cwd": "${workspaceFolder}",
      "env": {
        "NODE_ENV": "production"
      }
    }
  },
  "github.copilot.advanced": {
    "mcp.enabled": true,
    "mcp.servers": ["config-mcp-server"]
  }
}

VS Code User Settings (settings.json):

{
  "mcp.global.servers": {
    "config-mcp-server": {
      "command": "node",
      "args": ["path/to/Config-MCP-Server/dist/index.js"],
      "autoStart": true,
      "workspaceRelative": true
    }
  }
}

Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "config-mcp-server": {
      "command": "node",
      "args": ["path/to/Config-MCP-Server/dist/index.js"],
      "cwd": "path/to/your/workspace"
    }
  }
}

Continue.dev (.continue/config.json):

{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "node",
          "args": ["path/to/Config-MCP-Server/dist/index.js"]
        }
      }
    ]
  }
}

Development Scripts

• npm run dev — Start in watch mode (supports .ts imports)
• npm run build — Compile TypeScript to dist/
• npm start — Run compiled server
• npm run lint — Check code style
• npm run format — Format code with Prettier

Tool Reference

searchDocs

Search developer documentation and markdown files.

// Parameters:
{
  query: string,           // Search term or phrase
  include?: string[]       // Custom glob patterns (optional)
}

// Example usage by AI:
// "Search for authentication setup instructions"
// Uses: searchDocs({ query: "authentication setup" })

searchSettings

Search configuration and settings files for specific keys or values.

// Parameters:
{
  query: string,           // Search term
  include?: string[]       // Custom patterns (optional)
}

// Example usage by AI:
// "Find VS Code Python interpreter settings"
// Uses: searchSettings({ query: "python.defaultInterpreterPath" })

getConfig

Read and parse configuration files with optional key extraction.

// Parameters:
{
  file: string,           // Path to config file
  key?: string           // Dot-separated key path (optional)
}

// Example usage by AI:
// "Get the database host from config.json"
// Uses: getConfig({ file: "config.json", key: "database.host" })

setConfig

Update configuration files safely with automatic format detection.

// Parameters:
{
  file: string,           // Path to config file
  key: string,           // Dot-separated key path
  value: string          // JSON-encoded value
}

// Example usage by AI:
// "Set the API timeout to 30000 in config.json"
// Uses: setConfig({ file: "config.json", key: "api.timeout", value: "30000" })

listConfigs

Discover configuration files in the workspace.

// Parameters:
{
  include?: string[]      // Glob patterns (default: common config files)
}

// Example usage by AI:
// "Show me all configuration files"
// Uses: listConfigs({})

Supported File Formats

• JSON (.json) - Standard JSON files
• JSONC (.jsonc) - JSON with comments (VS Code style)
• YAML (.yaml, .yml) - YAML configuration files
• TOML (.toml) - TOML configuration files
• Markdown (.md, .mdx) - Documentation files
• Text (.txt) - Plain text files

Error Handling

All tools include comprehensive error handling and return user-friendly error messages when:

• Files are not found or unreadable
• Invalid JSON/YAML/TOML syntax
• Permission issues
• Invalid key paths or values

TypeScript Support

The server is built with TypeScript and supports:

• Import resolution with .ts extensions in development
• Path aliases (@/lib/...) for cleaner imports
• Strict type checking for reliability
• Source maps for debugging

GitHub Copilot Integration

Enhanced Copilot Experience

With this MCP server, GitHub Copilot gains powerful workspace awareness:

• Context-Aware Suggestions: Copilot can reference your project's documentation and configuration
• Smart Configuration: Automatically suggests configuration changes based on your project setup
• Workspace Understanding: Better code completions using your project's README and docs

VS Code Features

• Workspace Integration: Automatically detects when you're working in a configured workspace
• Command Palette: Access MCP tools via VS Code Command Palette (Ctrl/Cmd + Shift + P)
• Status Bar: Shows MCP server connection status
• Output Panel: View MCP server logs in VS Code Output panel

Usage Examples

In VS Code with GitHub Copilot

Chat with Copilot:

• "@workspace Search for authentication setup in our docs"
• "Help me find where the API configuration is defined"
• "What's the current database timeout setting?"
• "Update the dev server port to 3001"

Command Palette Integration

1. Press Ctrl/Cmd + Shift + P
2. Type "MCP: Config" to see available commands:
   • MCP: Search Documentation
   • MCP: Find Settings
   • MCP: Read Configuration
   • MCP: Update Configuration
   • MCP: List Config Files

Traditional Examples

Finding Documentation

Ask your AI: "Search for Docker setup instructions" → Uses searchDocs to find relevant documentation

Managing Configuration

Ask your AI: "Update the database port to 5433 in my config file" → Uses getConfig to read current config, then setConfig to update it

Exploring Settings

Ask your AI: "Show me all my VS Code Python settings" → Uses searchSettings to find Python-related configuration

VS Code & Copilot Troubleshooting

Common Issues

MCP Server Not Starting:

1. Check VS Code Output panel (View > Output > Model Context Protocol)
2. Verify Node.js is installed and accessible in PATH
3. Ensure the server path in settings.json is correct
4. Try reloading VS Code (Ctrl/Cmd + Shift + P > Developer: Reload Window)

Copilot Not Using MCP Context:

1. Verify GitHub Copilot extension is installed and active
2. Check that github.copilot.advanced.mcp.enabled is set to true
3. Restart VS Code after configuration changes
4. Use @workspace prefix in Copilot chat for explicit context

Performance Optimization:

1. Adjust maxResults in settings if searches are slow
2. Use more specific glob patterns in include parameters
3. Add common build directories to search exclusions

VS Code Tips

• Quick Access: Use Ctrl/Cmd + Shift + P then type "MCP" to see all available commands
• Status Monitoring: Check the status bar for MCP connection indicators
• Workspace Templates: Copy .vscode/settings.json.template to your project's .vscode/settings.json
• Global vs Workspace: Use User settings for global MCP config, Workspace settings for project-specific setup

GitHub Copilot Best Practices

• Start questions with @workspace to engage MCP context
• Be specific about file types: "search TypeScript configs" vs "search configs"
• Use natural language: "What's my current database setup?" instead of technical queries
• Leverage context: Copilot will automatically use your project's documentation in suggestions

Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Run npm run lint and npm run format
5. Test with VS Code MCP integration
6. Submit a pull request

License

MIT - See LICENSE file for details