MCP4Go

MCP4Go is a Go implementation of the Model Context Protocol (MCP), designed to simplify the development of AI applications by abstracting away protocol complexities.

Features

- Complete MCP protocol implementation in pure Go
- High-level abstractions for common MCP resources
- Pluggable architecture for custom extensions
- Comprehensive documentation and examples
- Production-ready with robust error handling

Installation

MCP4Go requires Go 1.18 or later. Install it using Go modules:

go get github.com/mcp4go/mcp4go

Getting Started

To get started with MCP4Go, import the package in your Go application:

package main
import (

	"context"

	"fmt"

	"log"

	"os"

	"os/signal"

	"syscall"

	"time"
"github.com/mcp4go/mcp4go/pkg/logger"

	"github.com/mcp4go/mcp4go/protocol"

	"github.com/mcp4go/mcp4go/server"

	"github.com/mcp4go/mcp4go/server/iface"

	"github.com/mcp4go/mcp4go/server/transport"
_ "time/tzdata" // Load all time zones

)
func main() {

	ctx, cancel := context.WithCancel(context.Background())

	defer cancel()

	_logger := logger.DefaultLog
// Listen for interrupt signals for graceful exit

	signalCh := make(chan os.Signal, 1)

	signal.Notify(signalCh, os.Interrupt, syscall.SIGTERM)

	go func() {

		<-signalCh

		_logger.Logf(ctx, logger.LevelWarn, "Received shutdown signal")

		cancel()

	}()
type timeRequest struct {

		TimeZone string json:"time_zone,omitempty" description:"time zone default is Asia/Shanghai"

	}
// Create standard input/output transport layer

	stdioTransport := transport.NewStdioTransport()

	// Create MCP server and configure options

	srv, cleanup, err := server.NewServer(

		stdioTransport,

		server.WithServerInfo(protocol.Implementation{

			Name:    "time-mcp",

			Version: "0.1.0",

		}),

		server.WithInstructions("Welcome to Time MCP! This server provides Time tools."),

		server.WithToolBuilder(iface.NewFunctionalToolsBuilder(

			iface.NewFunctionalToolWrapper(

				"time",

				"get current time",

				func(ctx context.Context, args timeRequest) ([]protocol.Content, error) {

					if args.TimeZone == "" {

						args.TimeZone = "Asia/Shanghai"

					}
getTimezoneTime := func(_ context.Context, timeZone string) time.Time {

						if timeZone == "" {

							timeZone = "Asia/Shanghai"

						}

						loc, err := time.LoadLocation(timeZone)

						if err != nil {

							return time.Now()

						}

						return time.Now().In(loc)

					}
currentTime := getTimezoneTime(ctx, args.TimeZone)
return []protocol.Content{

						protocol.NewTextContent(fmt.Sprintf("current time is %s", currentTime), nil),

					}, nil

				}),

		)),

	)

	if err != nil {

		log.Printf("Failed to create server: %v\n", err)

		return

	}

	defer cleanup()
// Start the server

	_logger.Logf(ctx, logger.LevelWarn, "Starting Time MCP server")

	if err := srv.Run(ctx); err != nil {

		_logger.Logf(ctx, logger.LevelError, "Server error: %v", err)

		return

	}
_logger.Logf(ctx, logger.LevelWarn, "Server shutdown complete")

}

Protocol Implementation

MCP4Go provides a complete implementation of the Model Context Protocol with support for: - JSON-RPC communication - Resource lifecycle management - Prompt engineering - Tool definitions and invocations - Sampling parameters - Logging and diagnostics

License

This project is licensed under the MIT License

Contributing

Contributions are welcome! Please see our Contributing Guide for more information.