PyGithub MCP Server

Instructions

Args:
    params: Dictionary with repository parameters
        - owner: Repository owner (username or organization)
        - repo: Repository name

Returns:
    MCP response with repository details

Implementation Reference

• src/pygithub_mcp_server/tools/repositories/tools.py:32-75 (handler)

  MCP tool handler: validates input with RepositoryRef, calls operations.repositories.get_repository(owner, repo), returns JSON-formatted repository details or error response.

  @tool()
  def get_repository(params: Dict) -> Dict:
      """Get details about a GitHub repository.
  
      Args:
          params: Dictionary with repository parameters
              - owner: Repository owner (username or organization)
              - repo: Repository name
  
      Returns:
          MCP response with repository details
      """
      try:
          logger.debug(f"get_repository called with params: {params}")
          # Convert dict to Pydantic model
          repo_params = RepositoryRef(**params)
          
          # Call operation
          result = repositories.get_repository(repo_params.owner, repo_params.repo)
          
          logger.debug(f"Got result: {result}")
          return {
              "content": [{"type": "text", "text": json.dumps(result, indent=2)}]
          }
      except ValidationError as e:
          logger.error(f"Validation error: {e}")
          return {
              "content": [{"type": "error", "text": f"Validation error: {str(e)}"}],
              "is_error": True
          }
      except GitHubError as e:
          logger.error(f"GitHub error: {e}")
          return {
              "content": [{"type": "error", "text": format_github_error(e)}],
              "is_error": True
          }
      except Exception as e:
          logger.error(f"Unexpected error: {e}")
          logger.error(traceback.format_exc())
          error_msg = str(e) if str(e) else "An unexpected error occurred"
          return {
              "content": [{"type": "error", "text": f"Internal server error: {error_msg}"}],
              "is_error": True
          }

• src/pygithub_mcp_server/schemas/base.py:10-33 (schema)

  Pydantic schema for repository reference (owner, repo) used for input validation in get_repository tool.

  class RepositoryRef(BaseModel):
      """Reference to a GitHub repository."""
  
      model_config = ConfigDict(strict=True)
      
      owner: str = Field(..., description="Repository owner (username or organization)")
      repo: str = Field(..., description="Repository name")
  
      @field_validator('owner')
      @classmethod
      def validate_owner(cls, v):
          """Validate that owner is not empty."""
          if not v.strip():
              raise ValueError("owner cannot be empty")
          return v
  
      @field_validator('repo')
      @classmethod
      def validate_repo(cls, v):
          """Validate that repo is not empty."""
          if not v.strip():
              raise ValueError("repo cannot be empty")
          return v

• src/pygithub_mcp_server/tools/repositories/__init__.py:9-39 (registration)

  Registration of repository tools including get_repository via register_tools call in the module's register function.

  def register(mcp: FastMCP) -> None:
      """Register all repository tools with the MCP server.
  
      Args:
          mcp: The MCP server instance
      """
      from pygithub_mcp_server.tools import register_tools
      from .tools import (
          get_repository,
          create_repository,
          fork_repository,
          search_repositories,
          get_file_contents,
          create_or_update_file,
          push_files,
          create_branch,
          list_commits
      )
  
      # Register all repository tools
      register_tools(mcp, [
          get_repository,
          create_repository,
          fork_repository,
          search_repositories,
          get_file_contents,
          create_or_update_file,
          push_files,
          create_branch,
          list_commits
      ])

• src/pygithub_mcp_server/operations/repositories.py:35-56 (helper)

  Core operation: fetches repository using GitHubClient.get_repo and converts to schema using convert_repository.

  def get_repository(owner: str, repo: str) -> Dict[str, Any]:
      """Get a repository by owner and name.
  
      Args:
          owner: Repository owner (user or organization)
          repo: Repository name
  
      Returns:
          Repository data in our schema
  
      Raises:
          GitHubError: If repository access fails
      """
      logger.debug(f"Getting repository: {owner}/{repo}")
      try:
          client = GitHubClient.get_instance()
          repository = client.get_repo(f"{owner}/{repo}")
          return convert_repository(repository)
      except GithubException as e:
          logger.error(f"GitHub exception when getting repo {owner}/{repo}: {str(e)}")
          raise client._handle_github_exception(e, resource_hint="repository")