Kilo Code: Advanced MCP Integration

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   GitHub    │────▶│  Custom     │────▶│   AI        │
│   API       │     │  Integration│     │   Assistant │
└─────────────┘     └─────────────┘     └─────────────┘

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   Slack     │────▶│  Custom     │────▶│   AI        │
│   API       │     │  Integration│     │   Assistant │
└─────────────┘     └─────────────┘     └─────────────┘

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   Database  │────▶│  Custom     │────▶│   AI        │
│             │     │  Integration│     │   Assistant │
└─────────────┘     └─────────────┘     └─────────────┘

Result: Fragile, hard-to-maintain integrations

┌─────────────┐
│   GitHub    │
│   MCP       │
│   Server    │
└──────┬──────┘
       │
┌──────┴──────┐     ┌─────────────┐
│   MCP       │────▶│   AI        │
│   Host      │     │   Assistant │
│   (Kilo)    │     │             │
└──────┬──────┘     └─────────────┘
       │
┌──────┴──────┐
│   Slack     │
│   MCP       │
│   Server    │
└─────────────┘

Result: Standard, swappable integrations

# GitHub MCP Server
npm install -g @modelcontextprotocol/server-github

# PostgreSQL MCP Server
npm install -g @modelcontextprotocol/server-postgres

# Filesystem MCP Server
npm install -g @modelcontextprotocol/server-filesystem

# Slack MCP Server
npm install -g @modelcontextprotocol/server-slack

# PostgreSQL MCP Server via Docker
docker run -d \
  -p 3000:3000 \
  -e DATABASE_URL="postgresql://user:pass@localhost:5432/mydb" \
  mcp/postgres-server

# Redis MCP Server via Docker
docker run -d \
  -p 3001:3001 \
  -e REDIS_URL="redis://localhost:6379" \
  mcp/redis-server

# Run GitHub MCP without installing
npx @modelcontextprotocol/server-github

# Run in Kilo Code config
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"]
    }
  }
}

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      },
      "enabled": true
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem"],
      "args": ["/Users/paladm/projects"],
      "enabled": true
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      },
      "enabled": true
    },
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "${SLACK_BOT_TOKEN}"
      },
      "enabled": false
    }
  }
}

# .kilocode/.env
GITHUB_TOKEN=ghp_xxxxxxxxxxxxxxxxxxxx
DATABASE_URL=postgresql://user:pass@localhost:5432/mydb
SLACK_BOT_TOKEN=xoxb-xxxxxxxxxxxx-xxxxxxxxxxxx-xxxxxxxxxxxx

# List configured servers
kilo-code mcp list

# Output:
Configured MCP Servers:
  ✓ github (connected)
  ✓ filesystem (connected)
  ✓ postgres (connected)
  ✗ slack (disabled)

# Test server connection
kilo-code mcp test github

# Output:
Testing GitHub MCP Server...
✓ Connection successful
✓ Available tools: 15
✓ Available resources: 8

User: "Create a GitHub issue for the login bug we found"

Kilo Code (via MCP):
I'll create a GitHub issue with the details we discussed.

Using GitHub MCP Server:
- Repository: myorg/myapp
- Title: Login fails with valid credentials
- Labels: bug, priority-high
- Assignee: @current-user

Creating issue...
✓ Issue #142 created: https://github.com/myorg/myapp/issues/142

Would you like me to:
1. Create a branch for this issue?
2. Add more details to the issue?
3. Notify the team on Slack?

User: "Copy the config from our templates repo"

Kilo Code (via MCP):
I'll use the Filesystem MCP to access the templates repo.

Reading from: /Users/paladm/templates/webapp/config.json
Writing to: /Users/paladm/projects/myapp/config.json

✓ File copied successfully

Contents:
{
  "app": {
    "name": "MyApp",
    "version": "1.0.0"
  },
  "database": {
    "host": "localhost",
    "port": 5432
  }
}

User: "Check how many users signed up this week"

Kilo Code (via MCP):
I'll query the PostgreSQL database.

Executing query:
```sql
SELECT COUNT(*) as new_users, 
       DATE(created_at) as signup_date
FROM users
WHERE created_at >= NOW() - INTERVAL '7 days'
GROUP BY DATE(created_at)
ORDER BY signup_date;
```

Results:
| signup_date | new_users |
|-------------|-----------|
| 2026-03-25 | 45 |
| 2026-03-26 | 52 |
| 2026-03-27 | 38 |
| 2026-03-28 | 67 |
| 2026-03-29 | 71 |
| 2026-03-30 | 89 |
| 2026-03-31 | 43 |

Total: 405 new users this week

// my-custom-server.ts
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from '@modelcontextprotocol/sdk/types.js';

// Create server instance
const server = new Server(
  {
    name: 'my-custom-server',
    version: '1.0.0',
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

// Define available tools
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: 'get_user_data',
        description: 'Get user data from internal API',
        inputSchema: {
          type: 'object',
          properties: {
            userId: {
              type: 'string',
              description: 'The user ID to fetch',
            },
          },
          required: ['userId'],
        },
      },
      {
        name: 'create_report',
        description: 'Generate a custom report',
        inputSchema: {
          type: 'object',
          properties: {
            reportType: {
              type: 'string',
              enum: ['daily', 'weekly', 'monthly'],
            },
            startDate: {
              type: 'string',
              description: 'Start date (ISO format)',
            },
            endDate: {
              type: 'string',
              description: 'End date (ISO format)',
            },
          },
          required: ['reportType'],
        },
      },
    ],
  };
});

