AdamPippert multi service mcp server

** NOTE: This project is no longer being maintained, as issues with model memory for smaller models means my preferred method for MCP servers is as individual containerized server providers rather than a monolithic routing provider. Code is being kept up in case others still want to try to go down this route.

A modular server that implements the Model Context Protocol standard, providing tools for GitHub, GitLab, Google Maps, Memory storage, and Puppeteer web automation.

The MCP server is built with a modular architecture, where each tool is implemented as a separate module. The server provides a unified gateway that routes requests to the appropriate tool.

• MCP Gateway: A unified endpoint for all tool requests following the MCP standard
• MCP Manifest: An endpoint that describes all available tools and their capabilities
• Direct Tool Access: Each tool can be accessed directly via its own API endpoints
• Modular Design: Easy to add or remove tools as needed

1. GitHub Tool: Interact with GitHub repositories, issues, and search
2. GitLab Tool: Interact with GitLab projects, issues, and pipelines
3. Google Maps Tool: Geocoding, directions, and places search
4. Memory Tool: Store and retrieve data persistently
5. Puppeteer Tool: Take screenshots, generate PDFs, and extract content from websites

• Python 3.8 or higher
• Node.js 14 or higher
• A Red Hat-based Linux distribution (RHEL, CentOS, Fedora) or any Linux/macOS system

1. Clone this repository:

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

2. Install Python dependencies:

   pip install -r requirements.txt

3. Install Node.js dependencies:

   npm install

4. Create a .env file with your configuration:

   SECRET_KEY=your-secret-key
   DEBUG=False
   
   # GitHub configuration
   GITHUB_TOKEN=your-github-token
   
   # GitLab configuration
   GITLAB_TOKEN=your-gitlab-token
   
   # Google Maps configuration
   GMAPS_API_KEY=your-google-maps-api-key
   
   # Memory configuration
   MEMORY_DB_URI=sqlite:///memory.db
   
   # Puppeteer configuration
   PUPPETEER_HEADLESS=true
   CHROME_PATH=/usr/bin/chromium-browser
   

5. Start the server:

   python app.py

You can run the server using either Docker or Podman (Red Hat's container engine).

If you already have Docker and docker-compose installed:

1. Build the Docker image:

   docker build -t mcp-server .

2. Run the container:

   docker run -p 5000:5000 --env-file .env mcp-server

3. Alternatively, use docker-compose:

   Create a docker-compose.yml file:

   version: '3'
   services:
     mcp-server:
       build: .
       ports:
         - "5000:5000"
       volumes:
         - ./data:/app/data
       env_file:
         - .env
       restart: unless-stopped

   Then run:

   docker-compose up -d

For Red Hat based systems (RHEL, CentOS, Fedora) using Podman:

1. Build the container image:

   podman build -t mcp-server .

2. Run the container:

   podman run -p 5000:5000 --env-file .env mcp-server

3. If you need persistent storage:

   mkdir -p ./data
   podman run -p 5000:5000 --env-file .env -v ./data:/app/data:Z mcp-server

   Note: The :Z suffix is important for SELinux-enabled systems.

4. Using Podman Compose (if installed):

   # Install podman-compose if needed
   pip install podman-compose
   
   # Use the same docker-compose.yml file as above
   podman-compose up -d

The MCP Gateway is the main endpoint for accessing all tools using the MCP standard.

Endpoint: POST /mcp/gateway

Request format:

{
  "tool": "github",
  "action": "listRepos",
  "parameters": {
    "username": "octocat"
  }
}

Response format:

{
  "tool": "github",
  "action": "listRepos",
  "status": "success",
  "result": [
    {
      "id": 1296269,
      "name": "Hello-World",
      "full_name": "octocat/Hello-World",
      "owner": {
        "login": "octocat",
        "id": 1
      },
      ...
    }
  ]
}

The MCP Manifest describes all available tools and their capabilities.

Endpoint: GET /mcp/manifest

Response format:

{
  "manifestVersion": "1.0",
  "tools": {
    "github": {
      "actions": {
        "listRepos": {
          "description": "List repositories for a user or organization",
          "parameters": {
            "username": {
              "type": "string",
              "description": "GitHub username or organization name"
            }
          },
          "returns": {
            "type": "array",
            "description": "List of repository objects"
          }
        },
        ...
      }
    },
    ...
  }
}

Each tool can also be accessed directly via its own API endpoints:

• GitHub: /tool/github/...
• GitLab: /tool/gitlab/...
• Google Maps: /tool/gmaps/...
• Memory: /tool/memory/...
• Puppeteer: /tool/puppeteer/...

See the API documentation for each tool for details on the available endpoints.

The GitHub tool provides access to the GitHub API for repositories, issues, and search.

Actions:

• listRepos: List repositories for a user or organization
• getRepo: Get details for a specific repository
• searchRepos: Search for repositories
• getIssues: Get issues for a repository
• createIssue: Create a new issue in a repository

The GitLab tool provides access to the GitLab API for projects, issues, and pipelines.

Actions:

• listProjects: List all projects accessible by the authenticated user
• getProject: Get details for a specific project
• searchProjects: Search for projects on GitLab
• getIssues: Get issues for a project
• createIssue: Create a new issue in a project
• getPipelines: Get pipelines for a project

The Google Maps tool provides access to the Google Maps API for geocoding, directions, and places search.

Actions:

• geocode: Convert an address to geographic coordinates
• reverseGeocode: Convert geographic coordinates to an address
• getDirections: Get directions between two locations
• searchPlaces: Search for places using the Google Places API
• getPlaceDetails: Get details for a specific place

The Memory tool provides a persistent key-value store for storing and retrieving data.

Actions:

• get: Get a memory item by key
• set: Create or update a memory item
• delete: Delete a memory item by key
• list: List all memory items, with optional filtering
• search: Search memory items by value

The Puppeteer tool provides web automation capabilities for taking screenshots, generating PDFs, and extracting content from websites.

Actions:

• screenshot: Take a screenshot of a webpage
• pdf: Generate a PDF of a webpage
• extract: Extract content from a webpage

Contributions are welcome! Here's how you can extend the MCP server:

1. Create a new file in the tools directory, e.g., tools/newtool_tool.py
2. Implement the tool with actions following the same pattern as existing tools
3. Add the tool to the manifest in app.py
4. Register the tool's blueprint in tools/__init__.py

This project is licensed under the MIT License - see the LICENSE file for details.

• Model Context Protocol for the standard specification
• Flask for the web framework
• Puppeteer for web automation