Skip to main content
Glama
venugopalareddy46

MCP GitHub Automation Server

by venugopalareddy46
OverviewSchemaRelated ServersScoreDiscussions
Python
Remote

🤖 MCP GitHub Automation Server

📌 Project Overview

This project demonstrates how to build, containerize, deploy, and automatically update a Model Context Protocol (MCP) server for GitHub automation.

The MCP server is developed using Python and exposes GitHub-related tools that can be discovered and invoked by an MCP-compatible AI application.

The complete application is:

Python MCP Server
        ↓
GitHub REST API
        ↓
Docker Container
        ↓
GitHub Container Registry
        ↓
AWS EC2
        ↓
GitHub Actions CI/CD

Related MCP server: GitHubMcpServer

🎯 Project Objectives

  • 🧠 Understand Model Context Protocol

  • 🔌 Build a custom MCP server

  • 🛠️ Implement MCP tools

  • 🐙 Integrate GitHub REST API

  • 🐳 Containerize the MCP server

  • ☁️ Deploy the server on AWS EC2

  • 📦 Publish Docker images to GHCR

  • ⚙️ Implement GitHub Actions CI/CD

  • 🔐 Secure API credentials

  • 🚀 Automate application deployment

🧠 What is MCP?

Model Context Protocol (MCP) is a standardized protocol that allows AI applications to interact with external tools, resources, and services.

Instead of creating a separate integration for every AI application and external system, MCP provides a common interface.

                     ┌─────────────────────┐
                     │    AI Application   │
                     └──────────┬──────────┘
                                │
                                ▼
                     ┌─────────────────────┐
                     │      MCP Client     │
                     └──────────┬──────────┘
                                │
                         MCP Protocol
                                │
                                ▼
                     ┌─────────────────────┐
                     │      MCP Server     │
                     └──────────┬──────────┘
                                │
             ┌──────────────────┼──────────────────┐
             │                  │                  │
             ▼                  ▼                  ▼
          🛠 Tools          📚 Resources       💬 Prompts
             │                  │                  │
             └──────────────────┼──────────────────┘
                                │
                                ▼
                       External Systems

🔌 MCP Architecture

┌──────────────────────────────────────────────────────────────┐
│                      AI APPLICATION                          │
│                                                              │
│   ChatGPT / Claude / Other MCP-Compatible AI Application    │
└────────────────────────────┬─────────────────────────────────┘
                             │
                             ▼
                    ┌─────────────────┐
                    │    MCP Client   │
                    └────────┬────────┘
                             │
                             │ MCP
                             ▼
┌──────────────────────────────────────────────────────────────┐
│                         AWS EC2                              │
│                                                              │
│   ┌──────────────────────────────────────────────────────┐   │
│   │                 Docker Container                     │   │
│   │                                                      │   │
│   │                 Python MCP Server                    │   │
│   │                                                      │   │
│   │   ┌────────────┐ ┌────────────┐ ┌──────────────┐   │   │
│   │   │ Repository │ │   Issues   │ │   Workflows  │   │   │
│   │   │    Tool    │ │    Tool    │ │     Tool     │   │   │
│   │   └──────┬─────┘ └─────┬──────┘ └──────┬───────┘   │   │
│   └──────────┼──────────────┼───────────────┼───────────┘   │
└──────────────┼──────────────┼───────────────┼───────────────┘
               │              │               │
               └──────────────┼───────────────┘
                              ▼
                    ┌──────────────────┐
                    │  GitHub REST API │
                    └────────┬─────────┘
                             │
                             ▼
                       🐙 GitHub

🐙 GitHub Automation Use Case

GitHub was selected as the practical MCP use case.

The MCP server provides controlled access to GitHub information through reusable tools.

Problem

AI applications need a standardized and secure way to interact with GitHub repositories, issues, and workflows.

MCP Solution

The MCP server acts as a controlled gateway between the AI application and GitHub.

AI
 │
 ▼
MCP Client
 │
 ▼
MCP Server
 │
 ├── Repository Information
 ├── Issue Management
 └── Workflow Monitoring
 │
 ▼
GitHub API

🛠️ MCP Tools

Tool

Purpose

get_repository_info()

Retrieve repository information

list_issues()

Retrieve open GitHub issues

get_workflow_status()

Check GitHub Actions workflow status

📦 Repository Information

get_repository_info()

Returns:

