📌Overview

Purpose: To provide a Go implementation of the Model Context Protocol (MCP), facilitating seamless integration between LLM applications and external data sources and tools.

Overview: MCP Go enables developers to create high-level servers that expose resources and tools to LLM applications. Designed for simplicity and efficiency, it abstracts complex protocol details, allowing developers to focus on building functional tools without extensive boilerplate code.

Key Features:

• Fast: The high-level interface expedites development by reducing code requirements.

• Simple: Facilitates easy server creation with minimal setup, streamlining MCP implementation.

• Complete: Aims to deliver a comprehensive implementation of core MCP specifications, making it suitable for various functionality and integration needs.

---

MCP Go 🚀

A Go implementation of the Model Context Protocol (MCP), enabling seamless integration between LLM applications and external data sources and tools.

Table of Contents

• Installation
• Quickstart
• What is MCP?
• Core Concepts
  • Server
  • Resources
  • Tools
  • Prompts
• Examples
• Contributing

Installation

go get github.com/mark3labs/mcp-go

Quickstart

Here's how to create a simple MCP server that exposes a calculator tool:

package main

import (
    "context"
    "errors"
    "fmt"

    "github.com/mark3labs/mcp-go/mcp"
    "github.com/mark3labs/mcp-go/server"
)

func main() {
    s := server.NewMCPServer("Calculator Demo", "1.0.0", server.WithResourceCapabilities(true, true), server.WithLogging())
    
    calculatorTool := mcp.NewTool("calculate",
        mcp.WithDescription("Perform basic arithmetic operations"),
        mcp.WithString("operation", mcp.Required(), mcp.Description("Arithmetic operation"), mcp.Enum("add", "subtract", "multiply", "divide")),
        mcp.WithNumber("x", mcp.Required(), mcp.Description("First number")),
        mcp.WithNumber("y", mcp.Required(), mcp.Description("Second number")),
    )

    s.AddTool(calculatorTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
        op := request.Params.Arguments["operation"].(string)
        x := request.Params.Arguments["x"].(float64)
        y := request.Params.Arguments["y"].(float64)

        var result float64
        switch op {
        case "add":
            result = x + y
        case "subtract":
            result = x - y
        case "multiply":
            result = x * y
        case "divide":
            if y == 0 {
                return nil, errors.New("Cannot divide by zero")
            }
            result = x / y
        }

        return mcp.NewToolResultText(fmt.Sprintf("%.2f", result)), nil
    })

    if err := server.ServeStdio(s); err != nil {
        fmt.Printf("Server error: %v\n", err)
    }
}

What is MCP?

The Model Context Protocol (MCP) allows you to build servers that expose data and functionality to LLM applications in a standardized way. MCP servers can:

• Expose data through Resources (like GET endpoints)
• Provide functionality through Tools (like POST endpoints)
• Define interaction patterns through Prompts

Core Concepts

Server

The server is your core interface to the MCP protocol. It handles connection management, protocol compliance, and message routing:

s := server.NewMCPServer("My Server", "1.0.0")
if err := server.ServeStdio(s); err != nil {
    log.Fatalf("Server error: %v", err)
}

Resources

Resources expose data to LLMs. They can be static or dynamic:

// Static resource
resource := mcp.NewResource("docs://readme", "Project README", mcp.WithResourceDescription("The project's README file"), mcp.WithMIMEType("text/markdown"))
s.AddResource(resource, func(ctx context.Context, request mcp.ReadResourceRequest) ([]mcp.ResourceContents, error) {
    content, err := os.ReadFile("README.md")
    if err != nil {
        return nil, err
    }
    return []mcp.ResourceContents{mcp.TextResourceContents{URI: "docs://readme", MIMEType: "text/markdown", Text: string(content)}}, nil
})

Tools

Tools allow LLMs to perform actions through your server:

calculatorTool := mcp.NewTool("calculate", mcp.WithDescription("Perform basic arithmetic calculations"),
    mcp.WithString("operation", mcp.Required(), mcp.Description("The arithmetic operation to perform"), mcp.Enum("add", "subtract", "multiply", "divide")),
    mcp.WithNumber("x", mcp.Required(), mcp.Description("First number")),
    mcp.WithNumber("y", mcp.Required(), mcp.Description("Second number")),
)

s.AddTool(calculatorTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
    // implementation
})

Prompts

Prompts are reusable templates that guide LLM interactions:

s.AddPrompt(mcp.NewPrompt("greeting", 
    mcp.WithPromptDescription("A friendly greeting prompt"),
    mcp.WithArgument("name", mcp.ArgumentDescription("Name of the person to greet")),
), func(ctx context.Context, request mcp.GetPromptRequest) (*mcp.GetPromptResult, error) {
    // implementation
})

Examples

For examples, see the examples/ directory.

Contributing

Prerequisites

Go version >= 1.23

Installation

Fork this repository and clone it:

git clone https://github.com/mark3labs/mcp-go.git
cd mcp-go

Testing

Run tests from the root directory:

go test -v './...'

Opening a Pull Request

Create a new branch, make changes, and push to your fork:

git checkout -b my-branch
git add . && git commit -m "My changes"
git push origin my-branch