Debugging & Testing MCPs with MCP Inspector

# Install MCP Inspector
npm install -g @modelcontextprotocol/inspector

# Or use npx
npx @modelcontextprotocol/inspector

# Start inspector with your MCP server
mcp-inspector --server "node dist/server.js"

# With specific port
mcp-inspector --server "node dist/server.js" --port 3001

# With environment variables
GITHUB_TOKEN=your_token mcp-inspector --server "mcp-server-github"

// test/server.test.js
import { MCPServer } from '@modelcontextprotocol/sdk';
import { expect } from 'chai';

describe('MCP Server', () => {
  let server;

  beforeEach(() => {
    server = new MCPServer({
      name: 'test-server',
      version: '1.0.0'
    });
  });

  it('should list available tools', async () => {
    const tools = await server.listTools();
    expect(tools).to.be.an('array');
    expect(tools.length).to.be.greaterThan(0);
  });

  it('should execute tool correctly', async () => {
    const result = await server.callTool('test-tool', {
      param: 'value'
    });
    expect(result).to.have.property('content');
  });
});

// test/integration.test.js
import { MCPClient } from '@modelcontextprotocol/client';

describe('MCP Integration', () => {
  let client;

  before(async () => {
    client = new MCPClient();
    await client.connect('http://localhost:3000');
  });

  it('should connect to server', async () => {
    const info = await client.getServerInfo();
    expect(info.name).to.equal('test-server');
  });

  it('should handle tool calls', async () => {
    const result = await client.callTool('filesystem', 'list', {
      path: '/tmp'
    });
    expect(result).to.have.property('files');
  });
});

// Enable debug logging
import debug from 'debug';
const log = debug('mcp:server');

class MCPServer {
  async handleRequest(request) {
    log('Received request:', request);
    
    try {
      const result = await this.processRequest(request);
      log('Request processed successfully:', result);
      return result;
    } catch (error) {
      log('Request failed:', error);
      throw error;
    }
  }
}

// Validate MCP protocol compliance
import { validateMCPMessage } from '@modelcontextprotocol/validator';

function validateRequest(request) {
  const validation = validateMCPMessage(request);
  if (!validation.valid) {
    throw new Error(`Invalid MCP message: ${validation.errors.join(', ')}`);
  }
}

// Load testing with artillery
// artillery.yml
config:
  target: 'http://localhost:3000'
  phases:
    - duration: 60
      arrivalRate: 10

scenarios:
  - name: "Tool calls"
    requests:
      - post:
          url: "/mcp/call"
          json:
            tool: "filesystem"
            action: "list"
            params: { path: "/" }

# Check server status
curl -f http://localhost:3000/health

# Check process
ps aux | grep mcp

# Check logs
tail -f /var/log/mcp/server.log

// Monitor memory usage
setInterval(() => {
  const usage = process.memoryUsage();
  console.log('Memory usage:', {
    rss: Math.round(usage.rss / 1024 / 1024) + 'MB',
    heapUsed: Math.round(usage.heapUsed / 1024 / 1024) + 'MB',
    heapTotal: Math.round(usage.heapTotal / 1024 / 1024) + 'MB'
  });
}, 10000);

# .github/workflows/test.yml
name: Test MCP Server

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '18'
      
      - run: npm install
      - run: npm run build
      - run: npm test
      
      - name: Start MCP server
        run: npm start &
        
      - name: Wait for server
        run: sleep 5
        
      - name: Test with MCP Inspector
        run: mcp-inspector --test --server "http://localhost:3000"