// Example resource definition
{
  uri: "file:///home/user/projects/data.json",
  name: "Project Data",
  description: "Current project configuration and data",
  mimeType: "application/json"
}

// Example tool definition
{
  name: "calculate_metrics",
  description: "Calculate statistics for a dataset",
  inputSchema: {
    type: "object",
    properties: {
      dataset: { type: "string" },
      metrics: { type: "array", items: { type: "string" } }
    }
  }
}

// Example prompt definition
{
  name: "analyze_code",
  description: "Analyze code for improvements",
  arguments: [
    {
      name: "language",
      description: "Programming language",
      required: true
    }
  ]
}

#!/usr/bin/env node
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
  CallToolRequestSchema,
  ErrorCode,
  ListResourcesRequestSchema,
  ListToolsRequestSchema,
  McpError,
  ReadResourceRequestSchema,
} from '@modelcontextprotocol/sdk/types.js';
import fs from 'fs/promises';
import path from 'path';

// Define the base directory for file operations
const BASE_DIR = process.env.MCP_BASE_DIR || process.cwd();

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

// List available resources (files in the directory)
server.setRequestHandler(ListResourcesRequestSchema, async () => {
  try {
    const files = await fs.readdir(BASE_DIR);
    const resources = await Promise.all(
      files.map(async (file) => {
        const filePath = path.join(BASE_DIR, file);
        const stats = await fs.stat(filePath);
        
        if (stats.isFile()) {
          return {
            uri: `file://${filePath}`,
            name: file,
            description: `File: ${file} (${stats.size} bytes)`,
            mimeType: getMimeType(file),
          };
        }
        return null;
      })
    );

    return {
      resources: resources.filter(r => r !== null),
    };
  } catch (error) {
    throw new McpError(
      ErrorCode.InternalError,
      `Failed to list resources: ${error}`
    );
  }
});

// Read resource content
server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
  const { uri } = request.params;
  
  if (!uri.startsWith('file://')) {
    throw new McpError(
      ErrorCode.InvalidRequest,
      'Only file:// URIs are supported'
    );
  }

  const filePath = uri.slice(7); // Remove 'file://'
  
  // Security check: ensure file is within BASE_DIR
  const resolvedPath = path.resolve(filePath);
  const resolvedBase = path.resolve(BASE_DIR);
  
  if (!resolvedPath.startsWith(resolvedBase)) {
    throw new McpError(
      ErrorCode.InvalidRequest,
      'Access denied: file outside base directory'
    );
  }

  try {
    const content = await fs.readFile(filePath, 'utf-8');
    return {
      contents: [
        {
          uri,
          mimeType: getMimeType(filePath),
          text: content,
        },
      ],
    };
  } catch (error) {
    throw new McpError(
      ErrorCode.InternalError,
      `Failed to read file: ${error}`
    );
  }
});

// List available tools
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: 'create_file',
        description: 'Create a new file with specified content',
        inputSchema: {
          type: 'object',
          properties: {
            filename: {
              type: 'string',
              description: 'Name of the file to create',
            },
            content: {
              type: 'string',
              description: 'Content to write to the file',
            },
          },
          required: ['filename', 'content'],
        },
      },
      {
        name: 'search_files',
        description: 'Search for files containing specific text',
        inputSchema: {
          type: 'object',
          properties: {
            query: {
              type: 'string',
              description: 'Text to search for',
            },
            extension: {
              type: 'string',
              description: 'File extension to filter (optional)',
            },
          },
          required: ['query'],
        },
      },
    ],
  };
});

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

  switch (name) {
    case 'create_file': {
      const { filename, content } = args as { filename: string; content: string };
      const filePath = path.join(BASE_DIR, filename);
      
      // Security check
      const resolvedPath = path.resolve(filePath);
      const resolvedBase = path.resolve(BASE_DIR);
      
      if (!resolvedPath.startsWith(resolvedBase)) {
        throw new McpError(
          ErrorCode.InvalidRequest,
          'Cannot create file outside base directory'
        );
      }

      try {
        await fs.writeFile(filePath, content, 'utf-8');
        return {
          content: [
            {
              type: 'text',
              text: `Successfully created file: ${filename}`,
            },
          ],
        };
      } catch (error) {
        throw new McpError(
          ErrorCode.InternalError,
          `Failed to create file: ${error}`
        );
      }
    }

    case 'search_files': {
      const { query, extension } = args as { query: string; extension?: string };
      
      try {
        const results = await searchFiles(BASE_DIR, query, extension);
        return {
          content: [
            {
              type: 'text',
              text: results.length > 0
                ? `Found ${results.length} matches:\n${results.join('\n')}`
                : 'No matches found',
            },
          ],
        };
      } catch (error) {
        throw new McpError(
          ErrorCode.InternalError,
          `Search failed: ${error}`
        );
      }
    }

    default:
      throw new McpError(
        ErrorCode.MethodNotFound,
        `Unknown tool: ${name}`
      );
  }
});

