Skip to main content
Glama
enesjakozh
oghenetejiriorukpegmail

GitHub MCP Server

by oghenetejiriorukpegmail
OverviewSchemaSourceRelated ServersDiscussionsAdmin
JavaScript
Hybrid

Servidor MCP de GitHub

Implementación de un servidor del Protocolo de Contexto de Modelo (MCP) para la integración con GitHub. Este servidor proporciona herramientas para interactuar con la API de GitHub mediante el protocolo MCP.

Características

  • Crear repositorios de GitHub

  • Enviar contenido a los repositorios

  • Obtener información del usuario

  • Manejo adecuado de errores y seguridad de tipos en TypeScript

  • Script de instalación automática

Related MCP server: github-mcp-tool

Prerrequisitos

  • Node.js (v18 o superior)

  • npm (v8 o superior)

  • PowerShell (para instalación en Windows)

  • Token de acceso personal de GitHub con alcance de repositorio

Instalación

Ventanas

  1. Clonar este repositorio:

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

  1. Ejecute el script de instalación:

.\install.ps1

El guión hará lo siguiente:

  • Crea los directorios necesarios

  • Instalar dependencias

  • Construir el código TypeScript

  • Configurar los ajustes de MCP

Instalación manual

  1. Crear el directorio MCP:

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

  1. Clone este repositorio en ese directorio:

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

  1. Instalar dependencias:

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

  1. Construya el código TypeScript:

npm run build

  1. Agregue la configuración del servidor a su archivo de configuración de MCP en: %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": []
    }
  }
}

Herramientas disponibles

obtener_usuario

Obtener información del usuario de GitHub.

{
  "username": "octocat"
}

crear_repositorio

Crea un nuevo repositorio de GitHub.

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

enviar al repositorio

Enviar contenido a un repositorio de GitHub.

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

Desarrollo

  1. Clonar el repositorio

  2. Instalar dependencias: npm install

  3. Realizar cambios en src/index.ts

  4. Construir: npm run build

  5. Pruebe sus cambios

Contribuyendo

  1. Bifurcar el repositorio

  2. Crear una rama de características

  3. Confirme sus cambios

  4. Empujar hacia la rama

  5. Crear una solicitud de extracción

Licencia

Instituto Tecnológico de Massachusetts (MIT)

Available Tools

3 tools
create_repoC

Create a new GitHub repository

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

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

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.

  1. 3 tool updates
    • First observedcreate_repo
    • First observedget_user
    • First observedpush_to_repo
Deploy Server
Shareable, User-Owned Context BackendPeople, applications, and agents read, write, and coordinate together in one context lake. Reach it over MCP, a CLI, a Python SDK, or REST.fulcradynamics.comAd

TDQS

B3/5.0

Scored across 3 tools

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
ResponsivenessNo issues

Resources

Related MCP Connectors

Related MCP Servers

Appeared in Searches