GitHub Enterprise MCP

GitHub Enterprise MCP: A Model Context Protocol Server

What is GitHub Enterprise MCP?

GitHub Enterprise MCP (Model Context Protocol) is a server designed to facilitate interaction with the GitHub Enterprise API. It provides an MCP interface, allowing users to easily access and manage various aspects of GitHub Enterprise, including repository information, issues, pull requests, and more, particularly within the Cursor environment.

How to Use GitHub Enterprise MCP

GitHub Enterprise MCP can be set up and used in several ways:

• Docker: Build and run a Docker image, providing necessary environment variables like GITHUB_TOKEN and GITHUB_ENTERPRISE_URL.
• Docker Compose: Use a docker-compose.yml file and a .env file for easier management of environment variables.
• Local Development (Concurrent Mode): Clone the repository, install dependencies (npm install), and run npm run dev for automatic recompilation and server restarts.
• Production (URL Mode): Build the project (npm run build) and run the server using node dist/index.js --transport http. Then, configure Cursor's .cursor/mcp.json to point to the server's URL.
• Global Command (npm link): Install globally using npm link after building, then run as a global command.
• npx (if published): If the package is published to npm, use npx @ddukbg/github-enterprise-mcp.

Integration with AI tools like Claude Desktop and Cursor is supported, typically by configuring their MCP settings to point to the running GitHub Enterprise MCP server.

Key Features of GitHub Enterprise MCP

• Repository Management: Retrieve, get detailed information, list branches, create, update, and delete repositories.
• Content Management: View file and directory contents.
• Issue and Pull Request Management: List, get details, create, and merge pull requests; list, get details, create, and list comments on issues.
• GitHub Actions: List workflows and workflow runs, trigger workflows.
• User Management (Enterprise Only): List, get details, create, update, suspend, and unsuspend users; list user organizations.
• Enterprise Statistics (Enterprise Only): Access license information and system statistics (requires site administrator privileges).
• Enhanced Error Handling: Provides robust error handling and user-friendly response formatting.
• Language Configuration: Supports English and Korean.

Use Cases of GitHub Enterprise MCP

• Automated Repository Operations: Programmatically create, update, and delete repositories.
• CI/CD Integration: Trigger GitHub Actions workflows from external systems.
• Issue and PR Automation: Automate the creation, management, and merging of issues and pull requests.
• Enterprise Administration: Manage users and access enterprise-level statistics within GitHub Enterprise Server environments.
• AI-Powered Development: Integrate with AI tools like Cursor and Claude Desktop to leverage AI for interacting with GitHub Enterprise data and functionalities.

FAQ about GitHub Enterprise MCP

• Compatibility: Primarily designed for GitHub Enterprise Server, but also works with GitHub.com and GitHub Enterprise Cloud (with some enterprise-specific features not working).
• Prerequisites: Node.js 18 or higher, access to a GitHub Enterprise instance, and a Personal Access Token (PAT).
• Required PAT Permissions: Different tools require specific PAT permissions (e.g., repo, delete_repo, actions:read, actions:write). Enterprise-specific tools require site_admin privileges.
• Recommended Cursor Integration: URL mode is recommended for the most stable operation in Cursor.
• Language Support: Supports English (default) and Korean, configurable via environment variables or command-line arguments.
• Additional HTTP Mode Options: --debug, --github-enterprise-url, --token, and --language are available.
• Available MCP Tools: A comprehensive list of tools is provided, including list-repositories, get-repository, list-branches, get-content, list-pull-requests, create-pull-request, merge-pull-request, list-issues, create-issue, create-repository, update-repository, delete-repository, list-workflows, list-workflow-runs, trigger-workflow, get-license-info, get-enterprise-stats, and various user management tools.", tags=[

GitHub Enterprise MCP Server

An MCP (Model Context Protocol) server for integration with GitHub Enterprise API. This server provides an MCP interface to easily access repository information, issues, PRs, and more from GitHub Enterprise in Cursor.

Compatibility

This project is primarily designed for GitHub Enterprise Server environments, but it also works with:

• GitHub.com
• GitHub Enterprise Cloud

Note: Some enterprise-specific features (like license information and enterprise statistics) will not work with GitHub.com or GitHub Enterprise Cloud.

Key Features

