mcpField
B
Bounteous MCP Server

Bounteous MCP Server

Local
github.com/ravi-accoliteVersion Control0Updated 80w ago
Repository

About Bounteous MCP Server

Bounteous MCP Server connects LLM applications with GitHub and GitLab for repository and project operations. It supports issue and review workflows, search, branch management, and file operations.

Key features

  1. 01GitHub repository and issue operations
  2. 02GitLab project and issue operations
  3. 03Pull and merge request handling
  4. 04Code and repository search
  5. 05Branch and file management
  6. 06Batch operations and branch creation

Use cases

  1. 01Reviewing and managing GitHub pull requests
  2. 02Handling GitLab issues and merge requests
  3. 03Searching code and repositories
  4. 04Managing branches and repository files

MCP support

It exposes GitHub and GitLab version-control operations to MCP clients, including repository, issue, review, search, branch, and file capabilities.

Configuration

Local server config is the same for every client. Copy it into your client’s MCP config file.

mcp.json · Universal config
{
  "mcpServers": {
    "mcpserver-ravi-accolite": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "build"
      ]
    }
  }
}
Run commanddocker run -i --rm build

Local servers need a runtime on your machine (e.g. Node.js 18+). Config file locations differ by client; see your client’s docs.

Packages
ocibuild

Tools

No tool list yet

Local servers expose tools only once running on your machine, and the maintainer has not provided a tool list.

Details

From the project README

Bounteous MCP Server

A Model Context Protocol (MCP) server implementation for Bounteous organization, enabling seamless integration between LLM applications and version control systems (GitHub and GitLab).

Overview

This MCP server provides a standardized way to connect Large Language Models (LLMs) with version control systems, enabling powerful automation and integration capabilities. Built following the Model Context Protocol specifications.

Features

Version Control Integration

  • GitHub Integration

    • Repository management
    • Issue tracking
    • Pull request handling
    • Code review workflows
    • Advanced search capabilities
    • Branch management
    • File operations

  • GitLab Integration

    • Project management
    • Issue tracking
    • Merge request handling
    • Code review workflows
    • Repository operations
    • Branch management
    • File operations
Common Features
  • Automatic branch creation
  • Comprehensive error handling
  • Git history preservation
  • Batch operations support
  • File and directory management
  • Code search capabilities

Getting Started

Prerequisites
  • Node.js (v16 or higher)
  • npm or yarn package manager
  • GitLab or GitHub account with appropriate permissions
  • Personal Access Token for the respective service
Installation
  1. Clone the repository:
git clone https://github.com/ravi-accolite/mcpserver.git
cd mcpserver
  1. Install dependencies:
npm install
# or
yarn install
  1. Configure environment variables:
cp .env.example .env
# Edit .env with your configuration
Usage
Docker
# Build and run GitHub MCP Server
docker build -t mcp/github -f packages/bounteous-hulk/src/github/Dockerfile .
docker run -e GITHUB_PERSONAL_ACCESS_TOKEN=<your_token> mcp/github

# Build and run GitLab MCP Server
docker build -t mcp/gitlab -f packages/bounteous-hulk/src/gitlab/Dockerfile .
docker run -e GITLAB_PERSONAL_ACCESS_TOKEN=<your_token> -e GITLAB_API_URL=https://gitlab.com/api/v4 mcp/gitlab
NPX
# Run GitHub MCP Server
npx -y bounteous-hulk --github-token <your_token>

# Run GitLab MCP Server
npx -y bounteous-hulk --gitlab-token <your_token> --gitlab-api-url https://gitlab.com/api/v4
Configuration (Local Setup)

Add the following to your .cursor/mcp.json (project level mcp server) or global level:

{
    "mcpServers": {
        "bounteous-hulk": {
            "command": "node",
            "args": [
                "<ABSOLUTE_PATH>/mcpserver/packages/bounteous-hulk/dist/index.js"
            ],
            "env": {
                "GITHUB_PERSONAL_ACCESS_TOKEN": "<GITHUB_TOKEN>",
                "VERSION_CONTROL": "<OPTION>",
                "GITLAB_PERSONAL_ACCESS_TOKEN": "<GITLAB_TOKEN>",
                "GITLAB_API_URL": "<API_URL>"
            }
        }
    }
}

Different VERSION_CONTROL value possible: github, gitlab

Configuration with Docker

Add the following to your claude_desktop_config.json:

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "mcp/github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>"
      }
    },
    "gitlab": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "GITLAB_PERSONAL_ACCESS_TOKEN",
        "-e",
        "GITLAB_API_URL",
        "mcp/gitlab"
      ],
      "env": {
        "GITLAB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>",
        "GITLAB_API_URL": "https://gitlab.com/api/v4"
      }
    }
  }
}

Documentation

Detailed documentation for each MCP server is available in their respective directories:

Contributing

  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add some amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request

License

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

Acknowledgments

  • Built using the Model Context Protocol specification
  • Inspired by the MCP reference implementation and community servers

Support

For support and questions, please create an issue in the repository or contact the Bounteous development team.

Built with ❤️ by Bounteous Development Team

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.