Skip to main content
Glama
enesjakozh
oghenetejiriorukpegmail

GitHub MCP Server

by oghenetejiriorukpegmail
OverviewSchemaRelated ServersScoreDiscussions
JavaScript
Hybrid

GitHub MCP Server

A Model Context Protocol (MCP) server implementation for GitHub integration. This server provides tools for interacting with GitHub's API through the MCP protocol.

Features

  • Create GitHub repositories

  • Push content to repositories

  • Get user information

  • Proper error handling and TypeScript type safety

  • Automatic installation script

Related MCP server: github-mcp-tool

Prerequisites

  • Node.js (v18 or higher)

  • npm (v8 or higher)

  • PowerShell (for Windows installation)

  • GitHub Personal Access Token with repo scope

Installation

Windows

  1. Clone this repository:

git clone https://github.com/oghenetejiriorukpegmail/github-mcp.git

  1. Run the installation script:

.\install.ps1

The script will:

  • Create the necessary directories

  • Install dependencies

  • Build the TypeScript code

  • Configure the MCP settings

Manual Installation

  1. Create the MCP directory:

mkdir -p "$env:APPDATA\Roo-Code\MCP\github-mcp"

  1. Clone this repository into that directory:

git clone https://github.com/oghenetejiriorukpegmail/github-mcp.git "$env:APPDATA\Roo-Code\MCP\github-mcp"

  1. Install dependencies:

cd "$env:APPDATA\Roo-Code\MCP\github-mcp"
npm install

  1. Build the TypeScript code:

npm run build

  1. Add the server configuration to your MCP settings file at: %APPDATA%\Code\User\globalStorage\rooveterinaryinc.roo-cline\settings\cline_mcp_settings.json

{
  "mcpServers": {
    "github": {
      "command": "node",
      "args": [
        "%APPDATA%\Roo-Code\MCP\github-mcp\build\index.js"
      ],
      "env": {
        "GITHUB_TOKEN": "your-github-token-here"
      },
      "disabled": false,
      "alwaysAllow": []
    }
  }
}

Available Tools

get_user

Get GitHub user information.

{
  "username": "octocat"
}

create_repo

Create a new GitHub repository.

{
  "repo_name": "my-new-repo",
  "description": "A new repository",
  "private": false
}

push_to_repo

Push content to a GitHub repository.

{
  "repo_name": "my-repo",
  "file_path": "docs/README.md",
  "content": "# My Project\nThis is a test file.",
  "message": "Add README file"
}

Development

  1. Clone the repository

  2. Install dependencies: npm install

  3. Make changes to src/index.ts

  4. Build: npm run build

  5. Test your changes

Contributing

  1. Fork the repository

  2. Create a feature branch

  3. Commit your changes

  4. Push to the branch

  5. Create a Pull Request

License

MIT

Available Tools

3 tools
create_repoC

Create a new GitHub repository