// Helper functions
function getMimeType(filename: string): string {
  const ext = path.extname(filename).toLowerCase();
  const mimeTypes: { [key: string]: string } = {
    '.txt': 'text/plain',
    '.json': 'application/json',
    '.js': 'application/javascript',
    '.ts': 'application/typescript',
    '.py': 'text/x-python',
    '.md': 'text/markdown',
    '.html': 'text/html',
    '.css': 'text/css',
    '.csv': 'text/csv',
    '.xml': 'application/xml',
    '.yaml': 'application/yaml',
    '.yml': 'application/yaml',
  };
  return mimeTypes[ext] || 'text/plain';
}

async function searchFiles(
  dir: string,
  query: string,
  extension?: string
): Promise<string[]> {
  const results: string[] = [];
  const files = await fs.readdir(dir);

  for (const file of files) {
    const filePath = path.join(dir, file);
    const stats = await fs.stat(filePath);

    if (stats.isFile()) {
      if (extension && !file.endsWith(extension)) {
        continue;
      }

      try {
        const content = await fs.readFile(filePath, 'utf-8');
        if (content.toLowerCase().includes(query.toLowerCase())) {
          results.push(`${file}: ${getMatchContext(content, query)}`);
        }
      } catch (error) {
        // Skip files that can't be read
      }
    }
  }

  return results;
}

function getMatchContext(content: string, query: string): string {
  const index = content.toLowerCase().indexOf(query.toLowerCase());
  if (index === -1) return '';
  
  const start = Math.max(0, index - 30);
  const end = Math.min(content.length, index + query.length + 30);
  
  return '...' + content.slice(start, end).replace(/\n/g, ' ') + '...';
}

// Start the 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);
});

#!/usr/bin/env node
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
  CallToolRequestSchema,
  ErrorCode,
  ListToolsRequestSchema,
  McpError,
} from '@modelcontextprotocol/sdk/types.js';
import axios from 'axios';

// You need to get an API key from OpenWeatherMap
const API_KEY = process.env.OPENWEATHER_API_KEY || 'your_api_key_here';
const BASE_URL = 'https://api.openweathermap.org/data/2.5';

interface WeatherData {
  temperature: number;
  feels_like: number;
  humidity: number;
  description: string;
  wind_speed: number;
  city: string;
  country: string;
}

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

