Merge pull request #1048 from dgageot/cagent-mcp-http

Support exposing as a remote MCP server

Author: dgageot

cmd/root/mcp.go

@@ -1,14 +1,19 @@
 package root
 
 import (
+	"fmt"
+
 	"github.com/spf13/cobra"
 
 	"github.com/docker/cagent/pkg/config"
 	"github.com/docker/cagent/pkg/mcp"
+	"github.com/docker/cagent/pkg/server"
 	"github.com/docker/cagent/pkg/telemetry"
 )
 
 type mcpFlags struct {
+	http      bool
+	port      int
 	runConfig config.RuntimeConfig
 }
 
@@ -18,15 +23,18 @@ func newMCPCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "mcp <agent-file>|<registry-ref>",
 		Short: "Start an agent as an MCP (Model Context Protocol) server",
-		Long:  "Start an stdio MCP server that exposes the agent via the Model Context Protocol",
+		Long:  "Start an MCP server that exposes the agent via the Model Context Protocol. By default, uses stdio transport. Use --http to start a streaming HTTP server instead.",
 		Example: `  cagent mcp ./agent.yaml
   cagent mcp ./team.yaml
-  cagent mcp agentcatalog/pirate`,
+  cagent mcp agentcatalog/pirate
+  cagent mcp ./agent.yaml --http --port 8080`,
 		Args:    cobra.ExactArgs(1),
 		GroupID: "server",
 		RunE:    flags.runMCPCommand,
 	}
 
+	cmd.PersistentFlags().BoolVar(&flags.http, "http", false, "Use streaming HTTP transport instead of stdio")
+	cmd.PersistentFlags().IntVar(&flags.port, "port", 0, "Port to listen on when using HTTP transport (default: random available port)")
 	addRuntimeConfigFlags(cmd, &flags.runConfig)
 
 	return cmd
@@ -38,5 +46,14 @@ func (f *mcpFlags) runMCPCommand(cmd *cobra.Command, args []string) error {
 	ctx := cmd.Context()
 	agentFilename := args[0]
 
+	if f.http {
+		ln, err := server.Listen(ctx, fmt.Sprintf(":%d", f.port))
+		if err != nil {
+			return fmt.Errorf("failed to bind to port %d: %w", f.port, err)
+		}
+
+		return mcp.StartHTTPServer(ctx, agentFilename, &f.runConfig, ln)
+	}
+
 	return mcp.StartMCPServer(ctx, agentFilename, &f.runConfig)
 }

pkg/mcp/server.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
+	"net"
+	"net/http"
 
 	"github.com/modelcontextprotocol/go-sdk/mcp"
 
@@ -28,21 +30,71 @@ type ToolOutput struct {
 func StartMCPServer(ctx context.Context, agentFilename string, runConfig *config.RuntimeConfig) error {
 	slog.Debug("Starting MCP server", "agent", agentFilename)
 
-	agentSource, err := config.Resolve(agentFilename)
+	server, cleanup, err := createMCPServer(ctx, agentFilename, runConfig)
 	if err != nil {
 		return err
 	}
+	defer cleanup()
+
+	slog.Debug("MCP server starting with stdio transport")
+
+	if err := server.Run(ctx, &mcp.StdioTransport{}); err != nil {
+		return fmt.Errorf("MCP server error: %w", err)
+	}
+
+	return nil
+}
+
+// StartHTTPServer starts a streaming HTTP MCP server on the given listener
+func StartHTTPServer(ctx context.Context, agentFilename string, runConfig *config.RuntimeConfig, ln net.Listener) error {
+	slog.Debug("Starting HTTP MCP server", "agent", agentFilename, "addr", ln.Addr())
+
+	server, cleanup, err := createMCPServer(ctx, agentFilename, runConfig)
+	if err != nil {
+		return err
+	}
+	defer cleanup()
+
+	fmt.Printf("MCP HTTP server listening on http://%s\n", ln.Addr())
+
+	httpServer := &http.Server{
+		Handler: mcp.NewStreamableHTTPHandler(func(_ *http.Request) *mcp.Server {
+			return server
+		}, nil),
+	}
+
+	errCh := make(chan error, 1)
+	go func() {
+		errCh <- httpServer.Serve(ln)
+	}()
+
+	select {
+	case <-ctx.Done():
+		return httpServer.Shutdown(context.Background())
+	case err := <-errCh:
+		if err == http.ErrServerClosed {
+			return nil
+		}
+		return err
+	}
+}
+
+func createMCPServer(ctx context.Context, agentFilename string, runConfig *config.RuntimeConfig) (*mcp.Server, func(), error) {
+	agentSource, err := config.Resolve(agentFilename)
+	if err != nil {
+		return nil, nil, err
+	}
 
 	t, err := teamloader.Load(ctx, agentSource, runConfig)
 	if err != nil {
-		return fmt.Errorf("failed to load agents: %w", err)
+		return nil, nil, fmt.Errorf("failed to load agents: %w", err)
 	}
 
-	defer func() {
+	cleanup := func() {
 		if err := t.StopToolSets(ctx); err != nil {
 			slog.Error("Failed to stop tool sets", "error", err)
 		}
-	}()
+	}
 
 	server := mcp.NewServer(&mcp.Implementation{
 		Name:    "cagent",
@@ -55,7 +107,8 @@ func StartMCPServer(ctx context.Context, agentFilename string, runConfig *config
 	for _, agentName := range agentNames {
 		ag, err := t.Agent(agentName)
 		if err != nil {
-			return fmt.Errorf("failed to get agent %s: %w", agentName, err)
+			cleanup()
+			return nil, nil, fmt.Errorf("failed to get agent %s: %w", agentName, err)
 		}
 
 		description := ag.Description()
@@ -67,7 +120,8 @@ func StartMCPServer(ctx context.Context, agentFilename string, runConfig *config
 
 		readOnly, err := isReadOnlyAgent(ctx, ag)
 		if err != nil {
-			return fmt.Errorf("failed to determine if agent %s is read-only: %w", agentName, err)
+			cleanup()
+			return nil, nil, fmt.Errorf("failed to determine if agent %s is read-only: %w", agentName, err)
 		}
 
 		toolDef := &mcp.Tool{
@@ -83,13 +137,7 @@ func StartMCPServer(ctx context.Context, agentFilename string, runConfig *config
 		mcp.AddTool(server, toolDef, CreateToolHandler(t, agentName))
 	}
 
-	slog.Debug("MCP server starting with stdio transport")
-
-	if err := server.Run(ctx, &mcp.StdioTransport{}); err != nil {
-		return fmt.Errorf("MCP server error: %w", err)
-	}
-
-	return nil
+	return server, cleanup, nil
 }
 
 func CreateToolHandler(t *team.Team, agentName string) func(context.Context, *mcp.CallToolRequest, ToolInput) (*mcp.CallToolResult, ToolOutput, error) {