Implement HTTP transport using SSE

Signed-off-by: Doğaç Eldenk <dogac@carbonhealth.com>

Author: Doğaç Eldenk

README.md

@@ -61,7 +61,7 @@ go install github.com/f/mcptools/cmd/mcptools@latest
 
 ## Transport Options
 
-MCP currently supports one transport method for communicating with MCP servers:
+MCP currently supports two transport method for communicating with MCP servers:
 
 ### Stdio Transport
 
@@ -72,6 +72,20 @@ useful for command-line tools that implement the MCP protocol.
 mcp tools npx -y @modelcontextprotocol/server-filesystem ~/Code
 ```
 
+### Http SSE Transport
+
+Uses HTTP and Server-Sent Events (SSE) to communicate with an MCP server via JSON-RPC 2.0.
+This is useful for connecting to remote server that implement the MCP protocol.
+
+```
+mcp tools http://127.0.0.1:3001
+
+# As an example, you can use the everything sample server
+# docker run -p 3001:3001 --rm -it tzolov/mcp-everything-server:v1
+```
+
+_Note:_ Currently HTTP SSE supports only MCP protocol version 2024-11-05.
+
 ## Output Formats
 
 MCP supports three output formats:
@@ -202,7 +216,6 @@ mcp shell npx -y @modelcontextprotocol/server-filesystem ~/Code
 
 The following features are planned for future releases:
 
-- HTTP Transport: Add support for connecting to MCP servers over HTTP
 - Authentication: Support for secure authentication mechanisms
 
 ## License

cmd/mcptools/main.go

@@ -96,6 +96,10 @@ func createClient(args []string) (*client.Client, error) {
 		return nil, errCommandRequired
 	}
 
+	if len(args) == 1 && (strings.HasPrefix(args[0], "http://") || strings.HasPrefix(args[0], "https://")) {
+		return client.NewHttp(args[0]), nil
+	}
+
 	return client.NewStdio(args), nil
 }
 
@@ -519,7 +523,11 @@ func newShellCmd() *cobra.Command { //nolint:gocyclo
 				os.Exit(1)
 			}
 
-			mcpClient := client.NewStdio(parsedArgs)
+			mcpClient, clientErr := createClient(parsedArgs)
+			if clientErr != nil {
+				fmt.Fprintf(os.Stderr, "Error: %v\n", clientErr)
+				os.Exit(1)
+			}
 
 			_, listErr := mcpClient.ListTools()
 			if listErr != nil {

pkg/client/client.go

@@ -32,6 +32,13 @@ func NewStdio(command []string) *Client {
 	}
 }
 
+// NewHttp creates a MCP client that communicates with a server via HTTP using JSON-RPC.
+func NewHttp(address string) *Client {
+	return &Client{
+		transport: transport.NewHttp(address),
+	}
+}
+
 // ListTools retrieves the list of available tools from the MCP server.
 func (c *Client) ListTools() (map[string]any, error) {
 	return c.transport.Execute("tools/list", nil)

pkg/transport/http.go

@@ -0,0 +1,161 @@
+package transport
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+	"time"
+)
+
+// Http implements the Transport interface by communicating with a MCP server over HTTP using JSON-RPC.
+type Http struct {
+	address string
+	nextID  int
+	debug   bool
+	eventCh chan string
+}
+
+// NewHttp creates a new Http transport that will execute the given command.
+// It communicates with the command using JSON-RPC over HTTP.
+// Currently Http transport is implements MCP's Final draft version 2024-11-05,
+// https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#http-with-sse
+func NewHttp(address string) *Http {
+	debug := os.Getenv("MCP_DEBUG") == "1"
+
+	_, err := url.ParseRequestURI(address)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "invalid address: %s", err)
+		os.Exit(1)
+	}
+
+	resp, err := http.Get(address + "/sse")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error sending request: %s", err)
+		os.Exit(1)
+	}
+
+	eventCh := make(chan string, 1)
+
+	go func() {
+		defer resp.Body.Close()
+		reader := bufio.NewReader(resp.Body)
+		for {
+			select {
+			default:
+				line, err := reader.ReadString('\n')
+				if err != nil {
+					fmt.Fprintf(os.Stderr, "SSE read error: %s", err)
+					return
+				}
+				line = strings.TrimSpace(line)
+				if debug {
+					fmt.Fprintf(os.Stderr, "DEBUG: Received SSE: %s\n", line)
+				}
+				if strings.HasPrefix(line, "data:") {
+					data := strings.TrimSpace(line[5:])
+					select {
+					case eventCh <- data:
+					default:
+					}
+				}
+			}
+		}
+	}()
+
+	// First event we receive from SSE is the message address. We will use this endpoint to keep
+	// a session alive.
+	var messageAddress string
+	select {
+	case msg := <-eventCh:
+		messageAddress = msg
+	case <-time.After(10 * time.Second):
+		fmt.Errorf("timeout waiting for SSE response")
+		os.Exit(1)
+	}
+
+	return &Http{
+		// Use the SSE message address as the base address for the HTTP transport
+		address: address + messageAddress,
+		nextID:  1,
+		debug:   debug,
+		eventCh: eventCh,
+	}
+}
+
+// Execute implements the Transport via JSON-RPC over HTTP.
+func (t *Http) Execute(method string, params any) (map[string]any, error) {
+	if t.debug {
+		fmt.Fprintf(os.Stderr, "DEBUG: Connecting to server: %s\n", t.address)
+	}
+
+	request := Request{
+		JSONRPC: "2.0",
+		Method:  method,
+		ID:      t.nextID,
+		Params:  params,
+	}
+	t.nextID++
+
+	requestJSON, err := json.Marshal(request)
+	if err != nil {
+		return nil, fmt.Errorf("error marshaling request: %w", err)
+	}
+
+	requestJSON = append(requestJSON, '\n')
+
+	if t.debug {
+		fmt.Fprintf(os.Stderr, "DEBUG: Sending request: %s\n", string(requestJSON))
+	}
+
+	resp, err := http.Post(t.address, "application/json", bytes.NewBuffer(requestJSON))
+	if err != nil {
+		return nil, fmt.Errorf("error sending request: %w", err)
+	}
+
+	if t.debug {
+		fmt.Fprintf(os.Stderr, "DEBUG: Sent request to server\n")
+	}
+
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("error reading response: %w", err)
+	}
+
+	if t.debug {
+		fmt.Fprintf(os.Stderr, "DEBUG: Read from server: %s\n", string(body))
+	}
+
+	if len(body) == 0 {
+		return nil, fmt.Errorf("no response from server")
+	}
+
+	// After sending the request, we listen the SSE channel for the response
+	var response Response
+	select {
+	case msg := <-t.eventCh:
+		if unmarshalErr := json.Unmarshal([]byte(msg), &response); unmarshalErr != nil {
+			return nil, fmt.Errorf("error unmarshaling response: %w, response: %s", unmarshalErr, msg)
+		}
+	case <-time.After(10 * time.Second):
+		fmt.Errorf("timeout waiting for SSE response")
+		os.Exit(1)
+	}
+
+	if response.Error != nil {
+		return nil, fmt.Errorf("RPC error %d: %s", response.Error.Code, response.Error.Message)
+	}
+
+	if t.debug {
+		fmt.Fprintf(os.Stderr, "DEBUG: Successfully parsed response\n")
+	}
+
+	return response.Result, nil
+}