Repository Name
Description
Visibility
Default Branch
Stars
Forks

🐛 Issue Management

list_issues()

Returns open GitHub issues.

Example:

Issue #12
Title: Docker deployment issue
State: OPEN

⚙️ Workflow Monitoring

get_workflow_status()

Returns GitHub Actions workflow information.

Example:

Workflow: MCP Server CI/CD
Status: completed
Conclusion: success
Branch: main

🧰 Technology Stack

Category

Technology

🤖 Protocol

Model Context Protocol

🐍 Language

Python 3.12

🔌 SDK

MCP Python SDK

🐙 API

GitHub REST API

🌐 HTTP

HTTPX

🐳 Container

Docker

📦 Registry

GitHub Container Registry

☁️ Cloud

AWS

💻 Compute

EC2

🐧 OS

Ubuntu

⚙️ CI/CD

GitHub Actions

🔬 Testing

MCP Inspector

🌐 Transport

Streamable HTTP

📁 Project Structure

github-mcp-server/
│
├── 📄 server.py
├── 📄 requirements.txt
├── 🐳 Dockerfile
├── 📄 .dockerignore
├── 📄 .gitignore
├── 📄 README.md
│
└── .github/
    └── workflows/
        └── 🚀 deploy.yml

⚙️ Environment Configuration

Create a .env file:

GITHUB_TOKEN=your_github_token
GITHUB_OWNER=your_github_username
GITHUB_REPO=your_repository_name

🔐 Never commit .env

Add the following to .gitignore:

.env
venv/
__pycache__/
*.pyc

💻 Local Development

Clone Repository

git clone https://github.com/YOUR_USERNAME/YOUR_REPOSITORY.git
cd github-mcp-server

Create Virtual Environment

python -m venv venv

Linux:

source venv/bin/activate

Windows:

venv\Scripts\activate

Install Dependencies

pip install -r requirements.txt

Start Server

python server.py

🌐 MCP Endpoint

The MCP server uses Streamable HTTP.

Local:

http://localhost:8000/mcp

AWS EC2:

http://EC2_PUBLIC_IP:8000/mcp

For production:

https://mcp.example.com/mcp

🐳 Docker

Build Image

docker build -t github-mcp-server .

Run Container

docker run -d \
  --name mcp-server \
  --env-file .env \
  -p 8000:8000 \
  github-mcp-server

Verify

docker ps

View Logs

docker logs mcp-server

🐳 Dockerfile

FROM python:3.12-slim

WORKDIR /app

ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt

COPY server.py .

EXPOSE 8000

CMD ["python", "server.py"]

☁️ AWS EC2 Deployment

The MCP server is deployed on an Ubuntu EC2 instance using Docker.

Install Docker

sudo apt update
sudo apt install -y docker.io

Enable Docker:

sudo systemctl enable docker
sudo systemctl start docker

Verify:

docker --version

Clone Project

git clone https://github.com/YOUR_USERNAME/YOUR_REPOSITORY.git
cd github-mcp-server

Configure Environment

nano .env

Add:

GITHUB_TOKEN=your_github_token
GITHUB_OWNER=your_github_username
GITHUB_REPO=your_repository_name

Secure the file:

chmod 600 .env

Run MCP Server

docker build -t github-mcp-server .
docker run -d \
  --name mcp-server \
  --restart unless-stopped \
  --env-file .env \
  -p 8000:8000 \
  github-mcp-server

Verify:

docker ps

🔄 CI/CD Pipeline

                 👨‍💻 Developer
                       │
                       │ git push
                       ▼
                🐙 GitHub Repository
                       │
                       ▼
                ⚙️ GitHub Actions
                       │
             ┌─────────┴─────────┐
             │                   │
             ▼                   ▼
        🧪 Test             🐳 Build
             │                   │
             └─────────┬─────────┘
                       │
                       ▼
                📦 Docker Image
                       │
                       ▼
                 📦 GHCR
                       │
                       ▼
                  🔐 SSH Deploy
                       │
                       ▼
                  ☁️ AWS EC2
                       │
                       ▼
                 🐳 Docker
                       │
                       ▼
                 🤖 MCP Server

⚙️ GitHub Actions

The pipeline automatically executes when code is pushed to the main branch.

Pipeline Stages

Checkout
   ↓
Setup Python
   ↓
Install Dependencies
   ↓
