mcp-golang is an unofficial implementation of the Model Context Protocol (MCP) in Go that enables developers to build MCP servers and clients with minimal boilerplate code. Key capabilities include: - Type-safe tool arguments defined as native Go structs with automatic JSON schema generation, deserialization, and error handling - Multiple built-in transports including stdio for full feature support and HTTP for stateless communication, with the ability to implement custom transports - Modular architecture split into transport, protocol, and server/client components that can be used independently or together - Bi-directional support for both server and client implementations through stdio transport - Automatic generation of MCP endpoints leaving developers to focus only on implementing tools, prompts, and resources

[](https://pkg.go.dev/github.com/metoro-io/mcp-golang) [](https://goreportcard.com/report/github.com/metoro-io/mcp-golang)

mcp-golang

mcp-golang is an unofficial implementation of the Model Context Protocol in Go.

Write MCP servers and clients in golang with a few lines of code.

Docs at https://mcpgolang.com

Highlights

Example Usage

Install with go get github.com/metoro-io/mcp-golang

Server Example

package main
import (
	"fmt"
	"github.com/metoro-io/mcp-golang"
	"github.com/metoro-io/mcp-golang/transport/stdio"
)
// Tool arguments are just structs, annotated with jsonschema tags
// More at https://mcpgolang.com/tools#schema-generation
type Content struct {
	Title       string  json:"title" jsonschema:"required,description=The title to submit"
	Description *string json:"description" jsonschema:"description=The description to submit"
}
type MyFunctionsArguments struct {
	Submitter string  json:"submitter" jsonschema:"required,description=The name of the thing calling this tool (openai, google, claude, etc)"
	Content   Content json:"content" jsonschema:"required,description=The content of the message"
}
func main() {
	done := make(chan struct{})
	server := mcp_golang.NewServer(stdio.NewStdioServerTransport())
	err := server.RegisterTool("hello", "Say hello to a person", func(arguments MyFunctionsArguments) (*mcp_golang.ToolResponse, error) {
		return mcp_golang.NewToolResponse(mcp_golang.NewTextContent(fmt.Sprintf("Hello, %server!", arguments.Submitter))), nil
	})
	if err != nil {
		panic(err)
	}
	err = server.RegisterPrompt("promt_test", "This is a test prompt", func(arguments Content) (*mcp_golang.PromptResponse, error) {
		return mcp_golang.NewPromptResponse("description", mcp_golang.NewPromptMessage(mcp_golang.NewTextContent(fmt.Sprintf("Hello, %server!", arguments.Title)), mcp_golang.RoleUser)), nil
	})
	if err != nil {
		panic(err)
	}
	err = server.RegisterResource("test://resource", "resource_test", "This is a test resource", "application/json", func() (*mcp_golang.ResourceResponse, error) {
		return mcp_golang.NewResourceResponse(mcp_golang.NewTextEmbeddedResource("test://resource", "This is a test resource", "application/json")), nil
	})
	err = server.Serve()
	if err != nil {
		panic(err)
	}
	<-done
}

HTTP Server Example

You can also create an HTTP-based server using either the standard HTTP transport or Gin framework:

// Standard HTTP
transport := http.NewHTTPTransport("/mcp")
transport.WithAddr(":8080")
server := mcp_golang.NewServer(transport)
// Or with Gin framework
transport := http.NewGinTransport()
router := gin.Default()
router.POST("/mcp", transport.Handler())
server := mcp_golang.NewServer(transport)

Note: HTTP transports are stateless and don't support bidirectional features like notifications. Use stdio transport if you need those features.

Client Example

Checkout the examples/client directory for a more complete example.

``go package main

import ( "context" "log" mcp "github.com/metoro-io/mcp-golang" "github.com/metoro-io/mcp-golang/transport/stdio" )

// Define type-safe arguments type CalculateArgs struct { Operation string json:"operation" A int json:"a"` B