ParametersJSON Schema
NameRequiredDescriptionDefault
repo_nameYesThe name of the repository to create
descriptionNoA description of the repository
privateNoWhether the repository should be private

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. It states 'Create' which implies a write/mutation operation, but doesn't mention authentication needs, rate limits, whether the operation is idempotent, or what happens on success/failure. This leaves significant gaps for an agent to understand the tool's behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that states exactly what the tool does with zero wasted words. It's appropriately sized and front-loaded with the core functionality.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't address authentication requirements, error conditions, return values, or how it differs from sibling tools. The agent would need to guess about critical behavioral aspects of this repository creation operation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 100% description coverage, so all parameters are documented in the structured schema. The description adds no additional parameter information beyond what's already in the schema properties. This meets the baseline expectation when schema coverage is complete.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Create') and resource ('new GitHub repository'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'push_to_repo' which also interacts with repositories, missing an opportunity for clearer distinction.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'push_to_repo' (which might modify existing repositories) or 'get_user' (which retrieves information). There's no mention of prerequisites, such as authentication requirements or GitHub account permissions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_userC

Get GitHub user information

ParametersJSON Schema
NameRequiredDescriptionDefault
usernameYesGitHub username

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get GitHub user information' implies a read-only operation, but it doesn't specify if it requires authentication, rate limits, what data is returned, or error handling. For a tool with no annotations, this leaves significant behavioral gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description 'Get GitHub user information' is a single, efficient sentence that is front-loaded and wastes no words. It directly conveys the core purpose without unnecessary elaboration, making it highly concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has no annotations and no output schema, the description is incomplete. It doesn't explain what user information is retrieved (e.g., profile data, repositories), the return format, or any behavioral aspects like error cases. For a tool with this complexity and lack of structured data, more context is needed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with the 'username' parameter clearly documented as 'GitHub username'. The description doesn't add any meaning beyond this, such as format examples or constraints. With high schema coverage, the baseline is 3, as the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Get GitHub user information' clearly states the verb 'Get' and resource 'GitHub user information', making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'create_repo' or 'push_to_repo', which are clearly different operations, so it doesn't need sibling differentiation but could be more specific about what user information is retrieved.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context for usage, or any exclusions. While sibling tools are for different operations (creating and pushing to repos), there's no explicit guidance on usage scenarios for this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

push_to_repoC

Push content to a GitHub repository

ParametersJSON Schema
NameRequiredDescriptionDefault
repo_nameYesThe name of the repository to push to
file_pathYesThe path where the file should be created in the repository
contentYesThe content to push to the repository
messageNoThe commit messageUpdate via GitHub MCP

TDQS

C2.7/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden but lacks behavioral details. It states 'push content' but doesn't disclose if this creates/overwrites files, requires authentication, has rate limits, or what happens on success/failure (e.g., commit creation). It's minimal and misses key operational traits for a write operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for the tool's complexity, making it easy to parse quickly without unnecessary elaboration.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (a write operation to GitHub with 4 parameters), no annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects, return values, or error handling, leaving significant gaps for an agent to understand how to invoke it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, clearly documenting all 4 parameters (repo_name, file_path, content, message). The description adds no meaning beyond the schema, as it doesn't explain parameter interactions or usage nuances. Baseline 3 is appropriate since the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Push content to a GitHub repository' states a clear verb ('push') and resource ('GitHub repository'), but it's vague about what 'push' entails (e.g., creating/updating files, committing changes) and doesn't distinguish it from sibling tools like 'create_repo' (which likely creates repositories) or 'get_user' (which likely retrieves user data). It's not tautological, but lacks specificity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing repository), exclusions (e.g., not for creating repos), or compare to siblings like 'create_repo' for repository creation. Usage is implied by the action but without explicit context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 3 tool updates
    • First observedcreate_repo
    • First observedget_user
    • First observedpush_to_repo
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3/5.0
Disambiguation5/5

Each tool has a clearly distinct purpose: create_repo handles repository creation, get_user retrieves user information, and push_to_repo manages content pushes to repositories. There is no overlap in functionality, making it easy for an agent to select the correct tool for each task.

Naming Consistency4/5

The tools follow a consistent verb_noun pattern (create_repo, get_user, push_to_repo), which is predictable and readable. The minor deviation is that 'push_to_repo' includes a preposition, but this does not significantly impact consistency or clarity.

Tool Count3/5

With only 3 tools, the server feels thin for a GitHub domain, which typically involves more operations like listing repositories, managing issues, or handling pull requests. While the tools are well-scoped, the count is borderline low for comprehensive GitHub functionality.

Completeness2/5

The tool surface has significant gaps for a GitHub server. It lacks core operations such as listing repositories, updating or deleting repositories, managing issues or pull requests, and searching code. This incomplete coverage will likely cause agent failures when trying to perform common GitHub workflows.

Maintenance

ActivityInactive
ResponsivenessSyncing

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

Appeared in Searches

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/oghenetejiriorukpegmail/github-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server