From e0ce7fc5ebd27404ad163e423625092a58160f9e Mon Sep 17 00:00:00 2001 From: Atharva Patil <53966412+atharva1051@users.noreply.github.com> Date: Fri, 23 Jan 2026 10:57:03 +0000 Subject: [PATCH 1/8] feat: http mode for centralized deployments --- Dockerfile | 3 + README.md | 213 ++++++++++++++++++++++++++++++++++ cmd/github-mcp-server/main.go | 53 +++++++++ internal/ghmcp/server.go | 180 ++++++++++++++++++++++++++++ 4 files changed, 449 insertions(+) diff --git a/Dockerfile b/Dockerfile index 9d68a985a..6b3c3ce93 100644 --- a/Dockerfile +++ b/Dockerfile @@ -22,6 +22,9 @@ FROM gcr.io/distroless/base-debian12 # Add required MCP server annotation LABEL io.modelcontextprotocol.server.name="io.github.github/github-mcp-server" +# Expose port 8080 for HTTP mode +EXPOSE 8080 + # Set the working directory WORKDIR /server # Copy the binary from the build stage diff --git a/README.md b/README.md index d3220f2e6..248be3c72 100644 --- a/README.md +++ b/README.md @@ -266,6 +266,219 @@ the hostname for GitHub Enterprise Server or GitHub Enterprise Cloud with data r } ``` +### HTTP Server Mode + +The GitHub MCP Server supports HTTP mode for serving multiple concurrent clients with per-request authentication. This is ideal for enterprise deployments where a centralized MCP server serves multiple users or applications. + +#### Starting the HTTP Server + +Start the HTTP server with the `http` command: + +```bash +# Start HTTP server on default port (8080) +github-mcp-server http + +# Start HTTP server on custom port +github-mcp-server http --port 3000 + +# With Docker +docker run -p 8080:8080 ghcr.io/github/github-mcp-server http + +# With Docker on custom port +docker run -p 3000:3000 ghcr.io/github/github-mcp-server http --port 3000 +``` + +> **Note:** Unlike stdio mode, HTTP mode does not require a `GITHUB_PERSONAL_ACCESS_TOKEN` environment variable at startup. Instead, each client provides their token via the `Authorization` header. +#### Authentication with Authorization Header + +Clients authenticate by including their GitHub Personal Access Token in the `Authorization` header of each request: + +``` +Authorization: Bearer ghp_your_github_token_here +``` + +This "Bring Your Own Token" (BYOT) approach enables: +- **Multi-tenancy**: Different users can use their own tokens with proper permissions +- **Security**: Tokens are never stored on the server +- **Flexibility**: Users can revoke/rotate tokens independently + +#### Client Configuration Examples + +##### VS Code with GitHub Copilot + +Configure VS Code to connect to your HTTP server by adding the following to your VS Code MCP settings (`.vscode/settings.json` or user settings): + +```json +{ + "servers": { + "github-http": { + "type": "http", + "url": "http://your-mcp-server.example.com:8080", + "headers": { + "Authorization": "Bearer ${input:github_token}" + } + } + }, + "inputs": [ + { + "type": "promptString", + "id": "github_token", + "description": "GitHub Personal Access Token", + "password": true + } + ] +} +``` + +VS Code will prompt for the `github_token` input when connecting. + + + +> **Security Note:** When using hardcoded tokens in configuration files, ensure proper file permissions (e.g., `chmod 600`) to protect your token. +##### Other MCP Clients + +For other MCP clients that support HTTP transport, ensure they: +1. Connect to the server's HTTP endpoint (e.g., `http://localhost:8080`) +2. Include the `Authorization: Bearer ` header in all requests +3. Use the MCP streamable HTTP transport protocol + +Example with curl for testing: + +```bash +# Test server health (this should fail without proper MCP request structure) +curl -H "Authorization: Bearer ghp_your_token" http://localhost:8080 + +# Proper MCP client implementation required for actual tool calls +``` + +#### Docker Deployment + +##### Basic HTTP Server + +Run the HTTP server in Docker with port mapping: + +```bash +docker run -d \ + --name github-mcp-http \ + -p 8080:8080 \ + ghcr.io/github/github-mcp-server http +``` + +##### With Logging + +Enable file logging for debugging: + +```bash +docker run -d \ + --name github-mcp-http \ + -p 8080:8080 \ + -v $(pwd)/logs:/logs \ + ghcr.io/github/github-mcp-server http --log-file /logs/server.log +``` + +##### With Custom Configuration + +Use additional flags for configuration: + +```bash +docker run -d \ + --name github-mcp-http \ + -p 8080:8080 \ + ghcr.io/github/github-mcp-server http \ + --port 8080 \ + --toolsets actions,issues,pull_requests \ + --read-only \ + --log-file /var/log/github-mcp.log +``` + +##### Production Deployment with Docker Compose + +Create a `docker-compose.yml` file: + +```yaml +version: '3.8' +services: + github-mcp-server: + image: ghcr.io/github/github-mcp-server + command: http --port 8080 --log-file /logs/server.log + ports: + - "8080:8080" + volumes: + - ./logs:/logs + restart: unless-stopped + healthcheck: + test: ["CMD", "wget", "--spider", "http://localhost:8080"] + interval: 30s + timeout: 10s + retries: 3 +``` +Then start with: +```bash +docker-compose up -d +``` + +#### GitHub Enterprise Support + +HTTP mode works with GitHub Enterprise Server and GitHub Enterprise Cloud with data residency: + +```bash +# GitHub Enterprise Server +docker run -d \ + -p 8080:8080 \ + ghcr.io/github/github-mcp-server http \ + --gh-host https://github.yourcompany.com \ + --port 8080 + +# GitHub Enterprise Cloud with data residency +docker run -d \ + -p 8080:8080 \ + ghcr.io/github/github-mcp-server http \ + --gh-host https://octocorp.ghe.com \ + --port 8080 +``` + +Clients still provide their tokens via the `Authorization` header. + +#### Security Considerations + +When deploying the HTTP server: + +1. **Use HTTPS in Production**: Always use a reverse proxy (nginx, Caddy, etc.) to terminate TLS +2. **Network Security**: + - Bind to localhost (`127.0.0.1`) for local-only access + - Use firewalls to restrict access to trusted networks + - Consider VPN or IP allowlisting for remote deployments +3. **Token Management**: + - Tokens are validated per-request and never stored + - Use fine-grained tokens with minimum required permissions + - Rotate tokens regularly +4. **Rate Limiting**: Consider adding rate limiting at the reverse proxy level +5. **Monitoring**: Enable logging to track usage and potential security issues + +#### Troubleshooting HTTP Mode + +**Server won't start:** +- Check if port 8080 (or your custom port) is already in use +- Ensure Docker port mapping is correct (`-p host_port:container_port`) + +**Client connection fails:** +- Verify the server is running: `curl http://localhost:8080` (should return an error but connect) +- Check firewall rules allow connections to the port +- Verify the URL in client configuration matches the server address + +**Authentication errors:** +- Ensure the `Authorization` header is properly formatted: `Bearer ` +- Verify the GitHub token is valid and not expired +- Check token has required permissions for the operations being performed + +**Enable debug logging:** +```bash +github-mcp-server http --log-file debug.log +# Or with Docker: +docker run -p 8080:8080 -v $(pwd):/logs \ + ghcr.io/github/github-mcp-server http --log-file /logs/debug.log +``` + ## Installation ### Install in GitHub Copilot on VS Code diff --git a/cmd/github-mcp-server/main.go b/cmd/github-mcp-server/main.go index 27bffaff8..f8f862bf8 100644 --- a/cmd/github-mcp-server/main.go +++ b/cmd/github-mcp-server/main.go @@ -89,6 +89,54 @@ var ( return ghmcp.RunStdioServer(stdioServerConfig) }, } + + httpCmd = &cobra.Command{ + Use: "http", + Short: "Start HTTP server", + Long: `Start an HTTP server that supports multiple concurrent clients with per-request authentication.`, + RunE: func(_ *cobra.Command, _ []string) error { + // Parse toolsets + var enabledToolsets []string + if viper.IsSet("toolsets") { + if err := viper.UnmarshalKey("toolsets", &enabledToolsets); err != nil { + return fmt.Errorf("failed to unmarshal toolsets: %w", err) + } + } + + // Parse tools + var enabledTools []string + if viper.IsSet("tools") { + if err := viper.UnmarshalKey("tools", &enabledTools); err != nil { + return fmt.Errorf("failed to unmarshal tools: %w", err) + } + } + + // Parse enabled features + var enabledFeatures []string + if viper.IsSet("features") { + if err := viper.UnmarshalKey("features", &enabledFeatures); err != nil { + return fmt.Errorf("failed to unmarshal features: %w", err) + } + } + + ttl := viper.GetDuration("repo-access-cache-ttl") + httpServerConfig := ghmcp.HTTPServerConfig{ + Version: version, + Host: viper.GetString("host"), + Port: viper.GetInt("port"), + EnabledToolsets: enabledToolsets, + EnabledTools: enabledTools, + EnabledFeatures: enabledFeatures, + DynamicToolsets: viper.GetBool("dynamic_toolsets"), + ReadOnly: viper.GetBool("read-only"), + LogFilePath: viper.GetString("log-file"), + ContentWindowSize: viper.GetInt("content-window-size"), + LockdownMode: viper.GetBool("lockdown-mode"), + RepoAccessCacheTTL: &ttl, + } + return ghmcp.RunHTTPServer(httpServerConfig) + }, + } ) func init() { @@ -127,8 +175,13 @@ func init() { _ = viper.BindPFlag("insider-mode", rootCmd.PersistentFlags().Lookup("insider-mode")) _ = viper.BindPFlag("repo-access-cache-ttl", rootCmd.PersistentFlags().Lookup("repo-access-cache-ttl")) + // Add HTTP-specific flags + httpCmd.Flags().Int("port", 8080, "Port to listen on for HTTP server") + _ = viper.BindPFlag("port", httpCmd.Flags().Lookup("port")) + // Add subcommands rootCmd.AddCommand(stdioCmd) + rootCmd.AddCommand(httpCmd) } func initConfig() { diff --git a/internal/ghmcp/server.go b/internal/ghmcp/server.go index 9e7dafcae..f8bc4e8c9 100644 --- a/internal/ghmcp/server.go +++ b/internal/ghmcp/server.go @@ -344,6 +344,48 @@ type StdioServerConfig struct { RepoAccessCacheTTL *time.Duration } +type HTTPServerConfig struct { + // Version of the server + Version string + + // GitHub Host to target for API requests (e.g. github.com or github.enterprise.com) + Host string + + // Port to listen on + Port int + + // EnabledToolsets is a list of toolsets to enable + // See: https://github.com/github/github-mcp-server?tab=readme-ov-file#tool-configuration + EnabledToolsets []string + + // EnabledTools is a list of specific tools to enable (additive to toolsets) + // When specified, these tools are registered in addition to any specified toolset tools + EnabledTools []string + + // EnabledFeatures is a list of feature flags that are enabled + // Items with FeatureFlagEnable matching an entry in this list will be available + EnabledFeatures []string + + // Whether to enable dynamic toolsets + // See: https://github.com/github/github-mcp-server?tab=readme-ov-file#dynamic-tool-discovery + DynamicToolsets bool + + // ReadOnly indicates if we should only register read-only tools + ReadOnly bool + + // Path to the log file if not stderr + LogFilePath string + + // Content window size + ContentWindowSize int + + // LockdownMode indicates if we should enable lockdown mode + LockdownMode bool + + // RepoAccessCacheTTL overrides the default TTL for repository access cache entries. + RepoAccessCacheTTL *time.Duration +} + // RunStdioServer is not concurrent safe. func RunStdioServer(cfg StdioServerConfig) error { // Create app context @@ -699,3 +741,141 @@ func fetchTokenScopesForHost(ctx context.Context, token, host string) ([]string, return fetcher.FetchTokenScopes(ctx, token) } + +// extractTokenFromAuthHeader extracts a GitHub token from the Authorization header. +// It supports "Bearer " format. +func extractTokenFromAuthHeader(req *http.Request) string { + authHeader := req.Header.Get("Authorization") + if authHeader == "" { + return "" + } + + // Check for "Bearer " prefix + const bearerPrefix = "Bearer " + if strings.HasPrefix(authHeader, bearerPrefix) { + return strings.TrimPrefix(authHeader, bearerPrefix) + } + + return "" +} + +// RunHTTPServer starts the HTTP server for multi-client MCP connections. +func RunHTTPServer(cfg HTTPServerConfig) error { + // Create app context + ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) + defer stop() + + t, _ := translations.TranslationHelper() + + // Set up logging + var slogHandler slog.Handler + var logOutput io.Writer + if cfg.LogFilePath != "" { + file, err := os.OpenFile(cfg.LogFilePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0600) + if err != nil { + return fmt.Errorf("failed to open log file: %w", err) + } + defer file.Close() + logOutput = file + slogHandler = slog.NewTextHandler(logOutput, &slog.HandlerOptions{Level: slog.LevelDebug}) + } else { + logOutput = os.Stderr + slogHandler = slog.NewTextHandler(logOutput, &slog.HandlerOptions{Level: slog.LevelInfo}) + } + logger := slog.New(slogHandler) + logger.Info("starting HTTP server", + "version", cfg.Version, + "host", cfg.Host, + "port", cfg.Port, + "dynamicToolsets", cfg.DynamicToolsets, + "readOnly", cfg.ReadOnly, + "lockdownEnabled", cfg.LockdownMode) + + // Create HTTP handler with per-request server creation + handler := mcp.NewStreamableHTTPHandler(func(req *http.Request) *mcp.Server { + // Extract token from Authorization header + token := extractTokenFromAuthHeader(req) + if token == "" { + logger.Warn("request without valid Authorization header", "path", req.URL.Path) + return nil // This will cause a 400 Bad Request + } + + // Fetch token scopes for scope-based tool filtering (PAT tokens only) + var tokenScopes []string + if strings.HasPrefix(token, "ghp_") { + fetchedScopes, err := fetchTokenScopesForHost(req.Context(), token, cfg.Host) + if err != nil { + logger.Warn("failed to fetch token scopes, continuing without scope filtering", "error", err) + } else { + tokenScopes = fetchedScopes + logger.Debug("token scopes fetched for filtering", "scopes", tokenScopes) + } + } + + // Create a new server instance for this request with the extracted token + ghServer, err := NewMCPServer(MCPServerConfig{ + Version: cfg.Version, + Host: cfg.Host, + Token: token, + EnabledToolsets: cfg.EnabledToolsets, + EnabledTools: cfg.EnabledTools, + EnabledFeatures: cfg.EnabledFeatures, + DynamicToolsets: cfg.DynamicToolsets, + ReadOnly: cfg.ReadOnly, + Translator: t, + ContentWindowSize: cfg.ContentWindowSize, + LockdownMode: cfg.LockdownMode, + Logger: logger, + RepoAccessTTL: cfg.RepoAccessCacheTTL, + TokenScopes: tokenScopes, + }) + if err != nil { + logger.Error("failed to create MCP server", "error", err) + return nil + } + + return ghServer + }, &mcp.StreamableHTTPOptions{ + Logger: logger, + SessionTimeout: 30 * time.Second, // 30 second heartbeat interval + }) + + // Create HTTP server + addr := fmt.Sprintf(":%d", cfg.Port) + httpServer := &http.Server{ + Addr: addr, + Handler: handler, + ReadHeaderTimeout: 10 * time.Second, + } + + // Start server in goroutine + errC := make(chan error, 1) + go func() { + logger.Info("HTTP server listening", "addr", addr) + if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed { + errC <- fmt.Errorf("HTTP server error: %w", err) + } + }() + + // Wait for shutdown signal + select { + case <-ctx.Done(): + logger.Info("shutting down HTTP server", "signal", "context done") + case err := <-errC: + if err != nil { + logger.Error("HTTP server error", "error", err) + return err + } + } + + // Graceful shutdown + shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + if err := httpServer.Shutdown(shutdownCtx); err != nil { + logger.Error("error during HTTP server shutdown", "error", err) + return fmt.Errorf("HTTP server shutdown error: %w", err) + } + + logger.Info("HTTP server stopped") + return nil +} From 6a67839bcfe8bb8ac9f19a62a2a1e57b27193b20 Mon Sep 17 00:00:00 2001 From: Atharva Patil <53966412+atharva1051@users.noreply.github.com> Date: Sun, 25 Jan 2026 22:25:10 +0530 Subject: [PATCH 2/8] fix: Read/Write/Idle Timeout Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- internal/ghmcp/server.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/internal/ghmcp/server.go b/internal/ghmcp/server.go index f8bc4e8c9..04c4599c2 100644 --- a/internal/ghmcp/server.go +++ b/internal/ghmcp/server.go @@ -846,6 +846,9 @@ func RunHTTPServer(cfg HTTPServerConfig) error { Addr: addr, Handler: handler, ReadHeaderTimeout: 10 * time.Second, + ReadTimeout: 30 * time.Second, + WriteTimeout: 30 * time.Second, + IdleTimeout: 120 * time.Second, } // Start server in goroutine From 745b2b422edd416268eb612872c34a68ce928f72 Mon Sep 17 00:00:00 2001 From: Atharva Patil <53966412+atharva1051@users.noreply.github.com> Date: Sun, 25 Jan 2026 22:26:28 +0530 Subject: [PATCH 3/8] fix: indentation Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 248be3c72..31a500858 100644 --- a/README.md +++ b/README.md @@ -310,16 +310,16 @@ Configure VS Code to connect to your HTTP server by adding the following to your ```json { - "servers": { - "github-http": { + "servers": { + "github-http": { "type": "http", "url": "http://your-mcp-server.example.com:8080", "headers": { "Authorization": "Bearer ${input:github_token}" } } - }, - "inputs": [ + }, + "inputs": [ { "type": "promptString", "id": "github_token", From 9f6f33797e54a3e51650bde3f51c5325d9e40412 Mon Sep 17 00:00:00 2001 From: Atharva Patil <53966412+atharva1051@users.noreply.github.com> Date: Sun, 25 Jan 2026 22:27:35 +0530 Subject: [PATCH 4/8] fix: insider mode Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- internal/ghmcp/server.go | 1 + 1 file changed, 1 insertion(+) diff --git a/internal/ghmcp/server.go b/internal/ghmcp/server.go index 04c4599c2..5b06d31b9 100644 --- a/internal/ghmcp/server.go +++ b/internal/ghmcp/server.go @@ -828,6 +828,7 @@ func RunHTTPServer(cfg HTTPServerConfig) error { Logger: logger, RepoAccessTTL: cfg.RepoAccessCacheTTL, TokenScopes: tokenScopes, + InsiderMode: cfg.InsiderMode, }) if err != nil { logger.Error("failed to create MCP server", "error", err) From 79635e49ba54d4126a7554cf92d90a121500fee3 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Sun, 25 Jan 2026 16:57:57 +0000 Subject: [PATCH 5/8] Initial plan From dd552047167e30c333fec898cb09a49903fc0ccc Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Sun, 25 Jan 2026 17:01:42 +0000 Subject: [PATCH 6/8] feat: add InsiderMode support to HTTP mode Add InsiderMode field to HTTPServerConfig and pass it from CLI flags. This ensures that the --insider-mode flag works for HTTP mode just like it does for stdio mode, enabling experimental features when set. Co-authored-by: atharva1051 <53966412+atharva1051@users.noreply.github.com> --- cmd/github-mcp-server/main.go | 1 + internal/ghmcp/server.go | 3 +++ 2 files changed, 4 insertions(+) diff --git a/cmd/github-mcp-server/main.go b/cmd/github-mcp-server/main.go index f8f862bf8..df83e67c7 100644 --- a/cmd/github-mcp-server/main.go +++ b/cmd/github-mcp-server/main.go @@ -132,6 +132,7 @@ var ( LogFilePath: viper.GetString("log-file"), ContentWindowSize: viper.GetInt("content-window-size"), LockdownMode: viper.GetBool("lockdown-mode"), + InsiderMode: viper.GetBool("insider-mode"), RepoAccessCacheTTL: &ttl, } return ghmcp.RunHTTPServer(httpServerConfig) diff --git a/internal/ghmcp/server.go b/internal/ghmcp/server.go index 5b06d31b9..264e6a5ae 100644 --- a/internal/ghmcp/server.go +++ b/internal/ghmcp/server.go @@ -382,6 +382,9 @@ type HTTPServerConfig struct { // LockdownMode indicates if we should enable lockdown mode LockdownMode bool + // InsiderMode indicates if we should enable experimental features + InsiderMode bool + // RepoAccessCacheTTL overrides the default TTL for repository access cache entries. RepoAccessCacheTTL *time.Duration } From 278e122a4e8ac37714572b5a0d94bb20ec279107 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Sun, 25 Jan 2026 17:03:47 +0000 Subject: [PATCH 7/8] Add InsiderMode support to HTTP server mode Co-authored-by: atharva1051 <53966412+atharva1051@users.noreply.github.com> --- go.mod | 3 --- go.sum | 9 --------- 2 files changed, 12 deletions(-) diff --git a/go.mod b/go.mod index e50f52c72..937a9f2ed 100644 --- a/go.mod +++ b/go.mod @@ -3,7 +3,6 @@ module github.com/github/github-mcp-server go 1.24.0 require ( - github.com/fatih/color v1.18.0 github.com/google/go-github/v79 v79.0.0 github.com/google/jsonschema-go v0.4.2 github.com/josephburnett/jd v1.9.2 @@ -21,8 +20,6 @@ require ( github.com/gorilla/css v1.0.1 // indirect github.com/josharian/intern v1.0.0 // indirect github.com/mailru/easyjson v0.7.7 // indirect - github.com/mattn/go-colorable v0.1.13 // indirect - github.com/mattn/go-isatty v0.0.20 // indirect github.com/stretchr/objx v0.5.2 // indirect github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82 // indirect go.yaml.in/yaml/v3 v3.0.4 // indirect diff --git a/go.sum b/go.sum index 89c8b1dda..b364f2ef3 100644 --- a/go.sum +++ b/go.sum @@ -6,8 +6,6 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM= -github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU= github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k= @@ -53,11 +51,6 @@ github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN github.com/mailru/easyjson v0.7.6/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0= github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= -github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= -github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= -github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= -github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= -github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk= github.com/microcosm-cc/bluemonday v1.0.27/go.mod h1:jFi9vgW+H7c3V0lb6nR74Ib/DIB5OBs92Dimizgw2cA= github.com/modelcontextprotocol/go-sdk v1.2.0 h1:Y23co09300CEk8iZ/tMxIX1dVmKZkzoSBZOpJwUnc/s= @@ -130,9 +123,7 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik= golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= From b28ab64aa222e3e2b88318802fb036bcb81f16ef Mon Sep 17 00:00:00 2001 From: Atharva Patil <53966412+atharva1051@users.noreply.github.com> Date: Sun, 25 Jan 2026 22:44:47 +0530 Subject: [PATCH 8/8] fix: this won't work need health check at lb level Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- README.md | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/README.md b/README.md index 31a500858..6c8fd3efc 100644 --- a/README.md +++ b/README.md @@ -406,11 +406,7 @@ services: volumes: - ./logs:/logs restart: unless-stopped - healthcheck: - test: ["CMD", "wget", "--spider", "http://localhost:8080"] - interval: 30s - timeout: 10s - retries: 3 + # Configure health checks at your load balancer or orchestrator level. ``` Then start with: ```bash