• Retrieve repository list from GitHub Enterprise instances
• Get detailed repository information
• List repository branches
• View file and directory contents
• Manage issues and pull requests
• Repository management (create, update, delete)
• GitHub Actions workflows management
• User management (list, create, update, delete, suspend/unsuspend users)
• Access enterprise statistics
• Enhanced error handling and user-friendly response formatting

Getting Started

Prerequisites

• Node.js 18 or higher
• Access to a GitHub Enterprise instance
• Personal Access Token (PAT)

Docker Installation and Setup

Option 1: Running with Docker

1. Build the Docker image:

   docker build -t github-enterprise-mcp .
   

2. Run the Docker container with environment variables:

   docker run -p 3000:3000 \
     -e GITHUB_TOKEN="your_github_token" \
     -e GITHUB_ENTERPRISE_URL="https://github.your-company.com/api/v3" \
     -e DEBUG=true \
     github-enterprise-mcp
   

Note: The Dockerfile is configured to run with --transport http by default. If you need to change this, you can override the command:

docker run -p 3000:3000 \
  -e GITHUB_TOKEN="your_github_token" \
  -e GITHUB_ENTERPRISE_URL="https://github.your-company.com/api/v3" \
  -e DEBUG=true \
  github-enterprise-mcp node dist/index.js --transport http --debug

Option 2: Using Docker Compose

1. Create a .env file in the project root with the required environment variables:

   GITHUB_ENTERPRISE_URL=https://github.your-company.com/api/v3
   GITHUB_TOKEN=your_github_token
   DEBUG=true
   

2. Start the container with Docker Compose:

   docker-compose up -d
   

3. Check the logs:

   docker-compose logs -f
   

4. Stop the container:

   docker-compose down
   

Installation and Setup

Local Development (Using Concurrent Mode)

This method is recommended for active development with automatic recompilation and server restarts:

1. Clone the repository and install required packages:

   git clone https://github.com/ddukbg/github-enterprise-mcp.git
   cd github-enterprise-mcp
   npm install
   

2. Run the development server:

   export GITHUB_TOKEN="your_github_token"
   export GITHUB_ENTERPRISE_URL="https://github.your-company.com/api/v3"
   npm run dev
   

   This will:

   • Compile TypeScript code automatically when files change
   • Restart the server when compiled files are updated
   • Run the server in HTTP mode for URL-based connections

3. Connect to Cursor using URL mode as described below

Installation and Setup for Production

Option 1: Using URL Mode (Recommended for Local Development)

This method is the most stable and recommended for local development or testing:

1. Clone the repository and install required packages:

   git clone https://github.com/ddukbg/github-enterprise-mcp.git
   cd github-enterprise-mcp
   npm install
   

2. Build the project:

   npm run build
   chmod +x dist/index.js
   

3. Run the server:

   export GITHUB_TOKEN="your_github_token"
   export GITHUB_ENTERPRISE_URL="https://github.your-company.com/api/v3"
   node dist/index.js --transport http --debug
   

4. Connect to Cursor using URL mode:

   • Add the following to your Cursor's .cursor/mcp.json file:

   {
     "mcpServers": {
       "github-enterprise": {
         "url": "http://localhost:3000/sse"
       }
     }
   }
   

Option 2: Install as a Global Command (npm link)

This method is useful for local development:

# After cloning the repository
git clone https://github.com/ddukbg/github-enterprise-mcp.git
cd github-enterprise-mcp

# Install required packages
npm install

# Build
npm run build
chmod +x dist/index.js

# Link globally
npm link

# Run as a global command
export GITHUB_TOKEN="your_github_token"
export GITHUB_ENTERPRISE_URL="https://github.your-company.com/api/v3"
github-enterprise-mcp --transport=http --debug

Option 3: Using npx (When Package is Published)

If the package is published to the public npm registry:

npx @ddukbg/github-enterprise-mcp --token=your_github_token --github-enterprise-url=https://github.your-company.com/api/v3

Integration with AI Tools

Claude Desktop

Add the following to your claude_desktop_config.json:

{
  "mcpServers": {
    "github-enterprise": {
      "command": "npx",
      "args": ["-y", "@ddukbg/github-enterprise-mcp", "--token=YOUR_GITHUB_TOKEN", "--github-enterprise-url=YOUR_GITHUB_ENTERPRISE_URL"]
    }
  }
}

Replace YOUR_GITHUB_TOKEN and YOUR_GITHUB_ENTERPRISE_URL with your actual values.