// List available tools
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: 'get_weather',
        description: 'Get current weather for a city',
        inputSchema: {
          type: 'object',
          properties: {
            city: {
              type: 'string',
              description: 'City name',
            },
            country: {
              type: 'string',
              description: 'Country code (e.g., US, UK)',
              default: '',
            },
            units: {
              type: 'string',
              enum: ['metric', 'imperial'],
              description: 'Temperature units',
              default: 'metric',
            },
          },
          required: ['city'],
        },
      },
      {
        name: 'get_forecast',
        description: 'Get 5-day weather forecast',
        inputSchema: {
          type: 'object',
          properties: {
            city: {
              type: 'string',
              description: 'City name',
            },
            country: {
              type: 'string',
              description: 'Country code (e.g., US, UK)',
              default: '',
            },
            units: {
              type: 'string',
              enum: ['metric', 'imperial'],
              description: 'Temperature units',
              default: 'metric',
            },
          },
          required: ['city'],
        },
      },
      {
        name: 'compare_weather',
        description: 'Compare weather between multiple cities',
        inputSchema: {
          type: 'object',
          properties: {
            cities: {
              type: 'array',
              items: { type: 'string' },
              description: 'List of cities to compare',
              minItems: 2,
              maxItems: 5,
            },
            units: {
              type: 'string',
              enum: ['metric', 'imperial'],
              description: 'Temperature units',
              default: 'metric',
            },
          },
          required: ['cities'],
        },
      },
    ],
  };
});

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

  try {
    switch (name) {
      case 'get_weather': {
        const { city, country = '', units = 'metric' } = args as {
          city: string;
          country?: string;
          units?: string;
        };

        const weather = await getCurrentWeather(city, country, units);
        
        return {
          content: [
            {
              type: 'text',
              text: formatWeatherReport(weather, units),
            },
          ],
        };
      }

      case 'get_forecast': {
        const { city, country = '', units = 'metric' } = args as {
          city: string;
          country?: string;
          units?: string;
        };

        const forecast = await getForecast(city, country, units);
        
        return {
          content: [
            {
              type: 'text',
              text: formatForecastReport(forecast, units),
            },
          ],
        };
      }

      case 'compare_weather': {
        const { cities, units = 'metric' } = args as {
          cities: string[];
          units?: string;
        };

        const weatherData = await Promise.all(
          cities.map(city => getCurrentWeather(city, '', units))
        );

        return {
          content: [
            {
              type: 'text',
              text: formatComparisonReport(weatherData, units),
            },
          ],
        };
      }

      default:
        throw new McpError(
          ErrorCode.MethodNotFound,
          `Unknown tool: ${name}`
        );
    }
  } catch (error: any) {
    if (error instanceof McpError) {
      throw error;
    }
    
    throw new McpError(
      ErrorCode.InternalError,
      `Weather API error: ${error.message}`
    );
  }
});

// Weather API functions
async function getCurrentWeather(
  city: string,
  country: string,
  units: string
): Promise<WeatherData> {
  const location = country ? `${city},${country}` : city;
  
  try {
    const response = await axios.get(`${BASE_URL}/weather`, {
      params: {
        q: location,
        appid: API_KEY,
        units: units,
      },
    });

    const data = response.data;
    
    return {
      temperature: Math.round(data.main.temp),
      feels_like: Math.round(data.main.feels_like),
      humidity: data.main.humidity,
      description: data.weather[0].description,
      wind_speed: data.wind.speed,
      city: data.name,
      country: data.sys.country,
    };
  } catch (error: any) {
    if (error.response?.status === 404) {
      throw new Error(`City not found: ${location}`);
    }
    throw error;
  }
}

async function getForecast(
  city: string,
  country: string,
  units: string
): Promise<any[]> {
  const location = country ? `${city},${country}` : city;
  
  try {
    const response = await axios.get(`${BASE_URL}/forecast`, {
      params: {
        q: location,
        appid: API_KEY,
        units: units,
        cnt: 40, // 5 days * 8 (3-hour intervals)
      },
    });

    // Group forecasts by day
    const dailyForecasts = new Map<string, any[]>();
    
    response.data.list.forEach((item: any) => {
      const date = new Date(item.dt * 1000).toLocaleDateString();
      if (!dailyForecasts.has(date)) {
        dailyForecasts.set(date, []);
      }
      dailyForecasts.get(date)!.push(item);
    });

    // Calculate daily summaries
    const forecasts = Array.from(dailyForecasts.entries()).map(([date, items]) => {
      const temps = items.map(item => item.main.temp);
      const descriptions = items.map(item => item.weather[0].description);
      
      return {
        date,
        min_temp: Math.round(Math.min(...temps)),
        max_temp: Math.round(Math.max(...temps)),
        description: getMostCommonElement(descriptions),
        city: response.data.city.name,
        country: response.data.city.country,
      };
    });

    return forecasts.slice(0, 5); // Return 5 days
  } catch (error: any) {
    if (error.response?.status === 404) {
      throw new Error(`City not found: ${location}`);
    }
    throw error;
  }
}

