The GitHub MCP Server supports enabling or disabling specific groups of functionalities via the `--toolsets` flag. This allows you to control which GitHub API capabilities are available to your AI tools.

The following sets of tools are available (all are on by default):

| Toolset | Description |

| ----------------------- | ------------------------------------------------------------- |

| `repos` | Repository-related tools (file operations, branches, commits) |

| `issues` | Issue-related tools (create, read, update, comment) |

| `users ` | Anything relating to GitHub Users |

| `pull_requests` | Pull request operations (create, merge, review) |

| `code_security` | Code scanning alerts and security features |

| `experiments` | Experimental features (not considered stable) |

To reduce the available tools, you can pass an allow-list in two ways:

1. **Using Command Line Argument**:

```bash

github-mcp-server --toolsets repos,issues,pull_requests,code_security

```

2. **Using Environment Variable**:

```bash

GITHUB_TOOLSETS="repos,issues,pull_requests,code_security" ./github-mcp-server

```

The environment variable `GITHUB_TOOLSETS` takes precedence over the command line argument if both are provided.

Any toolsets you specify will be enabled from the start, including when `--dynamic-toolsets` is on.

You might want to do this if the model is confused about which tools to call and you only require a subset.

When using Docker, you can pass the toolsets as environment variables:

docker run -i --rm \

-e GITHUB_PERSONAL_ACCESS_TOKEN=<your-token> \

-e GITHUB_TOOLSETS="repos,issues,pull_requests,code_security,experiments" \

ghcr.io/github/github-mcp-server

The special toolset `all` can be provided to enable all available toolsets regardless of any other configuration:

./github-mcp-server --toolsets all

Or using the environment variable:

GITHUB_TOOLSETS="all" ./github-mcp-server

Instead of starting with all tools enabled, you can turn on Dynamic Toolset Discovery.

This feature provides tools that help the MCP Host application to discover and enable sets of GitHub tools only when needed.

This helps to avoid situations where models get confused by the shear number of tools available to them, which varies by model.

When using the binary, you can pass the `--dynamic-toolsets` flag.

./github-mcp-server --dynamic-toolsets

When using Docker, you can pass the toolsets as environment variables:

docker run -i --rm \

-e GITHUB_PERSONAL_ACCESS_TOKEN=<your-token> \

-e GITHUB_DYNAMIC_TOOLSETS=1 \

ghcr.io/github/github-mcp-server

- **search_code** - Search for code across GitHub repositories

enabledToolsets := viper.GetStringSlice("toolsets")

enabledToolsets: enabledToolsets,

rootCmd.PersistentFlags().StringSlice("toolsets", github.DefaultTools, "An optional comma separated list of groups of tools to allow, defaults to enabling all")

rootCmd.PersistentFlags().Bool("dynamic-toolsets", false, "Enable dynamic toolsets")

_ = viper.BindPFlag("toolsets", rootCmd.PersistentFlags().Lookup("toolsets"))

_ = viper.BindPFlag("dynamic_toolsets", rootCmd.PersistentFlags().Lookup("dynamic-toolsets"))

_ = viper.BindPFlag("host", rootCmd.PersistentFlags().Lookup("gh-host"))

viper.SetEnvPrefix("github")

enabledToolsets []string

token := viper.GetString("personal_access_token")

host := viper.GetString("host")

// Create server

ghServer := github.NewServer(version, server.WithHooks(hooks))

enabled := cfg.enabledToolsets

dynamic := viper.GetBool("dynamic_toolsets")

if dynamic {

// filter "all" from the enabled toolsets

enabled = make([]string, 0, len(cfg.enabledToolsets))

for _, toolset := range cfg.enabledToolsets {

if toolset != "all" {

enabled = append(enabled, toolset)

}

}

}

// Create default toolsets

toolsets, err := github.InitToolsets(enabled, cfg.readOnly, getClient, t)

context := github.InitContextToolset(ghServer, getClient, t)

if err != nil {

stdlog.Fatal("Failed to initialize toolsets:", err)

}

// Register resources with the server

github.RegisterResources(ghServer, getClient, t)

// Register the tools with the server

toolsets.RegisterTools(ghServer)

context.RegisterTools(ghServer)

if dynamic {

dynamic := github.InitDynamicToolset(ghServer, toolsets, t)

dynamic.RegisterTools(ghServer)

}

github.com/mark3labs/mcp-go v0.20.1

github.com/mark3labs/mcp-go v0.20.1 h1:E1Bbx9K8d8kQmDZ1QHblM38c7UU2evQ2LlkANk1U/zw=

github.com/mark3labs/mcp-go v0.20.1/go.mod h1:KmJndYv7GIgcPVwEKJjNcbhVQ+hJGJhrCCB/9xITzpE=

package github

import (

"context"

"encoding/json"

"fmt"

"io"

"net/http"

"github.com/github/github-mcp-server/pkg/translations"

"github.com/mark3labs/mcp-go/mcp"

"github.com/mark3labs/mcp-go/server"

)

func GetMe(getClient GetClientFn, t translations.TranslationHelperFunc) (tool mcp.Tool, handler server.ToolHandlerFunc) {

return mcp.NewTool("get_me",

mcp.WithDescription(t("TOOL_GET_ME_DESCRIPTION", "Get details of the authenticated GitHub user. Use this when a request include \"me\", \"my\"...")),

mcp.WithString("reason",

mcp.Description("Optional: reason the session was created"),

),

),

func(ctx context.Context, _ mcp.CallToolRequest) (*mcp.CallToolResult, error) {

client, err := getClient(ctx)

if err != nil {

return nil, fmt.Errorf("failed to get GitHub client: %w", err)

}

user, resp, err := client.Users.Get(ctx, "")

if err != nil {

return nil, fmt.Errorf("failed to get user: %w", err)

}

defer func() { _ = resp.Body.Close() }()

if resp.StatusCode != http.StatusOK {

body, err := io.ReadAll(resp.Body)

if err != nil {

return nil, fmt.Errorf("failed to read response body: %w", err)

}

return mcp.NewToolResultError(fmt.Sprintf("failed to get user: %s", string(body))), nil

}

r, err := json.Marshal(user)

if err != nil {

return nil, fmt.Errorf("failed to marshal user: %w", err)

}

return mcp.NewToolResultText(string(r)), nil

}

}