# Directory Structure

```
├── .gitignore
├── claude_desktop_config.json
├── main.py
├── pyproject.toml
├── README.md
└── requirements.txt
```

# Files

--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------

```
# Python-generated files
__pycache__/
*.py[oc]
build/
dist/
wheels/
*.egg-info

# Virtual environments
.venv
.env 

```

--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------

```markdown
# GitHub MCP Server

## Overview

GitHub MCP Server is an API-based tool that interacts with GitHub using the [MCP (Modular Command Processor)](https://github.com/mcp-framework) framework. It provides various functionalities, including fetching user details, repository information, and authenticated user data using GitHub's REST API.

This project is built using Python and leverages `httpx` for asynchronous API calls. It also uses `dotenv` for secure handling of GitHub authentication tokens.

## Features

- Fetch GitHub user information by username.
- Retrieve details of a GitHub repository.
- Get authenticated user details using a GitHub personal access token.
- Utilizes `FastMCP` for modular command processing.

## Project Structure
```bash
D:/MCP_Project/ 
|----.env
│----.gitignore
│----claude_desktop_config.json  (Create this file in C:\Users\your_username\AppData\Roaming\Claude\)
│----main.py
│----pyproject.toml
│----README.md
│----requirements.txt
```

<br>

- `main.py`: Core logic of the GitHub MCP Server.
- `.env`: Stores environment variables (e.g., GitHub Token).
- `claude_desktop_config.json`: Configuration for running the MCP Server.
- `requirements.txt`: Lists required dependencies.
- `explanation_video.mp4`: A video explaining the project.

## Setup Instructions

### Prerequisites

- Python >=3.10
- GitHub personal access token (for authenticated requests)
- `conda` or `venv` for virtual environment management

### Setup and Usage

1. **Clone the Repository**
   ```bash
   git clone https://github.com/DivyanshKushwaha/GitHub-MCP-Server-Claude.git
   cd GitHub-MCP-Server-Claude
   ```
2. **Create Python environment**
```bash 
python -m venv venv
source venv/bin/activate  
```

3. **Install Dependencies**
```bash
pip install -r requirements.txt
```

4. **Set Up Environment Variables (Create .env file)**
```bash
GITHUB_TOKEN=your_personal_access_token
```

5. **Setup claude_desktop_config.json**

```bash
{
    "mcpServers": {
        "MCP_Server": {
            "command": "my_env/Scripts/uv",
            "args": [
                "run",
                "D:/MCP_Project/main.py"
            ]
        }
    }
}
```

- The command key specifies the path to the uv script located in the conda environment. This is used to run the server.

- The args key provides additional arguments for the uv script:

    - "run": Indicates the action to run the server.
    - my_env : python environment 'my_env'
    - "D:/MCP_Project/main.py": Specifies the path to the main.py script, which contains the implementation of the MCP server.


6. **Launch the Claude Desktop Application**
- Open the Claude Desktop Application. 
- It will use the MCP Server as configured in the claude_desktop_config.json file to fetch and process data.
```

--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------

```
fastmcp
httpx
python-dotenv
uv

```

--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------

```toml
[project]
name = "mcp-server"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.10"
dependencies = []

```

--------------------------------------------------------------------------------
/claude_desktop_config.json:
--------------------------------------------------------------------------------

```json
{
    "mcpServers": {
        "MCP_Server": {
            "command": "D:/conda-envs/openaidemo/Scripts/uv",
            "args": [
                "run",
                "D:/Assignments/MCP_Server/main.py"
            ]
        }
    }
}

```

--------------------------------------------------------------------------------
/main.py:
--------------------------------------------------------------------------------

```python
from mcp.server.fastmcp import FastMCP
from dotenv import load_dotenv
import httpx
import os

# Load environment variables
load_dotenv()
GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")

# Initialize MCP server
mcp = FastMCP("github")

# GitHub API base URL and headers
BASE_URL = "https://api.github.com"
HEADERS = {
    "Authorization": f"Bearer {GITHUB_TOKEN}",
    "Accept": "application/vnd.github.v3+json",
    "User-Agent": "mcp-github-server"
}


@mcp.tool()
async def get_user_info(username: str):
    """
    Fetches information about a GitHub user.

    Args:
        username: The username of the GitHub user.

    Returns:
        A dictionary containing user details.
    """
    url = f"{BASE_URL}/users/{username}"
    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(url, headers=HEADERS)
            response.raise_for_status()
            return response.json()
        except httpx.HTTPStatusError as e:
            return {"error": str(e)}
        except httpx.TimeoutException:
            return {"error": "Request timed out"}


@mcp.tool()
async def get_repo_info(owner: str, repo: str):
    """
    Fetches information about a GitHub repository.

    Args:
        owner: The username of the repository owner.
        repo: The name of the repository.

    Returns:
        A dictionary containing repository details.
    """
    url = f"{BASE_URL}/repos/{owner}/{repo}"
    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(url, headers=HEADERS)
            response.raise_for_status()
            return response.json()
        except httpx.HTTPStatusError as e:
            return {"error": str(e)}
        except httpx.TimeoutException:
            return {"error": "Request timed out"}


@mcp.tool()
async def get_authenticated_user():
    """
    Fetches information about the authenticated GitHub user.

    Returns:
        A dictionary containing the authenticated user's details.
    """
    url = f"{BASE_URL}/user"
    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(url, headers=HEADERS)
            response.raise_for_status()
            return response.json()
        except httpx.HTTPStatusError as e:
            return {"error": str(e)}
        except httpx.TimeoutException:
            return {"error": "Request timed out"}


def main():
    print("Running MCP server for GitHub!")


if __name__ == "__main__":
    mcp.run(transport="stdio")





```