// Helper functions
function formatWeatherReport(weather: WeatherData, units: string): string {
  const tempUnit = units === 'metric' ? '°C' : '°F';
  const speedUnit = units === 'metric' ? 'm/s' : 'mph';
  
  return `
🌤️ **Current Weather in ${weather.city}, ${weather.country}**

🌡️ Temperature: ${weather.temperature}${tempUnit} (feels like ${weather.feels_like}${tempUnit})
☁️ Conditions: ${weather.description}
💧 Humidity: ${weather.humidity}%
💨 Wind Speed: ${weather.wind_speed} ${speedUnit}
  `.trim();
}

function formatForecastReport(forecasts: any[], units: string): string {
  const tempUnit = units === 'metric' ? '°C' : '°F';
  
  let report = `📅 **5-Day Forecast for ${forecasts[0].city}, ${forecasts[0].country}**\n\n`;
  
  forecasts.forEach(forecast => {
    report += `**${forecast.date}**\n`;
    report += `  🌡️ ${forecast.min_temp}-${forecast.max_temp}${tempUnit}\n`;
    report += `  ☁️ ${forecast.description}\n\n`;
  });
  
  return report.trim();
}

function formatComparisonReport(weatherData: WeatherData[], units: string): string {
  const tempUnit = units === 'metric' ? '°C' : '°F';
  
  let report = '🌍 **Weather Comparison**\n\n';
  
  // Sort by temperature
  weatherData.sort((a, b) => b.temperature - a.temperature);
  
  weatherData.forEach((weather, index) => {
    const emoji = index === 0 ? '🥇' : index === 1 ? '🥈' : index === 2 ? '🥉' : '📍';
    
    report += `${emoji} **${weather.city}, ${weather.country}**\n`;
    report += `   🌡️ ${weather.temperature}${tempUnit} - ${weather.description}\n`;
    report += `   💧 Humidity: ${weather.humidity}%\n\n`;
  });
  
  return report.trim();
}

function getMostCommonElement(arr: string[]): string {
  const counts = new Map<string, number>();
  
  arr.forEach(element => {
    counts.set(element, (counts.get(element) || 0) + 1);
  });
  
  let maxCount = 0;
  let mostCommon = arr[0];
  
  counts.forEach((count, element) => {
    if (count > maxCount) {
      maxCount = count;
      mostCommon = element;
    }
  });
  
  return mostCommon;
}

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

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

// Example: Exposing configuration files
const configResource = {
  uri: "config://app/settings",
  name: "Application Settings",
  description: "Current app configuration",
  mimeType: "application/json"
};

// Example: Database views
const dbResource = {
  uri: "db://analytics/user_metrics",
  name: "User Analytics",
  description: "Read-only view of user metrics",
  mimeType: "application/json"
};

// Example: API endpoints
const apiResource = {
  uri: "api://github/repos",
  name: "GitHub Repositories",
  description: "List of user's GitHub repos",
  mimeType: "application/json"
};

// Example: System administration tool
const systemTool = {
  name: "restart_service",
  description: "Restart a system service",
  inputSchema: {
    type: "object",
    properties: {
      service_name: {
        type: "string",
        enum: ["web", "database", "cache"],
        description: "Service to restart"
      },
      force: {
        type: "boolean",
        default: false,
        description: "Force restart without graceful shutdown"
      }
    },
    required: ["service_name"]
  }
};

// Example: Data processing tool
const dataTool = {
  name: "transform_dataset",
  description: "Apply transformations to a dataset",
  inputSchema: {
    type: "object",
    properties: {
      dataset_id: { type: "string" },
      transformations: {
        type: "array",
        items: {
          type: "object",
          properties: {
            type: { type: "string", enum: ["filter", "map", "aggregate"] },
            config: { type: "object" }
          }
        }
      }
    },
    required: ["dataset_id", "transformations"]
  }
};

