Skip to main content
Glama
enesjakozh
oghenetejiriorukpegmail

GitHub MCP Server

by oghenetejiriorukpegmail
OverviewSchemaSourceRelated ServersDiscussionsAdmin
JavaScript
Hybrid

GitHub MCP 서버

GitHub 통합을 위한 모델 컨텍스트 프로토콜(MCP) 서버 구현입니다. 이 서버는 MCP 프로토콜을 통해 GitHub API와 상호 작용할 수 있는 도구를 제공합니다.

특징

  • GitHub 저장소 만들기

  • 콘텐츠를 저장소에 푸시합니다

  • 사용자 정보 가져오기

  • 적절한 오류 처리 및 TypeScript 유형 안전성

  • 자동 설치 스크립트

Related MCP server: github-mcp-tool

필수 조건

  • Node.js(v18 이상)

  • npm(v8 이상)

  • PowerShell(Windows 설치용)

  • 리포지토리 범위가 있는 GitHub 개인 액세스 토큰

설치

윈도우

  1. 이 저장소를 복제하세요:

지엑스피1

  1. 설치 스크립트를 실행합니다.

.\install.ps1

스크립트는 다음을 수행합니다.

  • 필요한 디렉토리를 생성하세요

  • 종속성 설치

  • TypeScript 코드 작성

  • MCP 설정 구성

수동 설치

  1. MCP 디렉토리를 만듭니다.

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

  1. 이 저장소를 해당 디렉토리에 복제합니다.

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

  1. 종속성 설치:

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

  1. TypeScript 코드를 작성합니다.

npm run build

  1. %APPDATA%\Code\User\globalStorage\rooveterinaryinc.roo-cline\settings\cline_mcp_settings.json 에 있는 MCP 설정 파일에 서버 구성을 추가하세요.

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

사용 가능한 도구

사용자 가져오기

GitHub 사용자 정보를 가져옵니다.

{
  "username": "octocat"
}

리포지토리 생성

새로운 GitHub 저장소를 만듭니다.

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

리포지토리로 푸시

GitHub 저장소에 콘텐츠를 푸시합니다.

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

개발

  1. 저장소를 복제합니다

  2. 종속성 설치: npm install

  3. src/index.ts 를 변경하세요

  4. 빌드: npm run build

  5. 변경 사항을 테스트하세요

기여하다

  1. 저장소를 포크하세요

  2. 기능 브랜치 생성

  3. 변경 사항을 커밋하세요

  4. 지점으로 밀어 넣기

  5. 풀 리퀘스트 만들기

특허

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