MCP Integration

DevAll includes a built-in MCP (Model Context Protocol) server that allows AI assistants like Claude to control your entire development environment through natural language.

What is MCP?

The Model Context Protocol is a standard for connecting AI assistants to external tools and data sources. DevAll’s MCP server exposes tools that let AI assistants:

Start and stop services
View service status and logs
Restart processes
Modify configuration
Monitor system resources

Supported Clients

DevAll’s MCP server works with:

Claude Desktop: Anthropic’s desktop application for Claude
Claude Code: Anthropic’s CLI tool for development workflows
Any MCP-compatible client: Custom integrations and other AI tools

Quick Setup

Automatic Setup (Recommended)

The easiest way to set up the MCP server:

npx devall mcp setup

This command will:

Install MCP server dependencies
Build the MCP server
Detect Claude Desktop and/or Claude Code
Automatically configure detected clients
Add DevAll to your client settings

Then start the DevAll dashboard:

npx devall

Your MCP-enabled clients can now control DevAll!

Manual Setup

If automatic setup doesn’t work, you can configure MCP manually.

1. Build the MCP Server

First, build the MCP server:

cd mcp
npm install
npm run build

This creates the MCP server executable at mcp/bin/index.js.

2. Configure Your Client

For Claude Desktop

Config file location:

macOS:

~/Library/Application Support/Claude/claude_desktop_config.json

Linux:

~/.config/Claude/claude_desktop_config.json

Windows:

%APPDATA%\Claude\claude_desktop_config.json

Add this configuration:

{
  "mcpServers": {
    "devall": {
      "command": "node",
      "args": ["/absolute/path/to/devall-core/mcp/bin/index.js"]
    }
  }
}

Important: Replace /absolute/path/to/devall-core with the actual absolute path to your DevAll installation.

Restart: Close and reopen Claude Desktop completely.

For Claude Code

Config file location:

macOS/Linux:

~/.config/claude-code/mcp_settings.json

Windows:

%APPDATA%\claude-code\mcp_settings.json

Add this configuration:

{
  "mcpServers": {
    "devall": {
      "command": "node",
      "args": ["/absolute/path/to/devall-core/mcp/bin/index.js"],
      "env": {}
    }
  }
}

Important: Replace /absolute/path/to/devall-core with the actual absolute path to your DevAll installation.

Restart: Restart your Claude Code session.

3. Verify Installation

Check that the MCP server is configured:

Claude Desktop: Look for the hammer icon (🔨) in the chat interface

Claude Code: MCP tools will be available automatically in your session

Test command: Ask “What DevAll services are configured?” to verify the connection.

Using DevAll with AI Assistants

Once configured, you can control DevAll naturally:

Starting Services

“Start the frontend service”

“Launch all autostart services”

“Start the API and database”

Stopping Services

“Stop the backend server”

“Shut down all services”

Viewing Status

“What services are running?”

“Show me the status of all services”

“Is the frontend service up?”

Checking Logs

“Show me the last 50 lines of the API logs”

“What errors are in the backend logs?”

Restarting Services

“Restart the frontend”

“Restart all services”

Configuration

“What services are configured?”

“Add a new service for the authentication server”

Available MCP Tools

DevAll exposes these tools to AI assistants. This is the complete reference for all available MCP functions.

Service Management Tools

`list_services`

Lists all configured services with their current status.

Parameters: None

Returns:

{
  "services": [
    {
      "id": "frontend",
      "name": "Frontend",
      "status": "running",
      "port": 3000,
      "pid": 12345,
      "uptime": "2h 15m"
    },
    {
      "id": "backend",
      "name": "Backend API",
      "status": "stopped",
      "port": 8080,
      "pid": null
    }
  ]
}

Use cases:

Get an overview of all services
Check which services are running
See service ports and PIDs

`get_service_status`

Gets detailed status information for a specific service.

Parameters:

name (string, required): Service name or ID

Returns:

{
  "id": "frontend",
  "name": "Frontend",
  "status": "running",
  "port": 3000,
  "pid": 12345,
  "uptime": "2h 15m 32s",
  "restarts": 0,
  "lastRestart": null,
  "memory": "125MB",
  "cpu": "2.5%"
}

Status values:

running: Service is active and healthy
stopped: Service is not running
starting: Service is in startup phase
crashed: Service has crashed
error: Service encountered an error

Use cases:

Check if a specific service is running
Get detailed resource usage
Monitor service uptime

`start_service`

Starts a stopped service.

Parameters:

name (string, required): Service name or ID

Returns:

{
  "success": true,
  "message": "Service 'frontend' started successfully",
  "service": {
    "id": "frontend",
    "status": "starting",
    "pid": 12456
  }
}

Error responses:

Service already running
Service not found in configuration
Port already in use

Use cases:

Start a service that was stopped
Launch services for development session
Restart crashed services

`stop_service`

Stops a running service gracefully.

Parameters:

name (string, required): Service name or ID

Returns:

{
  "success": true,
  "message": "Service 'frontend' stopped successfully",
  "service": {
    "id": "frontend",
    "status": "stopped",
    "pid": null
  }
}

Use cases:

Stop a service before making changes
Shut down services after development
Free up ports

`restart_service`

Restarts a service (stops then starts).

Parameters:

name (string, required): Service name or ID

Returns:

{
  "success": true,
  "message": "Service 'frontend' restarted successfully",
  "service": {
    "id": "frontend",
    "status": "starting",
    "pid": 12457
  }
}

Use cases:

Apply configuration changes
Clear service state
Recover from errors

Logging Tools

`get_service_logs`

