MCP Server¶

import { createMcpServer } from '@github-to-mcp/mcp-server';

const server = createMcpServer({
  name: 'my-mcp-server',
  version: '1.0.0',
  tools: [
    {
      name: 'hello_world',
      description: 'Say hello',
      inputSchema: {
        type: 'object',
        properties: {
          name: { type: 'string' }
        }
      },
      execute: async ({ name }) => {
        return { greeting: `Hello, ${name}!` };
      }
    }
  ]
});

await server.start();

import { createMcpServer } from '@github-to-mcp/mcp-server';
import { generateFromGithub } from '@nirholas/github-to-mcp';

const result = await generateFromGithub('https://github.com/owner/repo');

const server = createMcpServer({
  name: 'repo-mcp',
  version: '1.0.0',
  tools: result.tools.map(tool => ({
    ...tool,
    execute: createExecutor(tool),
  })),
});

await server.start();

interface McpServerOptions {
  /** Server name */
  name: string;

  /** Server version */
  version: string;

  /** Tool definitions */
  tools: ToolDefinition[];

  /** Transport type */
  transport?: 'stdio' | 'http';

  /** HTTP port (if using http transport) */
  port?: number;

  /** Enable logging */
  logging?: boolean;

  /** Custom logger */
  logger?: Logger;
}

const server = createMcpServer({
  name: 'my-server',
  transport: 'stdio',
  tools: [...]
});

await server.start();
// Communicates via stdin/stdout

const server = createMcpServer({
  name: 'my-server',
  transport: 'http',
  port: 3000,
  tools: [...]
});

await server.start();
// Listening on http://localhost:3000

interface ToolDefinition {
  /** Tool name (snake_case recommended) */
  name: string;

  /** Human-readable description */
  description: string;

  /** JSON Schema for input parameters */
  inputSchema: JSONSchema;

  /** Tool execution function */
  execute: (input: unknown, context: ToolContext) => Promise<unknown>;
}

interface ToolContext {
  /** Server configuration */
  config: ServerConfig;

  /** Logger instance */
  logger: Logger;

  /** Access to other tools */
  tools: Record<string, ToolDefinition>;

  /** Request metadata */
  request: RequestMetadata;
}

await server.start();

await server.stop();

server.addTool({
  name: 'new_tool',
  description: 'A new tool',
  inputSchema: { type: 'object' },
  execute: async () => ({ result: 'ok' }),
});

server.removeTool('tool_name');

const tools = server.listTools();
console.log(tools.map(t => t.name));

import { ToolError } from '@github-to-mcp/mcp-server';

const tool = {
  name: 'risky_operation',
  execute: async ({ path }) => {
    if (path.includes('..')) {
      throw new ToolError('Invalid path: directory traversal not allowed');
    }
    // ...
  }
};

enum ErrorCode {
  InvalidParams = -32602,
  InternalError = -32603,
  ToolNotFound = -32001,
  ExecutionFailed = -32002,
}

const server = createMcpServer({
  name: 'my-server',
  tools: [...],
  middleware: [
    // Logging middleware
    async (tool, input, context, next) => {
      console.log(`Calling ${tool.name} with`, input);
      const start = Date.now();
      const result = await next();
      console.log(`${tool.name} completed in ${Date.now() - start}ms`);
      return result;
    },

    // Caching middleware
    async (tool, input, context, next) => {
      const cacheKey = `${tool.name}:${JSON.stringify(input)}`;
      const cached = cache.get(cacheKey);
      if (cached) return cached;
      const result = await next();
      cache.set(cacheKey, result);
      return result;
    },
  ],
});