// Example: Code review prompt
const codeReviewPrompt = {
  name: "code_review",
  description: "Comprehensive code review template",
  arguments: [
    {
      name: "language",
      description: "Programming language",
      required: true
    },
    {
      name: "focus_areas",
      description: "Specific areas to focus on",
      required: false
    }
  ],
  template: `Please review the following {language} code focusing on:
- Code quality and best practices
- Performance implications
- Security vulnerabilities
- Maintainability
{focus_areas ? "Additional focus: " + focus_areas : ""}`
};

// Example: Data analysis prompt
const analysisPrompt = {
  name: "data_analysis",
  description: "Statistical data analysis template",
  arguments: [
    {
      name: "dataset",
      description: "Dataset identifier",
      required: true
    },
    {
      name: "hypothesis",
      description: "Hypothesis to test",
      required: false
    }
  ]
};

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
import { spawn } from 'child_process';

async function createMCPClient() {
  // Spawn the server process
  const serverProcess = spawn('node', ['path/to/server.js'], {
    stdio: ['pipe', 'pipe', 'process.stderr'],
  });

  // Create transport
  const transport = new StdioClientTransport({
    reader: serverProcess.stdout,
    writer: serverProcess.stdin,
  });

  // Create client
  const client = new Client({
    name: 'my-mcp-client',
    version: '1.0.0',
  }, {
    capabilities: {}
  });

  // Connect
  await client.connect(transport);

  // List available resources
  const resources = await client.listResources();
  console.log('Available resources:', resources);

  // List available tools
  const tools = await client.listTools();
  console.log('Available tools:', tools);

  // Call a tool
  const result = await client.callTool({
    name: 'create_file',
    arguments: {
      filename: 'test.txt',
      content: 'Hello from MCP!'
    }
  });
  console.log('Tool result:', result);

  return client;
}

// Usage
const client = await createMCPClient();

// git-server.ts
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { exec } from 'child_process';
import { promisify } from 'util';

const execAsync = promisify(exec);

class GitServer {
  private server: Server;
  private repoPath: string;

  constructor(repoPath: string) {
    this.repoPath = repoPath;
    this.server = new Server({
      name: 'git-manager',
      version: '1.0.0',
    });
    
    this.setupHandlers();
  }

  private setupHandlers() {
    // List tools
    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
      return {
        tools: [
          {
            name: 'git_status',
            description: 'Get current git status',
            inputSchema: { type: 'object', properties: {} }
          },
          {
            name: 'git_log',
            description: 'Get commit history',
            inputSchema: {
              type: 'object',
              properties: {
                limit: { type: 'number', default: 10 },
                oneline: { type: 'boolean', default: false }
              }
            }
          },
          {
            name: 'git_diff',
            description: 'Show changes in working directory',
            inputSchema: {
              type: 'object',
              properties: {
                staged: { type: 'boolean', default: false }
              }
            }
          },
          {
            name: 'git_branch',
            description: 'List or create branches',
            inputSchema: {
              type: 'object',
              properties: {
                create: { type: 'string' },
                delete: { type: 'string' },
                list: { type: 'boolean', default: true }
              }
            }
          }
        ]
      };
    });

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

      try {
        let result: string;

        switch (name) {
          case 'git_status':
            result = await this.gitCommand('status --porcelain');
            break;

          case 'git_log':
            const limit = args.limit || 10;
            const format = args.oneline ? '--oneline' : '';
            result = await this.gitCommand(`log -${limit} ${format}`);
            break;

          case 'git_diff':
            const staged = args.staged ? '--cached' : '';
            result = await this.gitCommand(`diff ${staged}`);
            break;

          case 'git_branch':
            if (args.create) {
              result = await this.gitCommand(`checkout -b ${args.create}`);
            } else if (args.delete) {
              result = await this.gitCommand(`branch -d ${args.delete}`);
            } else {
              result = await this.gitCommand('branch -a');
            }
            break;

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

        return {
          content: [{
            type: 'text',
            text: result || 'Command completed successfully'
          }]
        };
      } catch (error: any) {
        return {
          content: [{
            type: 'text',
            text: `Git error: ${error.message}`
          }]
        };
      }
    });
  }

  private async gitCommand(command: string): Promise<string> {
    const { stdout, stderr } = await execAsync(
      `git ${command}`,
      { cwd: this.repoPath }
    );
    
    if (stderr && !stderr.includes('warning')) {
      throw new Error(stderr);
    }
    
    return stdout;
  }
}

