Unlock AI Tool Integration with the New Go MCP SDK v1.0.0

In the era of rapid AI development, large language models (LLM) need richer, dynamic context, and the Model Context Protocol (MCP) provides a standard for secure, efficient interaction with external tools, data sources, and services.

The official Go SDK for MCP was delayed, but after months of community testing the modelcontextprotocol/go-sdk project finally released the milestone v1.0.0 , marking the transition from an unstable preview to a production‑ready version.

What does v1.0.0 mean? – Commitment and Trust

The version jump from v0.x.x to v1.0.0 signals a firm promise of API stability. The core team states “Going forward we won’t make breaking API changes.” This guarantees:

Reliable dependency : developers can use the SDK in production without fearing incompatible upgrades.

Backward compatibility : future enhancements will be added via deprecation rather than breaking changes, giving ample migration time.

Foundation for ecosystem growth : a stable API enables library authors and tool developers to build higher‑level applications, fostering a thriving Go MCP ecosystem.

Quick Start

The modelcontextprotocol/go-sdk package provides all core functions for building MCP clients and servers.

Installation

$ go get github.com/modelcontextprotocol/go-sdk/[email protected]

Create an MCP Server

The following example creates a simple “greeting” server offering a greet tool.

package main

import (
    "context"
    "log"

    "github.com/modelcontextprotocol/go-sdk/mcp"
)

// Input defines the tool’s input parameters
type Input struct {
    Name string `json:"name" jsonschema:"the name of the person to greet"`
}

// Output defines the tool’s output
type Output struct {
    Greeting string `json:"greeting" jsonschema:"the greeting to tell to the user"`
}

// SayHi processes the tool request
func SayHi(ctx context.Context, req *mcp.CallToolRequest, input Input) (*mcp.CallToolResult, Output, error) {
    return nil, Output{Greeting: "Hi " + input.Name}, nil
}

func main() {
    server := mcp.NewServer(&mcp.Implementation{Name: "greeter", Version: "v1.0.0"}, nil)
    mcp.AddTool(server, &mcp.Tool{Name: "greet", Description: "say hi"}, SayHi)
    if err := server.Run(context.Background(), &mcp.StdioTransport{}); err != nil {
        log.Fatal(err)
    }
}

Create an MCP Client

The client connects to the server and calls the tool.

package main

import (
    "context"
    "log"
    "os/exec"

    "github.com/modelcontextprotocol/go-sdk/mcp"
)

func main() {
    ctx := context.Background()
    client := mcp.NewClient(&mcp.Implementation{Name: "mcp-client", Version: "v1.0.0"}, nil)
    transport := &mcp.CommandTransport{Command: exec.Command("./greeting")}
    session, err := client.Connect(ctx, transport, nil)
    if err != nil {
        log.Fatal(err)
    }
    defer session.Close()

    params := &mcp.CallToolParams{
        Name: "greet",
        Arguments: map[string]any{"name": "江湖十年"},
    }
    res, err := session.CallTool(ctx, params)
    if err != nil {
        log.Fatalf("CallTool failed: %v", err)
    }
    if res.IsError {
        log.Fatal("tool failed")
    }
    for _, c := range res.Content {
        log.Print(c.(*mcp.TextContent).Text)
    }
}

Run the Example

Compile the server, then run the client:

# Build the server
$ go build -o client/greeting server/greeting.go

# Run the client
$ cd client
$ go run client.go
2025/10/08 22:59:01 {"greeting":"Hi 江湖十年"}

This completes a standard‑input/output MCP usage example.

Design of the MCP Go SDK

The SDK follows the MCP specification and provides a type‑safe, modular architecture:

Modular and layered design : Transport interfaces (e.g., StdioTransport, CommandTransport, SSEServerTransport) abstract communication channels, supporting local, remote, and cloud deployments.

Session management : Session objects handle connection state and enable multiple interactions.

Type safety : Tool inputs/outputs are defined as Go structs with json and jsonschema tags for serialization and validation.

Client‑server model : Servers register tools via mcp.AddTool; clients invoke tools with session.CallTool, allowing aggregation of multiple services.

Protocol compatibility and extensibility : Full MCP compliance with support for future extensions.

Error handling : Errors are returned through Go’s error mechanism, and the IsError field indicates business‑logic failures.

Conclusion

Combining Go’s efficiency with MCP’s powerful protocol opens new possibilities for AI application development. The release of MCP Go SDK v1.0.0 provides a stable API, a complete MCP implementation, and production‑ready components, making it an ideal time for developers to build Go‑based MCP servers and clients.