MCP Go SDK

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

import "github.com/modelcontextprotocol/go-sdk/auth"      // OAuth authentication
import "github.com/modelcontextprotocol/go-sdk/jsonrpc"   // Custom transports
import "github.com/modelcontextprotocol/go-sdk/oauthex"   // OAuth extensions

package main

import (
	"context"
	"log"
	"github.com/modelcontextprotocol/go-sdk/mcp"
)

type Input struct {
	Name string `json:"name" jsonschema:"the name of the person to greet"`
}

type Output struct {
	Greeting string `json:"greeting" jsonschema:"the greeting to tell to the user"`
}

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

func main() {
	// Create a server with a single tool
	server := mcp.NewServer(&mcp.Implementation{Name: "greeter", Version: "v1.0.0"}, nil)
	mcp.AddTool(server, &mcp.Tool{Name: "greet", Description: "say hi"}, SayHi)

	// Run the server over stdin/stdout
	if err := server.Run(context.Background(), &mcp.StdioTransport{}); err != nil {
		log.Fatal(err)
	}
}

package main

import (
	"context"
	"log"
	"os/exec"
	"github.com/modelcontextprotocol/go-sdk/mcp"
)

func main() {
	ctx := context.Background()

	// Create a new client
	client := mcp.NewClient(&mcp.Implementation{Name: "mcp-client", Version: "v1.0.0"}, nil)

	// Connect to a server over stdin/stdout
	transport := &mcp.CommandTransport{Command: exec.Command("myserver")}
	session, err := client.Connect(ctx, transport, nil)
	if err != nil {
		log.Fatal(err)
	}
	defer session.Close()

	// Call a tool on the server
	params := &mcp.CallToolParams{
		Name:      "greet",
		Arguments: map[string]any{"name": "you"},
	}
	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)
	}
}

func NewServer(impl *Implementation, options *ServerOptions) *Server

func NewClient(impl *Implementation, opts *ClientOptions) *Client

type Transport interface {
	Connect(ctx context.Context) (Connection, error)
}

type CallToolParams struct {
	Meta      `json:"_meta,omitempty"`
	Name      string `json:"name"`
	Arguments any    `json:"arguments,omitempty"`
}

type InitializeParams struct {
	Meta            `json:"_meta,omitempty"`
	Capabilities    *ClientCapabilities `json:"capabilities"`
	ClientInfo      *Implementation     `json:"clientInfo"`
	ProtocolVersion string              `json:"protocolVersion"`
}

type Content interface {
	MarshalJSON() ([]byte, error)
}

type ServerCapabilities struct {
	Completions  *CompletionCapabilities `json:"completions,omitempty"`
	Experimental map[string]any          `json:"experimental,omitempty"`
	Logging      *LoggingCapabilities    `json:"logging,omitempty"`
	Prompts      *PromptCapabilities     `json:"prompts,omitempty"`
	Resources    *ResourceCapabilities   `json:"resources,omitempty"`
	Tools        *ToolCapabilities       `json:"tools,omitempty"`
}

func RequireBearerToken(verifier TokenVerifier, opts *RequireBearerTokenOptions) func(http.Handler) http.Handler

func DecodeMessage(data []byte) (Message, error)
func EncodeMessage(msg Message) ([]byte, error)

func GetProtectedResourceMetadata(ctx context.Context, resourceURL string, c *http.Client) (*ProtectedResourceMetadata, error)
func RegisterClient(ctx context.Context, registrationEndpoint string, clientMeta *ClientRegistrationMetadata, c *http.Client) (*ClientRegistrationResponse, error)

const (
	LevelDebug     = slog.LevelDebug
	LevelInfo      = slog.LevelInfo
	LevelNotice    = (slog.LevelInfo + slog.LevelWarn) / 2
	LevelWarning   = slog.LevelWarn
	LevelError     = slog.LevelError
	LevelCritical  = slog.LevelError + 4
	LevelAlert     = slog.LevelError + 8
	LevelEmergency = slog.LevelError + 12
)

const DefaultPageSize = 1000

var ErrConnectionClosed = errors.New("connection closed")
var ErrEventsPurged = errors.New("data purged")

type Implementation struct {
	Name    string `json:"name"`
	Title   string `json:"title,omitempty"`
	Version string `json:"version"`
}

type Meta map[string]any

type Role string

type LoggingLevel string

type Params interface {
	GetMeta() map[string]any
	SetMeta(map[string]any)
}

type RequestParams interface {
	Params
	GetProgressToken() any
	SetProgressToken(any)
}

type Result interface {
	GetMeta() map[string]any
	SetMeta(map[string]any)
}

type Request interface {
	GetSession() Session
	GetParams() Params
	GetExtra() *RequestExtra
}

type Session interface {
	ID() string
}

type RequestExtra struct {
	TokenInfo *auth.TokenInfo
	Header    http.Header
}