Run Tests
   ↓
Build Docker Image
   ↓
Login to GHCR
   ↓
Push Docker Image
   ↓
Connect to EC2
   ↓
Pull Latest Image
   ↓
Stop Old Container
   ↓
Start New Container

🔐 GitHub Secrets

Configure secrets under:

Repository
    ↓
Settings
    ↓
Secrets and variables
    ↓
Actions

Required:

EC2_HOST
EC2_USERNAME
EC2_SSH_KEY
GHCR_USERNAME
GHCR_TOKEN

Secrets must never be committed to GitHub.

📦 GitHub Container Registry

Images are stored in GHCR.

Example:

ghcr.io/YOUR_USERNAME/github-mcp-server:latest

Commit-based image:

ghcr.io/YOUR_USERNAME/github-mcp-server:<commit-sha>

This provides versioned and reproducible container deployments.

🧪 Testing

Python Syntax Test

python -m py_compile server.py

Docker Build Test

docker build -t github-mcp-server .

Container Test

docker ps

Log Verification

docker logs mcp-server

🔎 MCP Tool Verification

Connect an MCP-compatible client or MCP Inspector to:

http://localhost:8000/mcp

Verify tool discovery:

✓ get_repository_info
✓ list_issues
✓ get_workflow_status

🔐 Security

Security is critical because MCP servers can provide AI applications with access to external systems.

🔑 Secret Management

Never hard-code:

GitHub Tokens
AWS Credentials
SSH Keys
API Keys
Passwords

Use:

GitHub Secrets
Environment Variables
AWS Secrets Manager

🛡️ Least Privilege

GitHub tokens should only receive the permissions required by the MCP tools.

Prefer read-only permissions when write operations are not required.

🚫 Avoid Dangerous Tools

Avoid unrestricted operations such as:

delete_repository()
delete_branch()
merge_pull_request()
create_deployment()

unless proper authorization and confirmation are implemented.

🌐 Network Security

Restrict EC2 access.

Recommended:

SSH
Port 22
Source: Your IP/32

For production MCP access:

HTTPS
Port 443
Source: Authorized Clients

🧠 Prompt Injection Protection

GitHub issues, comments, pull requests, and repository content may contain untrusted instructions.

External content should be treated as data, not automatically as trusted instructions.

📊 Deployment Verification

After making changes:

git add .
git commit -m "Update MCP server"
git push origin main

GitHub Actions:

🧪 Test        → ✅ Passed
🐳 Docker Build → ✅ Passed
📦 GHCR Push   → ✅ Passed
☁️ EC2 Deploy  → ✅ Passed

EC2:

docker ps

Logs:

docker logs mcp-server

🔁 End-to-End Workflow

                    ┌─────────────────┐
                    │    Developer    │
                    └────────┬────────┘
                             │
                         git push
                             │
                             ▼
                    ┌─────────────────┐
                    │     GitHub      │
                    └────────┬────────┘
                             │
                             ▼
                    ┌─────────────────┐
                    │ GitHub Actions  │
                    └────────┬────────┘
                             │
                   ┌─────────┴─────────┐
                   │                   │
                   ▼                   ▼
                🧪 Test            🐳 Build
                   │                   │
                   └─────────┬─────────┘
                             │
                             ▼
                    ┌─────────────────┐
                    │      GHCR       │
                    └────────┬────────┘
                             │
                             ▼
                    ┌─────────────────┐
                    │     AWS EC2     │
                    └────────┬────────┘
                             │
                             ▼
                    ┌─────────────────┐
                    │ Docker Container│
                    └────────┬────────┘
                             │
                             ▼
                    ┌─────────────────┐
                    │   MCP Server    │
                    └────────┬────────┘
                             │
                             ▼
                    ┌─────────────────┐
                    │  GitHub API     │
                    └─────────────────┘

📚 MCP Concepts Covered

Concept

Description

MCP Client

Connects AI applications to MCP servers

MCP Server

Exposes capabilities to MCP clients

Tools

Executable functions

Resources

Data/context exposed to clients

Prompts

Reusable interaction templates

Transport

Communication mechanism

Tool Discovery

Client discovers available tools

Tool Invocation

Client calls a selected tool