Cursor

Recommended: URL Mode (Most Stable)

For the most reliable operation in Cursor, using URL mode is recommended:

1. Start the server in a separate terminal window:

   cd /path/to/github-enterprise-mcp
   GITHUB_ENTERPRISE_URL="https://github.your-company.com/api/v3" GITHUB_TOKEN="your_github_token" node dist/index.js --transport http
   

2. Configure Cursor's MCP settings:

   • Open Cursor and go to Settings
   • Navigate to AI > MCP Servers
   • Edit your .cursor/mcp.json file:

   {
     "mcpServers": {
       "github-enterprise": {
         "url": "http://localhost:3000/sse"
       }
     }
   }
   

3. Restart Cursor to apply the changes

Alternative: Command Mode

Alternatively, you can configure Cursor to use the command mode, although URL mode is more reliable:

1. Open Cursor and go to Settings
2. Navigate to AI > MCP Servers
3. Click Add MCP Server
4. Enter the following details:
   • Name: GitHub Enterprise
   • Command: npx
   • Arguments: @ddukbg/github-enterprise-mcp
   • Environment Variables:
     • GITHUB_ENTERPRISE_URL: Your GitHub Enterprise API URL
     • GITHUB_TOKEN: Your GitHub personal access token

Alternatively, you can manually edit your .cursor/mcp.json file to include:

{
  "mcpServers": {
    "github-enterprise": {
      "command": "npx",
      "args": [
        "@ddukbg/github-enterprise-mcp"
      ],
      "env": {
        "GITHUB_ENTERPRISE_URL": "https://github.your-company.com/api/v3",
        "GITHUB_TOKEN": "your_github_token"
      }
    }
  }
}

Language Configuration

This MCP server supports both English and Korean languages. You can configure the language using:

Environment Variables

# Set language to Korean
export LANGUAGE=ko

# Or in .env file
LANGUAGE=ko

Command-line Arguments

# Set language to Korean
node dist/index.js --language ko

The default language is English if not specified.

Additional Options in HTTP Mode

• --debug: Enable debug logging
• --github-enterprise-url <URL>: Set GitHub Enterprise API URL
• --token <TOKEN>: Set GitHub Personal Access Token
• --language <LANG>: Set language (en or ko, default: en)

Available MCP Tools

This MCP server provides the following tools:

Tool Name	Description	Parameters	Required PAT Permissions
list-repositories	Retrieve repository list for a user or organization	owner: Username/org nameisOrg: Whether it's an organizationtype: Repository typesort: Sort criteriapage: Page numberperPage: Items per page	repo
get-repository	Get detailed repository information	owner: Repository ownerrepo: Repository name	repo
list-branches	List branches of a repository	owner: Repository ownerrepo: Repository nameprotected_only: Whether to show only protected branchespage: Page numberperPage: Items per page	repo
get-content	Retrieve file or directory contents	owner: Repository ownerrepo: Repository namepath: File/directory pathref: Branch/commit (optional)	repo
list-pull-requests	List pull requests in a repository	owner: Repository ownerrepo: Repository namestate: PR state filtersort: Sort criteriadirection: Sort directionpage: Page numberper_page: Items per page	repo
get-pull-request	Get pull request details	owner: Repository ownerrepo: Repository namepull_number: Pull request number	repo
create-pull-request	Create a new pull request	owner: Repository ownerrepo: Repository nametitle: PR titlehead: Head branchbase: Base branchbody: PR descriptiondraft: Create as draft PR	repo
merge-pull-request	Merge a pull request	owner: Repository ownerrepo: Repository namepull_number: Pull request numbermerge_method: Merge methodcommit_title: Commit titlecommit_message: Commit message	repo
list-issues	List issues in a repository	owner: Repository ownerrepo: Repository namestate: Issue state filtersort: Sort criteriadirection: Sort directionpage: Page numberper_page: Items per page	repo
get-issue	Get issue details	owner: Repository ownerrepo: Repository nameissue_number: Issue number	repo
list-issue-comments	List comments on an issue or pull request	owner: Repository ownerrepo: Repository nameissue_number: Issue/PR numberpage: Page numberper_page: Items per page	repo
create-issue	Create a new issue	owner: Repository ownerrepo: Repository nametitle: Issue titlebody: Issue body contentlabels: Array of label namesassignees: Array of user loginsmilestone: Milestone ID	repo
create-repository	Create a new repository	name: Repository namedescription: Repository descriptionprivate: Whether privateauto_init: Initialize with READMEgitignore_template: Add .gitignorelicense_template: Add licenseorg: Organization name	repo
update-repository	Update repository settings	owner: Repository ownerrepo: Repository namedescription: New descriptionprivate: Change privacydefault_branch: Change default branchhas_issues: Enable/disable issueshas_projects: Enable/disable projectshas_wiki: Enable/disable wikiarchived: Archive/unarchive	repo
delete-repository	Delete a repository	owner: Repository ownerrepo: Repository nameconfirm: Confirmation (must be true)	delete_repo
list-workflows	List GitHub Actions workflows	owner: Repository ownerrepo: Repository namepage: Page numberperPage: Items per page	actions:read
list-workflow-runs	List workflow runs	owner: Repository ownerrepo: Repository nameworkflow_id: Workflow ID/filenamebranch: Filter by branchstatus: Filter by statuspage: Page numberperPage: Items per page	actions:read
trigger-workflow	Trigger a workflow	owner: Repository ownerrepo: Repository nameworkflow_id: Workflow ID/filenameref: Git referenceinputs: Workflow inputs	actions:write
get-license-info	Get GitHub Enterprise license information	-	Requires site_admin (Administrator) account
get-enterprise-stats	Get GitHub Enterprise system statistics	-	Requires site_admin (Administrator) account