// jupyter-server.ts
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import axios from 'axios';
import WebSocket from 'ws';

interface JupyterConfig {
  baseUrl: string;
  token: string;
}

class JupyterServer {
  private server: Server;
  private config: JupyterConfig;
  private kernels: Map<string, any> = new Map();

  constructor(config: JupyterConfig) {
    this.config = config;
    this.server = new Server({
      name: 'jupyter-integration',
      version: '1.0.0',
    });
    
    this.setupHandlers();
  }

  private setupHandlers() {
    // List resources (notebooks)
    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
      const notebooks = await this.listNotebooks();
      
      return {
        resources: notebooks.map(nb => ({
          uri: `notebook://${nb.path}`,
          name: nb.name,
          description: `Jupyter notebook: ${nb.name}`,
          mimeType: 'application/x-ipynb+json'
        }))
      };
    });

    // Read notebook content
    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
      const { uri } = request.params;
      const path = uri.replace('notebook://', '');
      
      const content = await this.getNotebook(path);
      
      return {
        contents: [{
          uri,
          mimeType: 'application/x-ipynb+json',
          text: JSON.stringify(content, null, 2)
        }]
      };
    });

    // List tools
    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
      return {
        tools: [
          {
            name: 'execute_code',
            description: 'Execute code in a Jupyter kernel',
            inputSchema: {
              type: 'object',
              properties: {
                code: {
                  type: 'string',
                  description: 'Code to execute'
                },
                kernel_name: {
                  type: 'string',
                  description: 'Kernel name (e.g., python3)',
                  default: 'python3'
                }
              },
              required: ['code']
            }
          },
          {
            name: 'create_notebook',
            description: 'Create a new Jupyter notebook',
            inputSchema: {
              type: 'object',
              properties: {
                name: {
                  type: 'string',
                  description: 'Notebook name'
                },
                content: {
                  type: 'object',
                  description: 'Initial notebook content'
                }
              },
              required: ['name']
            }
          },
          {
            name: 'list_kernels',
            description: 'List available Jupyter kernels',
            inputSchema: {
              type: 'object',
              properties: {}
            }
          }
        ]
      };
    });

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

      switch (name) {
        case 'execute_code':
          return await this.executeCode(args.code, args.kernel_name);
        
        case 'create_notebook':
          return await this.createNotebook(args.name, args.content);
        
        case 'list_kernels':
          return await this.listKernels();
        
        default:
          throw new Error(`Unknown tool: ${name}`);
      }
    });
  }

  private async executeCode(code: string, kernelName: string = 'python3') {
    // Start or get kernel
    let kernel = this.kernels.get(kernelName);
    if (!kernel) {
      kernel = await this.startKernel(kernelName);
      this.kernels.set(kernelName, kernel);
    }

    // Execute code
    const result = await this.executeInKernel(kernel, code);
    
    return {
      content: [{
        type: 'text',
        text: this.formatExecutionResult(result)
      }]
    };
  }

  private formatExecutionResult(result: any): string {
    let output = '';
    
    // Add stdout
    if (result.stdout) {
      output += `Output:\n${result.stdout}\n`;
    }
    
    // Add result data
    if (result.data) {
      if (result.data['text/plain']) {
        output += `Result:\n${result.data['text/plain']}\n`;
      }
    }
    
    // Add errors
    if (result.error) {
      output += `Error:\n${result.error.ename}: ${result.error.evalue}\n`;
    }
    
    return output || 'Code executed successfully (no output)';
  }

  // ... Additional implementation details
}