GitHub to MCP Converter

GitHub to MCP

Convert any GitHub repository into an MCP server in seconds

Give Claude, ChatGPT, Cursor, Windsurf, Cline, and any AI assistant instant access to any codebase.

🌐 Web App • 🚀 Quick Start • ✨ Features • 📖 Docs

---

📋 Table of Contents

• Introduction
• What is MCP
• Quick Start
• Features
• Installation
• Usage
• How It Works
• Generated Tools
• Configuration
• Integrating with AI Assistants
• Interactive Playground
• Project Structure
• Development
• Architecture Overview
• Supported Input Formats
• Output Formats
• Limitations
• Troubleshooting
• Contributing
• License

---

📖 Introduction

GitHub to MCP bridges the gap between code repositories and AI assistants. Instead of manually describing APIs or copying code snippets into chat windows, this tool generates a standardized interface that allows AI systems to programmatically explore, read, and interact with any GitHub repository.

The generated MCP servers provide tools that AI assistants can invoke to read files, search code, list directory structures, and call API endpoints discovered within the repository. This enables AI assistants to have deep, structured access to codebases without requiring manual context management.

┌─────────────────────────────────────────────────────────────┐

│ GitHub Repository │ └─────────────────────────────────────────────────────────────┘ ↓ ┌─────────────────────────────────────────────────────────────┐ │ 1. Fetch & Classify → Detect repo type (API/CLI/Lib) │ │ 2. Extract Tools → OpenAPI, GraphQL, Code, README │ │ 3. Generate Server → TypeScript or Python MCP server │ │ 4. Bundle Output → Complete package with dependencies │ └─────────────────────────────────────────────────────────────┘ ↓ ┌─────────────────────────────────────────────────────────────┐ │ Ready-to-use MCP Server + Config │ └─────────────────────────────────────────────────────────────┘

---

🔌 What is MCP

The Model Context Protocol (MCP) is an open standard developed by Anthropic that defines how AI assistants communicate with external tools and data sources. MCP servers expose "tools" that AI models can invoke, along with "resources" that provide context and "prompts" that guide interactions.

When you connect an MCP server to an AI assistant like Claude Desktop, the assistant gains the ability to call the tools defined by that server. For example, a GitHub MCP server might expose tools like read_file, search_code, or list_pull_requests, which the AI can invoke to gather information needed to answer questions or complete tasks.

This project generates MCP servers from GitHub repositories, automatically creating tools based on the repository's contents, APIs, and documentation.

---

🚀 Quick Start

🌐 Web UI (Easiest)

