feat(sse): Add remote transport

examples/weather/fetch.go

@@ -2,112 +2,75 @@ package main
 
 import (
 	"encoding/json"
+	"fmt"
 	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-	"time"
 )
 
-type Weather struct {
-	Temperature float64   `json:"temperature"`
-	Conditions  string    `json:"conditions"`
-	Humidity    float64   `json:"humidity"`
-	WindSpeed   float64   `json:"wind_speed"`
-	Timestamp   time.Time `json:"timestamp"`
+func fetch(url string) (*json.RawMessage, error) {
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("User-Agent", "mcp-go-weather/1.0")
+	req.Header.Set("Accept", "application/geo+json")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode >= 300 {
+		return nil, fmt.Errorf("status code: %d", resp.StatusCode)
+	}
+	defer resp.Body.Close()
+	var data json.RawMessage
+	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		return nil, err
+	}
+	return &data, nil
 }
 
-type weatherResponse struct {
-	Main struct {
-		Temp     float64 `json:"temp"`
-		Humidity float64 `json:"humidity"`
-	} `json:"main"`
-	Wind struct {
-		Speed float64 `json:"speed"`
-	} `json:"wind"`
-	Weather []struct {
-		Description string `json:"description"`
-	} `json:"weather"`
+type Points struct {
+	Properties struct {
+		Forecast string `json:"forecast"`
+	} `json:"properties"`
 }
 
-func (s *WeatherServer) fetchWeather(city string) (*Weather, error) {
-	q := url.Values{}
-	q.Set("q", city)
-	q.Set("appid", s.key)
-	q.Set("units", "metric")
-
-	uri := "http://api.openweathermap.org/data/2.5/weather?" + q.Encode()
-	resp, err := http.Get(uri)
+func fetchPoints(lat, lon float64) (*Points, error) {
+	url := fmt.Sprintf("https://api.weather.gov/points/%f,%f", lat, lon)
+	data, err := fetch(url)
 	if err != nil {
 		return nil, err
 	}
-	defer resp.Body.Close()
-
-	var data weatherResponse
-	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+	var points Points
+	if err := json.Unmarshal(*data, &points); err != nil {
 		return nil, err
 	}
-
-	return &Weather{
-		Temperature: data.Main.Temp,
-		Conditions:  data.Weather[0].Description,
-		Humidity:    data.Main.Humidity,
-		WindSpeed:   data.Wind.Speed,
-		Timestamp:   time.Now(),
-	}, nil
+	return &points, nil
 }
 
 type Forecast struct {
-	Date        string  `json:"date"`
-	Temperature float64 `json:"temperature"`
-	Conditions  string  `json:"conditions"`
+	Properties struct {
+		Periods []Period `json:"periods"`
+	} `json:"properties"`
 }
 
-type forecastResponse struct {
-	List []struct {
-		DatetimeText string `json:"dt_txt"`
-		Main         struct {
-			Temp float64 `json:"temp"`
-		} `json:"main"`
-		Weather []struct {
-			Description string `json:"description"`
-		} `json:"weather"`
-	} `json:"list"`
+type Period struct {
+	Name             string  `json:"name"`
+	Temp             float64 `json:"temperature"`
+	TempUnit         string  `json:"temperatureUnit"`
+	WindSpeed        string  `json:"windSpeed"`
+	WindDirection    string  `json:"windDirection"`
+	DetailedForecast string  `json:"detailedForecast"`
 }
 
-func (s *WeatherServer) fetchForecast(city string, days int) ([]Forecast, error) {
-	q := url.Values{}
-	q.Set("q", city)
-	q.Set("cnt", strconv.Itoa(days*8))
-	q.Set("appid", s.key)
-	q.Set("units", "metric")
-
-	uri := "http://api.openweathermap.org/data/2.5/forecast?" + q.Encode()
-	resp, err := http.Get(uri)
+func fetchForecast(url string) (*Forecast, error) {
+	data, err := fetch(url)
 	if err != nil {
 		return nil, err
 	}
-	defer resp.Body.Close()
-
-	var data forecastResponse
-	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+	fmt.Println("forecast", string(*data))
+	var forecast Forecast
+	if err := json.Unmarshal(*data, &forecast); err != nil {
 		return nil, err
 	}
-
-	forecasts := []Forecast{}
-	for i, day_data := range data.List {
-		if i%8 != 0 {
-			continue
-		}
-
-		date, _, _ := strings.Cut(day_data.DatetimeText, " ")
-
-		forecasts = append(forecasts, Forecast{
-			Date:        date,
-			Temperature: day_data.Main.Temp,
-			Conditions:  day_data.Weather[0].Description,
-		})
-	}
-
-	return forecasts, nil
+	return &forecast, nil
 }

examples/weather/main.go

@@ -2,21 +2,20 @@ package main
 
 import (
 	"context"
+	"fmt"
 	"log"
-	"os"
+	"net/http"
 
 	"github.com/riza-io/mcp-go"
-	"github.com/riza-io/mcp-go/stdio"
+	"github.com/riza-io/mcp-go/sse"
 )
 
 type WeatherServer struct {
-	key         string
-	defaultCity string
-
 	mcp.UnimplementedServer
 }
 
 func (s *WeatherServer) Initialize(ctx context.Context, req *mcp.Request[mcp.InitializeRequest]) (*mcp.Response[mcp.InitializeResponse], error) {
+	fmt.Println("Initialize", req.Params.ProtocolVersion)
 	return mcp.NewResponse(&mcp.InitializeResponse{
 		ProtocolVersion: req.Params.ProtocolVersion,
 		Capabilities: mcp.ServerCapabilities{
@@ -29,14 +28,15 @@ func (s *WeatherServer) Initialize(ctx context.Context, req *mcp.Request[mcp.Ini
 func main() {
 	ctx := context.Background()
 
-	if os.Getenv("OPENWEATHER_API_KEY") == "" {
-		log.Fatal("OPENWEATHER_API_KEY environment variable required")
-	}
+	mux := http.NewServeMux()
+
+	server := mcp.NewServer(sse.NewStream(mux, "/sse", "/messages"), &WeatherServer{})
 
-	server := mcp.NewServer(stdio.NewStream(os.Stdin, os.Stdout), &WeatherServer{
-		defaultCity: "London",
-		key:         os.Getenv("OPENWEATHER_API_KEY"),
-	})
+	go func() {
+		if err := http.ListenAndServe(":3009", mux); err != nil {
+			log.Fatal(err)
+		}
+	}()
 
 	if err := server.Listen(ctx); err != nil {
 		log.Fatal(err)

examples/weather/tools.go

@@ -10,31 +10,27 @@ import (
 const getForecastSchema = `{
   "type": "object",
   "properties": {
-    "city": {
-      "type": "string",
-      "description": "City name"
+    "latitude": {
+      "type": "number"
     },
-    "days": {
-      "type": "number",
-      "description": "Number of days (1-5)",
-      "minimum": 1,
-      "maximum": 5
+    "longitude": {
+      "type": "number"
     }
   },
-  "required": ["city"]
+  "required": ["latitude", "longitude"]
 }`
 
 type GetForecastArguments struct {
-	City string `json:"city"`
-	Days int    `json:"days"`
+	Latitude  float64 `json:"latitude"`
+	Longitude float64 `json:"longitude"`
 }
 
 func (s *WeatherServer) ListTools(ctx context.Context, req *mcp.Request[mcp.ListToolsRequest]) (*mcp.Response[mcp.ListToolsResponse], error) {
 	return mcp.NewResponse(&mcp.ListToolsResponse{
 		Tools: []mcp.Tool{
 			{
 				Name:        "get_forecast",
-				Description: "Get weather forecast for a city",
+				Description: "Get weather forecast for a location.",
 				InputSchema: json.RawMessage([]byte(getForecastSchema)),
 			},
 		},
@@ -47,22 +43,25 @@ func (s *WeatherServer) CallTool(ctx context.Context, req *mcp.Request[mcp.CallT
 		return nil, err
 	}
 
-	forecasts, err := s.fetchForecast(args.City, args.Days)
+	points, err := fetchPoints(args.Latitude, args.Longitude)
 	if err != nil {
 		return nil, err
 	}
 
-	text, err := json.MarshalIndent(forecasts, "", "  ")
+	forecast, err := fetchForecast(points.Properties.Forecast)
 	if err != nil {
 		return nil, err
 	}
 
+	content := []mcp.Content{}
+	for _, period := range forecast.Properties.Periods {
+		content = append(content, mcp.Content{
+			Type: "text",
+			Text: period.DetailedForecast,
+		})
+	}
+
 	return mcp.NewResponse(&mcp.CallToolResponse{
-		Content: []mcp.Content{
-			{
-				Type: "text",
-				Text: string(text),
-			},
-		},
+		Content: content,
 	}), nil
 }

go.mod

@@ -1,3 +1,5 @@
 module github.com/riza-io/mcp-go
 
 go 1.23.3
+
+require github.com/google/uuid v1.6.0 // indirect

go.sum

@@ -0,0 +1,2 @@
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=

process.go

@@ -61,8 +61,9 @@ func process[T, V any](ctx context.Context, cfg *base, msg *Message, method func
 
 	if err != nil {
 		return cfg.stream.Send(&Message{
-			ID:      msg.ID,
-			JsonRPC: msg.JsonRPC,
+			Metadata: msg.Metadata,
+			ID:       msg.ID,
+			JsonRPC:  msg.JsonRPC,
 			Error: &ErrorDetail{
 				Code:    9,
 				Message: err.Error(),
@@ -75,8 +76,9 @@ func process[T, V any](ctx context.Context, cfg *base, msg *Message, method func
 	rawresult, err := json.Marshal(resp.Result)
 	if err != nil {
 		return cfg.stream.Send(&Message{
-			ID:      msg.ID,
-			JsonRPC: msg.JsonRPC,
+			Metadata: msg.Metadata,
+			ID:       msg.ID,
+			JsonRPC:  msg.JsonRPC,
 			Error: &ErrorDetail{
 				Code:    9,
 				Message: err.Error(),
@@ -86,8 +88,9 @@ func process[T, V any](ctx context.Context, cfg *base, msg *Message, method func
 
 	rawmsg := json.RawMessage(rawresult)
 	return cfg.stream.Send(&Message{
-		ID:      msg.ID,
-		JsonRPC: msg.JsonRPC,
-		Result:  &rawmsg,
+		Metadata: msg.Metadata,
+		ID:       msg.ID,
+		JsonRPC:  msg.JsonRPC,
+		Result:   &rawmsg,
 	})
 }

rpc.go

@@ -14,6 +14,10 @@ type Message struct {
 	Params  *json.RawMessage `json:"params,omitempty"`
 	Result  *json.RawMessage `json:"result,omitempty"`
 	Error   *ErrorDetail     `json:"error,omitempty"`
+
+	// Metadata is used to store additional information about the message for
+	// processing by the client or server. It is never sent across the wire.
+	Metadata map[string]string
 }
 
 type ErrorDetail struct {