must be non-nil

Author: jba

examples/completion/main.go

@@ -40,7 +40,7 @@ func main() {
 
 	// Create the MCP Server instance and assign the handler.
 	// No server running, just showing the configuration.
-	_ = mcp.NewServer(nil, &mcp.ServerOptions{
+	_ = mcp.NewServer(&mcp.Implementation{Name: "server"}, &mcp.ServerOptions{
 		CompletionHandler: myCompletionHandler,
 	})
 

examples/memory/main.go

@@ -91,7 +91,7 @@ func main() {
 	kb := knowledgeBase{s: kbStore}
 
 	// Setup MCP server with knowledge base tools
-	server := mcp.NewServer(nil, nil)
+	server := mcp.NewServer(&mcp.Implementation{Name: "memory"}, nil)
 	mcp.AddTool(server, &mcp.Tool{
 		Name:        "create_entities",
 		Description: "Create multiple new entities in the knowledge graph",

internal/readme/client/client.go

@@ -17,7 +17,7 @@ func main() {
 	ctx := context.Background()
 
 	// Create a new client, with no features.
-	client := mcp.NewClient(nil, nil)
+	client := mcp.NewClient(&mcp.Implementation{Name: "mcp-client", Version: "v1.0.0"}, nil)
 
 	// Connect to a server over stdin/stdout
 	transport := mcp.NewCommandTransport(exec.Command("myserver"))

mcp/client.go

@@ -30,11 +30,12 @@ type Client struct {
 //
 // Use [Client.Connect] to connect it to an MCP server.
 //
-// If impl is nil, a default name and version are used, and the title is left empty.
+// The first argument must not be nil.
+//
 // If non-nil, the provided options configure the Client.
 func NewClient(impl *Implementation, opts *ClientOptions) *Client {
 	if impl == nil {
-		impl = &Implementation{Name: "Go MCP SDK Client", Version: "v0.1.0"}
+		panic("nil Implementation")
 	}
 	c := &Client{
 		impl:                    impl,

mcp/cmd_test.go

@@ -30,7 +30,7 @@ func TestMain(m *testing.M) {
 func runServer() {
 	ctx := context.Background()
 
-	server := mcp.NewServer(nil, nil)
+	server := mcp.NewServer(testImpl, nil)
 	mcp.AddTool(server, &mcp.Tool{Name: "greet", Description: "say hi"}, SayHi)
 	if err := server.Run(ctx, mcp.NewStdioTransport()); err != nil {
 		log.Fatal(err)
@@ -56,7 +56,7 @@ func TestCmdTransport(t *testing.T) {
 	cmd := exec.Command(exe)
 	cmd.Env = append(os.Environ(), runAsServer+"=true")
 
-	client := mcp.NewClient(nil, nil)
+	client := mcp.NewClient(testImpl, nil)
 	session, err := client.Connect(ctx, mcp.NewCommandTransport(cmd))
 	if err != nil {
 		log.Fatal(err)
@@ -80,3 +80,5 @@ func TestCmdTransport(t *testing.T) {
 		t.Fatalf("closing server: %v", err)
 	}
 }
+
+var testImpl = &mcp.Implementation{Name: "test", Version: "v1.0.0"}

mcp/example_progress_test.go

@@ -16,7 +16,7 @@ var nextProgressToken atomic.Int64
 // This middleware function adds a progress token to every outgoing request
 // from the client.
 func Example_progressMiddleware() {
-	c := mcp.NewClient(nil, nil)
+	c := mcp.NewClient(testImpl, nil)
 	c.AddSendingMiddleware(addProgressToken[*mcp.ClientSession])
 	_ = c
 }

mcp/mcp_test.go

@@ -64,7 +64,7 @@ func TestEndToEnd(t *testing.T) {
 			notificationChans["progress_server"] <- 0
 		},
 	}
-	s := NewServer(nil, sopts)
+	s := NewServer(testImpl, sopts)
 	AddTool(s, &Tool{
 		Name:        "greet",
 		Description: "say hi",
@@ -125,7 +125,7 @@ func TestEndToEnd(t *testing.T) {
 			notificationChans["progress_client"] <- 0
 		},
 	}
-	c := NewClient(nil, opts)
+	c := NewClient(testImpl, opts)
 	rootAbs, err := filepath.Abs(filepath.FromSlash("testdata/files"))
 	if err != nil {
 		t.Fatal(err)
@@ -510,7 +510,7 @@ func basicConnection(t *testing.T, config func(*Server)) (*ServerSession, *Clien
 	ctx := context.Background()
 	ct, st := NewInMemoryTransports()
 
-	s := NewServer(nil, nil)
+	s := NewServer(testImpl, nil)
 	if config != nil {
 		config(s)
 	}
@@ -519,7 +519,7 @@ func basicConnection(t *testing.T, config func(*Server)) (*ServerSession, *Clien
 		t.Fatal(err)
 	}
 
-	c := NewClient(nil, nil)
+	c := NewClient(testImpl, nil)
 	cs, err := c.Connect(ctx, ct)
 	if err != nil {
 		t.Fatal(err)
@@ -562,13 +562,13 @@ func TestBatching(t *testing.T) {
 	ctx := context.Background()
 	ct, st := NewInMemoryTransports()
 
-	s := NewServer(nil, nil)
+	s := NewServer(testImpl, nil)
 	_, err := s.Connect(ctx, st)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	c := NewClient(nil, nil)
+	c := NewClient(testImpl, nil)
 	// TODO: this test is broken, because increasing the batch size here causes
 	// 'initialize' to block. Therefore, we can only test with a size of 1.
 	// Since batching is being removed, we can probably just delete this.
@@ -632,7 +632,7 @@ func TestMiddleware(t *testing.T) {
 	ctx := context.Background()
 	ct, st := NewInMemoryTransports()
 
-	s := NewServer(nil, nil)
+	s := NewServer(testImpl, nil)
 	ss, err := s.Connect(ctx, st)
 	if err != nil {
 		t.Fatal(err)
@@ -656,7 +656,7 @@ func TestMiddleware(t *testing.T) {
 	s.AddSendingMiddleware(traceCalls[*ServerSession](&sbuf, "S1"), traceCalls[*ServerSession](&sbuf, "S2"))
 	s.AddReceivingMiddleware(traceCalls[*ServerSession](&sbuf, "R1"), traceCalls[*ServerSession](&sbuf, "R2"))
 
-	c := NewClient(nil, nil)
+	c := NewClient(testImpl, nil)
 	c.AddSendingMiddleware(traceCalls[*ClientSession](&cbuf, "S1"), traceCalls[*ClientSession](&cbuf, "S2"))
 	c.AddReceivingMiddleware(traceCalls[*ClientSession](&cbuf, "R1"), traceCalls[*ClientSession](&cbuf, "R2"))
 
@@ -741,13 +741,13 @@ func TestNoJSONNull(t *testing.T) {
 	var logbuf safeBuffer
 	ct = NewLoggingTransport(ct, &logbuf)
 
-	s := NewServer(nil, nil)
+	s := NewServer(testImpl, nil)
 	ss, err := s.Connect(ctx, st)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	c := NewClient(nil, nil)
+	c := NewClient(testImpl, nil)
 	cs, err := c.Connect(ctx, ct)
 	if err != nil {
 		t.Fatal(err)
@@ -810,7 +810,7 @@ func TestKeepAlive(t *testing.T) {
 	serverOpts := &ServerOptions{
 		KeepAlive: 100 * time.Millisecond,
 	}
-	s := NewServer(nil, serverOpts)
+	s := NewServer(testImpl, serverOpts)
 	AddTool(s, greetTool(), sayHi)
 
 	ss, err := s.Connect(ctx, st)
@@ -822,7 +822,7 @@ func TestKeepAlive(t *testing.T) {
 	clientOpts := &ClientOptions{
 		KeepAlive: 100 * time.Millisecond,
 	}
-	c := NewClient(nil, clientOpts)
+	c := NewClient(testImpl, clientOpts)
 	cs, err := c.Connect(ctx, ct)
 	if err != nil {
 		t.Fatal(err)
@@ -855,7 +855,7 @@ func TestKeepAliveFailure(t *testing.T) {
 	ct, st := NewInMemoryTransports()
 
 	// Server without keepalive (to test one-sided keepalive)
-	s := NewServer(nil, nil)
+	s := NewServer(testImpl, nil)
 	AddTool(s, greetTool(), sayHi)
 	ss, err := s.Connect(ctx, st)
 	if err != nil {
@@ -866,7 +866,7 @@ func TestKeepAliveFailure(t *testing.T) {
 	clientOpts := &ClientOptions{
 		KeepAlive: 50 * time.Millisecond,
 	}
-	c := NewClient(nil, clientOpts)
+	c := NewClient(testImpl, clientOpts)
 	cs, err := c.Connect(ctx, ct)
 	if err != nil {
 		t.Fatal(err)
@@ -895,3 +895,5 @@ func TestKeepAliveFailure(t *testing.T) {
 
 	t.Errorf("expected connection to be closed by keepalive, but it wasn't. Last error: %v", err)
 }
+
+var testImpl = &Implementation{Name: "test", Version: "v1.0.0"}

mcp/server.go

@@ -71,11 +71,12 @@ type ServerOptions struct {
 // The server can be connected to one or more MCP clients using [Server.Start]
 // or [Server.Run].
 //
-// If impl is nil, a default name and version are used, and the title is left empty.
-// If non-nil, the provided options is used to configure the server.
+// The first argument must not be nil.
+//
+// If non-nil, the provided options are used to configure the server.
 func NewServer(impl *Implementation, opts *ServerOptions) *Server {
 	if impl == nil {
-		impl = &Implementation{Name: "Go MCP SDK Server", Version: "v0.1.0"}
+		panic("nil Implementation")
 	}
 	if opts == nil {
 		opts = new(ServerOptions)

mcp/server_example_test.go

@@ -36,7 +36,7 @@ func ExampleServer() {
 		log.Fatal(err)
 	}
 
-	client := mcp.NewClient(nil, nil)
+	client := mcp.NewClient(&mcp.Implementation{Name: "client"}, nil)
 	clientSession, err := client.Connect(ctx, clientTransport)
 	if err != nil {
 		log.Fatal(err)
@@ -59,8 +59,8 @@ func ExampleServer() {
 
 // createSessions creates and connects an in-memory client and server session for testing purposes.
 func createSessions(ctx context.Context) (*mcp.ClientSession, *mcp.ServerSession, *mcp.Server) {
-	server := mcp.NewServer(nil, nil)
-	client := mcp.NewClient(nil, nil)
+	server := mcp.NewServer(testImpl, nil)
+	client := mcp.NewClient(testImpl, nil)
 	serverTransport, clientTransport := mcp.NewInMemoryTransports()
 	serverSession, err := server.Connect(ctx, serverTransport)
 	if err != nil {

mcp/sse_example_test.go

@@ -27,7 +27,7 @@ func Add(ctx context.Context, cc *mcp.ServerSession, params *mcp.CallToolParamsF
 }
 
 func ExampleSSEHandler() {
-	server := mcp.NewServer(&mcp.Implementation{Name: "adder"}, nil)
+	server := mcp.NewServer(&mcp.Implementation{Name: "adder", Version: "v0.0.1"}, nil)
 	mcp.AddTool(server, &mcp.Tool{Name: "add", Description: "add two numbers"}, Add)
 
 	handler := mcp.NewSSEHandler(func(*http.Request) *mcp.Server { return server })
@@ -36,7 +36,7 @@ func ExampleSSEHandler() {
 
 	ctx := context.Background()
 	transport := mcp.NewSSEClientTransport(httpServer.URL, nil)
-	client := mcp.NewClient(nil, nil)
+	client := mcp.NewClient(&mcp.Implementation{Name: "test", Version: "v1.0.0"}, nil)
 	cs, err := client.Connect(ctx, transport)
 	if err != nil {
 		log.Fatal(err)