Note: For Enterprise-specific tools (get-license-info and get-enterprise-stats), a user with site administrator privileges is required. A Classic Personal Access Token is recommended, as Fine-grained tokens may not support these Enterprise-level permissions.

Using the Tools in Cursor

Once you have set up the MCP server and configured Cursor to connect to it, you can use the GitHub Enterprise tools directly in Cursor's AI chat. Here are some examples:

Listing Repositories

mcp_github_enterprise_list_repositories(owner="octocat")

Getting Repository Information

mcp_github_enterprise_get_repository(owner="octocat", repo="hello-world")

Listing Pull Requests

mcp_github_enterprise_list_pull_requests(owner="octocat", repo="hello-world", state="open")

Managing Issues

# List issues
mcp_github_enterprise_list_issues(owner="octocat", repo="hello-world", state="all")
# Get issue details
mcp_github_enterprise_get_issue(owner="octocat", repo="hello-world", issue_number=1)

# Get issue/PR comments
mcp_github_enterprise_list_issue_comments(owner="octocat", repo="hello-world", issue_number=1)


# Create a new issue
mcp_github_enterprise_create_issue(
  owner="octocat", 
  repo="hello-world",
  title="Found a bug",
  body="Here is a description of the bug",
  labels=["bug", "important"]
)

Working with Repository Content

mcp_github_enterprise_get_content(owner="octocat", repo="hello-world", path="README.md")

Repository Management

# Create a new repository
mcp_github_enterprise_create_repository(
  name="new-project",
  description="This is a new project",
  private=true,
  auto_init=true
)

# Update repository settings
mcp_github_enterprise_update_repository(
  owner="octocat",
  repo="hello-world",
  description="Updated description",
  has_issues=true
)

User Management (Enterprise Only)

These features are specifically designed for GitHub Enterprise Server environments and require administrative permissions:

# List all users in the GitHub Enterprise instance
mcp_github_enterprise_list_users(filter="active", per_page=100)

# Get a specific user's details
mcp_github_enterprise_get_user(username="octocat")

# Create a new user (Enterprise only)
mcp_github_enterprise_create_user(
  login="newuser",
  email="newuser@example.com",
  name="New User",
  company="ACME Inc."
)

# Update a user's information (Enterprise only)
mcp_github_enterprise_update_user(
  username="octocat",
  email="updated-email@example.com",
  location="San Francisco"
)

# Suspend a user (Enterprise only)
mcp_github_enterprise_suspend_user(
  username="octocat",
  reason="Violation of terms of service"
)

# Unsuspend a user (Enterprise only)
mcp_github_enterprise_unsuspend_user(username="octocat")

# List organizations a user belongs to
mcp_github_enterprise_list_user_orgs(username="octocat")

API Improvements

• Flexible API URL configuration (supports various environment variables and command-line arguments)
• Enhanced error handling and timeout management
• User-friendly response formatting and messages

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

ISC