// Handle tool calls
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  if (name === 'get_user_data') {
    const { userId } = args as { userId: string };
    
    // Fetch from internal API
    const response = await fetch(`https://api.internal/users/${userId}`);
    const data = await response.json();
    
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(data, null, 2),
        },
      ],
    };
  }

  if (name === 'create_report') {
    const { reportType, startDate, endDate } = args as {
      reportType: string;
      startDate?: string;
      endDate?: string;
    };
    
    // Generate report logic here
    const report = await generateReport(reportType, startDate, endDate);
    
    return {
      content: [
        {
          type: 'text',
          text: report,
        },
      ],
    };
  }

  throw new Error(`Unknown tool: ${name}`);
});

// Start server
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error('MCP Server running on stdio');
}

main().catch((error) => {
  console.error('Server error:', error);
  process.exit(1);
});

{
  "name": "@mycompany/mcp-custom-server",
  "version": "1.0.0",
  "type": "module",
  "bin": {
    "mcp-custom-server": "./dist/index.js"
  },
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.0.0"
  },
  "devDependencies": {
    "typescript": "^5.0.0",
    "@types/node": "^20.0.0"
  }
}

{
  "mcpServers": {
    "custom": {
      "command": "node",
      "args": ["/path/to/my-custom-server/dist/index.js"],
      "env": {
        "API_KEY": "${INTERNAL_API_KEY}"
      }
    }
  }
}

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

User: "Show me the open issues in our repo"

Kilo Code:
Reading from github://myorg/myapp/issues?state=open

Found 12 open issues:

1. #142 - Login fails with valid credentials (High)
2. #141 - Mobile menu not responsive (Medium)
3. #140 - Add dark mode toggle (Low)
...

User: "What tables do we have?"

Kilo Code:
Reading from postgres://localhost/mydb/tables

Available tables:
- users (15,234 rows)
- products (892 rows)
- orders (45,678 rows)
- reviews (23,456 rows)

// prompts-server.ts
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import {
  ListPromptsRequestSchema,
  GetPromptRequestSchema,
} from '@modelcontextprotocol/sdk/types.js';

const server = new Server({
  name: 'prompts-server',
  version: '1.0.0',
}, {
  capabilities: {
    prompts: {},
  },
});

server.setRequestHandler(ListPromptsRequestSchema, async () => {
  return {
    prompts: [
      {
        name: 'code_review',
        description: 'Generate a code review for a pull request',
        arguments: [
          {
            name: 'pr_url',
            description: 'URL of the pull request',
            required: true,
          },
        ],
      },
      {
        name: 'bug_report',
        description: 'Create a structured bug report',
        arguments: [
          {
            name: 'description',
            description: 'Description of the bug',
            required: true,
          },
          {
            name: 'steps',
            description: 'Steps to reproduce',
            required: true,
          },
        ],
      },
    ],
  };
});

server.setRequestHandler(GetPromptRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  if (name === 'code_review') {
    return {
      messages: [
        {
          role: 'user',
          content: {
            type: 'text',
            text: `Please review this pull request: ${args.pr_url}

Focus on:
1. Code quality and best practices
2. Security vulnerabilities
3. Performance implications
4. Test coverage
5. Documentation

Provide specific suggestions with code examples.`,
          },
        },
      ],
    };
  }

  if (name === 'bug_report') {
    return {
      messages: [
        {
          role: 'user',
          content: {
            type: 'text',
            text: `Create a structured bug report:

Description: ${args.description}
Steps to Reproduce: ${args.steps}

Format the report with:
- Summary
- Environment
- Steps to Reproduce
- Expected Behavior
- Actual Behavior
- Screenshots (if applicable)
- Severity Assessment`,
          },
        },
      ],
    };
  }
});

User: /prompt code_review https://github.com/myorg/myapp/pull/50

Kilo Code:
Using prompt: code_review

## Code Review for PR #50

### Summary
This PR adds user authentication with JWT tokens. Overall good implementation with a few concerns.

### Security Issues

#### 1. Hardcoded Secret (Critical)
Line 23: JWT secret is hardcoded
```typescript
// Bad
const secret = 'my-secret-key';
```
Fix: Use environment variable

### Code Quality

#### 2. Missing Error Handling
The login function doesn't handle database errors...

[Full review continues]

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/allowed/path"],
      "readonly": true
    }
  }
}

# Good: Secrets in environment
export GITHUB_TOKEN=ghp_xxxx
kilo-code start

# Bad: Secrets in config file
{
  "github": {
    "token": "ghp_xxxx"  // Don't do this!
  }
}

{
  "mcpServers": {
    "github": { "enabled": true },
    "postgres": { "enabled": true },
    "slack": { "enabled": false },  // Disable unused
    "shell": { "enabled": false }   // Dangerous, disable
  }
}

# Log MCP tool calls
kilo-code mcp logs

# Review recent activity
kilo-code mcp audit --last 24h

# Check server status
kilo-code mcp status github

# Test connection
kilo-code mcp test github

# View logs
kilo-code mcp logs github

# List available tools
kilo-code mcp tools github

# Refresh server
kilo-code mcp restart github

# Check filesystem permissions
ls -la /path/to/directory

# Update MCP config with correct path
{
  "filesystem": {
    "args": ["/correct/path"]
  }
}