Retrieves recent log output from a service.

Parameters:

name (string, required): Service name or ID
lines (number, optional): Number of log lines to retrieve (default: 100, max: 1000)

Returns:

{
  "service": "frontend",
  "lines": 100,
  "logs": [
    "[2024-01-15 10:30:15] Server listening on port 3000",
    "[2024-01-15 10:30:16] GET / 200 15ms",
    "[2024-01-15 10:30:18] GET /api/users 200 45ms",
    "[2024-01-15 10:30:20] POST /api/login 201 120ms"
  ],
  "totalLines": 1543
}

Use cases:

Debug service issues
Monitor service activity
Check for errors or warnings
View startup messages

`clear_service_logs`

Clears accumulated logs for a service.

Parameters:

name (string, required): Service name or ID

Returns:

{
  "success": true,
  "message": "Logs cleared for service 'frontend'",
  "clearedLines": 1543
}

Use cases:

Clear logs before testing
Free up memory
Start fresh log collection

Configuration Tools

`get_config`

Retrieves the current DevAll configuration.

Parameters: None

Returns:

{
  "dashboard": {
    "port": 7777,
    "open": true
  },
  "services": [
    {
      "id": "frontend",
      "name": "Frontend",
      "command": "npm",
      "args": ["run", "dev"],
      "cwd": "./frontend",
      "port": 3000,
      "autostart": true,
      "color": "#3b82f6"
    }
  ],
  "configFile": "/path/to/devall.yaml"
}

Use cases:

View all configured services
Check service settings
Understand port assignments
Debug configuration issues

Tool Summary Table

Tool	Purpose	Required Params	Optional Params
`list_services`	List all services	None	None
`get_service_status`	Get service details	`name`	None
`start_service`	Start a service	`name`	None
`stop_service`	Stop a service	`name`	None
`restart_service`	Restart a service	`name`	None
`get_service_logs`	Get service logs	`name`	`lines`
`clear_service_logs`	Clear service logs	`name`	None
`get_config`	Get configuration	None	None

Running MCP Server Standalone

You can run the MCP server independently of Claude Desktop:

STDIO Mode (for Claude Desktop)

npx devall mcp start

SSE Mode (for web clients)

npx devall mcp start --sse --port 3001

Access at: http://localhost:3001/sse

Development & Testing

Test with MCP Inspector

The MCP Inspector is a tool for testing MCP servers:

npm run mcp:inspector

This opens a web interface where you can:

Test all available tools
View request/response payloads
Debug MCP server behavior

Start MCP Server in Dev Mode

Watch for changes and auto-reload:

cd mcp
npm run dev

Security Considerations

Authentication

The MCP server currently has no authentication. Ensure:

DevAll dashboard is only accessible on localhost
MCP server only accepts local connections
Don’t expose ports externally

Permissions

The MCP server has full control over configured services. It can:

Start/stop any process
View all logs
Modify configuration

Only use with trusted AI assistants in secure environments.

Troubleshooting

MCP Server Not Showing Up

Check Claude Desktop config is correct:

cat ~/Library/Application\ Support/Claude/claude_desktop_config.json

Verify the path to index.js is absolute
Check MCP server builds successfully:
Terminal window
```
cd mcp && npm run build
```
Restart Claude Desktop completely

”DevAll server is not running”

The MCP server requires the DevAll dashboard to be running:

# Terminal 1: Start dashboard
devall

# Terminal 2: Use Claude Desktop
# (MCP tools now work)

Commands Failing

Check DevAll dashboard is accessible:
Terminal window
```
curl http://localhost:7777/api/health
```
View MCP server logs (if running standalone):
Terminal window
```
npx devall mcp start
# Check stderr output
```
Test with MCP Inspector:
Terminal window
```
npm run mcp:inspector
```

Example Workflows

Starting a Full-Stack App

“I need to work on the frontend. Start the frontend service and the API gateway.”

AI will:

Call start_service for “Frontend”
Call start_service for “API Gateway”
Confirm both are running

Debugging a Service

“The backend is behaving strangely. Show me the last 100 log lines.”

AI will:

Call get_service_logs with lines: 100
Analyze the logs
Suggest fixes based on errors

Restarting After Config Change

“I just updated the environment variables. Restart all services.”

AI will:

Call list_services to get all services
Call restart_service for each one
Verify they’re all running

Checking System Health

“Are all my services running? What’s their status?”

AI will:

Call list_services
Present a summary of service states
Alert you to any stopped/crashed services

Advanced Usage

Custom MCP Tools

You can extend DevAll’s MCP server with custom tools:

Edit mcp/src/index.js
Add your tool to the tools list
Implement the tool handler
Rebuild: npm run build

Integration with Other MCP Servers

Claude Desktop can use multiple MCP servers simultaneously. Combine DevAll with:

File system tools: Read/write code
Git tools: Commit changes
Database tools: Query data
Slack tools: Send notifications

Example config:

{
  "mcpServers": {
    "devall": {
      "command": "node",
      "args": ["/path/to/devall/mcp/bin/index.js"]
    },
    "filesystem": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-filesystem"]
    }
  }
}

Client-Specific Guides

For usage examples and workflows specific to your MCP client:

Claude Code users: See the Claude Code Integration guide for usage examples, workflows, and best practices
Other AI agents: See the AI Agents Integration guide for CLI-based alternatives

Next Steps

Claude Code Integration - Usage guide for Claude Code

Resources

Model Context Protocol Documentation - Official MCP docs
Claude Desktop - Download Claude Desktop
Claude Code - Claude Code documentation
MCP Inspector - Test MCP servers