Claude MCP Server Development: Build Custom AI Integrations

# TypeScript Setup
npm init -y
npm install @modelcontextprotocol/sdk@1.18.1
npm install zod typescript tsx --save-dev

# Python Setup  
pip install mcp fastmcp pydantic --break-system-packages
pip install python-dotenv pytest --break-system-packages

// src/index.ts - TypeScript Server
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({
  name: "custom-integration-server",
  version: "1.0.0",
  capabilities: {
    tools: true,
    resources: true,
    prompts: true
  }
});

// Python equivalent: src/server.py
from mcp.server.fastmcp import FastMCP
from pydantic import Field

mcp = FastMCP("Custom Integration Server")

// TypeScript Tool Implementation
server.tool("database_query",
  {
    description: "Execute parameterized database queries safely",
    inputSchema: {
      query: z.string().min(1).max(1000),
      params: z.array(z.any()).optional()
    }
  },
  async ({ query, params }) => {
    // Validate and sanitize inputs
    const sanitized = parameterize(query, params);
    
    // Execute with connection pooling
    const result = await pool.query(sanitized);
    
    return {
      content: [{
        type: "text",
        text: JSON.stringify(result.rows, null, 2)
      }]
    };
  }
);

// Redis State Management
import Redis from 'ioredis';

const redis = new Redis({
  host: process.env.REDIS_HOST,
  port: 6379,
  maxRetriesPerRequest: 3
});

// Session middleware
server.use(async (context, next) => {
  const sessionId = context.headers['x-session-id'];
  context.state = await redis.get(sessionId) || {};
  
  await next();
  
  await redis.setex(sessionId, 3600, 
    JSON.stringify(context.state));
});

// OAuth 2.1 Implementation with PKCE
import { generateCodeChallenge } from './auth';

server.tool("authenticate",
  {
    description: "Initiate OAuth flow with PKCE",
    inputSchema: { 
      client_id: z.string(),
      scope: z.string() 
    }
  },
  async ({ client_id, scope }) => {
    const verifier = generateRandomString(128);
    const challenge = await generateCodeChallenge(verifier);
    
    // Store verifier securely
    await storeVerifier(verifier);
    
    const authUrl = buildAuthUrl({
      client_id,
      challenge,
      challenge_method: 'S256',
      scope
    });
    
    return {
      content: [{
        type: "text",
        text: `Authenticate at: ${authUrl}`
      }]
    };
  }
);

// ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "custom-integration": {
      "command": "node",
      "args": ["/absolute/path/to/dist/index.js"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}",
        "REDIS_HOST": "localhost",
        "API_KEY": "${API_KEY}"
      }
    }
  }
}

# Launch MCP Inspector
npx @modelcontextprotocol/inspector node dist/index.js

# Test specific tools
curl -X POST http://localhost:5173/test \
  -H "Content-Type: application/json" \
  -d '{"tool": "database_query", "params": {...}}'

# Monitor real-time messages
# Inspector UI shows all JSON-RPC communication