🚀 Key DevOps Practices

                 SOURCE CONTROL
                       │
                       ▼
                     GIT
                       │
                       ▼
                 CI/CD PIPELINE
                       │
                       ▼
                 AUTOMATED TEST
                       │
                       ▼
                 DOCKER BUILD
                       │
                       ▼
               CONTAINER REGISTRY
                       │
                       ▼
                CLOUD DEPLOYMENT
                       │
                       ▼
                 RUNTIME SECRETS
                       │
                       ▼
                    SECURITY

✨ Project Highlights

  • 🤖 Custom MCP server built with Python

  • 🐙 GitHub REST API integration

  • 🛠️ Three reusable MCP tools

  • 🌐 Streamable HTTP transport

  • 🐳 Docker containerization

  • 📦 GitHub Container Registry

  • ☁️ AWS EC2 deployment

  • ⚙️ GitHub Actions CI/CD

  • 🔐 Secure secret management

  • 🛡️ Least-privilege access

  • 🔄 Automated deployment

  • 🧪 Automated validation

  • 📊 GitHub workflow monitoring

🔮 Future Enhancements

HTTPS
  ↓
Custom Domain
  ↓
AWS ALB
  ↓
AWS Secrets Manager
  ↓
Amazon ECR
  ↓
Amazon ECS
  ↓
Kubernetes
  ↓
Terraform
  ↓
Prometheus
  ↓
Grafana

Potential MCP improvements:

  • 🔍 Repository search

  • 🔀 Pull request management

  • 📝 Create GitHub issues

  • 💬 Pull request comments

  • 🏷️ GitHub label management

  • 🔐 Authentication and authorization

  • 🚦 Rate limiting

  • 📊 Monitoring and observability

  • 🛡️ Container vulnerability scanning

🏆 Skills Demonstrated

Model Context Protocol
Python
GitHub REST API
Docker
AWS EC2
GitHub Actions
GHCR
Linux
Git
CI/CD
REST APIs
Cloud Security
Containerization
Automation

📈 Learning Outcomes

By completing this project, the following concepts were implemented and understood:

  • Model Context Protocol

  • MCP Client and Server architecture

  • MCP Tools

  • MCP Resources

  • MCP Prompts

  • Tool discovery

  • Tool invocation

  • GitHub API integration

  • Python MCP development

  • Streamable HTTP

  • Docker containerization

  • GHCR

  • AWS EC2

  • GitHub Actions

  • CI/CD automation

  • Secret management

  • Cloud security

  • Automated deployment

💼 Resume Project Description

MCP GitHub Automation Server | Python, MCP, Docker, AWS EC2, GitHub Actions

Developed and deployed a Python-based Model Context Protocol server for GitHub automation, exposing tools for repository information, issue retrieval, and GitHub Actions workflow monitoring. Containerized the application using Docker, published images to GitHub Container Registry, deployed on AWS EC2, and implemented GitHub Actions CI/CD for automated testing, image publishing, and remote deployment. Applied secure credential management, least-privilege access, and cloud network security practices.

👨‍💻 Author

Venu Gopala Reddy Eppala

Cloud & DevOps Engineer

This server cannot be installed

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd
F
license - not found
Not graded
quality - not tested
B
maintenance

How are these scores calculated?

Maintenance

–Maintainers
–Response time
–Release cycle
–Releases (12mo)
Commit activity

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

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

Related MCP Servers

  • GitHub MCP Server

    pipseedai
    A
    license
    A
    quality
    Not graded
    maintenance
    Enables AI agents to interact with GitHub repositories through the GitHub REST API for managing files, issues, and repository metadata. It supports both read operations like searching code and write operations such as creating repositories and updating issue comments.
    9

  • GitHubMcpServer

    moksh555
    F
    license
    Not graded
    quality
    D
    maintenance
    Exposes GitHub REST API operations as AI-ready tools for managing repositories, tracking push history, and updating settings. It enables LLM agents to perform tasks like creating repositories, retrieving metadata, and monitoring branch activity through a standardized interface.

View all related MCP servers

Related MCP Connectors

  • GitHub

    Connect AI assistants to GitHub - manage repos, issues, PRs, and workflows through natural language.

  • Hint-Services-obsidian-github-mcp

    Connect AI assistants to your GitHub-hosted Obsidian vault to seamlessly access, search, and analy…

  • GitLumen MCP

    Screens public GitHub repos and PRs to generate risk maps, findings, and merge-readiness signals.

View all MCP Connectors

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/venugopalareddy46/github-mcp-server'

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