Visit [github-to-mcp.modelcontextprotocol.name](https://github-to-mcp.modelcontextprotocol.name) — Paste any GitHub URL, click Generate, download your MCP server.

💻 CLI (One Command)

npx @nirholas/github-to-mcp https://github.com/stripe/stripe-node

📦 Programmatic (For Automation)

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

const result = await generateFromGithub('https://github.com/stripe/stripe-node'); console.log(Generated ${result.tools.length} tools); await result.save('./my-mcp-server');

---

✨ Features

🔬 Repository Analysis

• Automatic repository type classification (API, library, CLI tool, MCP server, documentation)
• Detection and parsing of OpenAPI/Swagger specifications
• GraphQL schema extraction and query/mutation tool generation
• gRPC/Protobuf service definition parsing
• AsyncAPI specification support for event-driven APIs
• Source code analysis for function extraction

🌍 Multi-Language Support

Input repositories:

• TypeScript and JavaScript
• Python
• Go
• Java and Kotlin
• Rust
• Ruby
• C# and F#

Output MCP servers:

• TypeScript (using the official MCP SDK)
• Python (using the MCP Python SDK)
• Go (using community MCP libraries)

🔧 Tool Extraction

• OpenAPI endpoints become callable tools with typed parameters
• GraphQL queries and mutations become tools with input validation
• Python functions decorated with @mcp.tool are preserved
• CLI commands documented in READMEs become executable tools
• HTTP route handlers from popular frameworks are detected

⚡ Code Generation

• Complete, runnable MCP server code with all dependencies
• Configuration files for Claude Desktop, Cursor, and other clients
• Docker deployment templates
• TypeScript type definitions for all generated tools

---

📥 Installation

From Source

Clone the repository and install dependencies:

git clone https://github.com/nirholas/github-to-mcp.git

cd github-to-mcp pnpm install pnpm build

Using the Web Interface

The web application is deployed at [github-to-mcp.modelcontextprotocol.name](https://github-to-mcp.modelcontextprotocol.name). Use the browser-based interface without any local installation.

---

📖 Usage

🌐 Web Interface

The web interface provides the simplest way to convert repositories:

1. Navigate to the web application
2. Enter a GitHub repository URL (e.g., https://github.com/owner/repo)
3. Optionally configure extraction options
4. Click "Generate" to analyze the repository
5. Review the generated tools and code
6. Download the MCP server package or copy the configuration

The web interface also provides an interactive playground where you can test generated tools before downloading.

💻 Command Line Interface

After building the project locally, you can use the CLI:

# Basic usage

node packages/core/dist/cli.mjs https://github.com/owner/repo

Specify output directory

node packages/core/dist/cli.mjs https://github.com/owner/repo --output ./my-mcp-server

Generate Python instead of TypeScript

node packages/core/dist/cli.mjs https://github.com/owner/repo --language python

Include only specific extraction sources

node packages/core/dist/cli.mjs https://github.com/owner/repo --sources openapi,readme

Use a GitHub token for private repos or higher rate limits

GITHUB_TOKEN=ghp_xxx node packages/core/dist/cli.mjs https://github.com/owner/repo

📦 Programmatic API

Import the generator in your own TypeScript or JavaScript code:

import { GithubToMcpGenerator } from '@nirholas/github-to-mcp';

const generator = new GithubToMcpGenerator({ githubToken: process.env.GITHUB_TOKEN, sources: ['openapi', 'readme', 'code'], outputLanguage: 'typescript' });

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

console.log(Repository: ${result.name}); console.log(Classification: ${result.classification.type}); console.log(Generated ${result.tools.length} tools);

// Access the generated code console.log(result.code);

// Save to disk await result.save('./output-directory');

📋 Generator Options Interface

interface GithubToMcpOptions {

// GitHub personal access token for API authentication githubToken?: string;

// Which sources to extract tools from // Default: ['openapi', 'readme', 'code', 'graphql', 'mcp'] sources?: Array<'openapi' | 'readme' | 'code' | 'graphql' | 'grpc' | 'mcp'>;

// Output language for generated server // Default: 'typescript' outputLanguage?: 'typescript' | 'python' | 'go';

// Include universal tools (read_file, list_files, etc.) // Default: true includeUniversalTools?: boolean;

// Maximum number of tools to generate // Default: 100 maxTools?: number;

// Specific branch to analyze // Default: repository's default branch branch?: string; }

---

⚙️ How It Works

The conversion process follows these stages:

🏷️ Repository Classification

The generator first analyzes the repository to determine its type and structure:

1. Fetch repository metadata from the GitHub API
2. Download and parse the README file
3. Examine package.json, setup.py, go.mod, or other manifest files
4. Scan for API specification files (openapi.json, schema.graphql, etc.)
5. Classify the repository as one of:

Classification influences which extraction strategies are prioritized and how tools are named.

🔍 Tool Extraction

Tools are extracted from multiple sources within the repository:

📄 OpenAPI/Swagger Extraction

When an OpenAPI specification is found:

1. Parse the specification (JSON or YAML, v2 or v3)
2. Extract each endpoint as a potential tool
3. Convert path parameters, query parameters, and request bodies to tool input schemas
4. Generate descriptions from operation summaries and descriptions
5. Map HTTP methods to appropriate tool semantics

🔷 GraphQL Extraction

When GraphQL schemas are found:

1. Parse .graphql or .gql schema files
2. Extract Query type fields as read-only tools
3. Extract Mutation type fields as write tools
4. Convert GraphQL input types to JSON Schema for tool inputs
5. Handle nested types and custom scalars

📖 README Extraction

The README is analyzed for:

1. Code blocks showing CLI usage patterns
2. API endpoint examples with curl or fetch
3. Function call examples with parameters
4. Installation and usage instructions

Extracted examples become tools with inferred parameter schemas.

💻 Source Code Extraction

For supported languages, the source code is analyzed:

1. Python: Functions decorated with @mcp.tool, @server.tool, or similar
2. TypeScript: Exported functions with JSDoc annotations
3. Go: HTTP handlers from Gin, Echo, Chi, Fiber, or Gorilla Mux
4. Java/Kotlin: Methods annotated with @GetMapping, @PostMapping, etc.
5. Rust: Route handl