mcp-golang MCP Server: Unofficial Implementation of Model Context Protocol in Go

Overview: What is mcp-golang MCP Server?

mcp-golang is an unofficial implementation of the Model Context Protocol (MCP) designed for developers looking to write MCP servers and clients in Go. This server simplifies the process by leveraging native Go structs, automatic schema generation, error handling, and more, making it highly versatile across various applications.

🔧 Core Features & MCP Capabilities

mcp-golang offers several compelling features that enhance its utility for AI application developers:

• Type Safety: Define your tool arguments using native Go structs and let mcp-golang handle the rest.
• Custom Transports: Utilize built-in transports like stdio, HTTP (standard or through Gin framework), or even write custom ones.
• Low Boilerplate: Minimal configuration required as mcp-golang generates most of the necessary MCP endpoints automatically.
• Modular Components: The library is split into transport, protocol, and server/client modules, allowing for flexibility in usage.

Server Examples

mcp-golang supports both STDIO (full feature support) and HTTP transports. Here are a couple of example usages:

Server Example:

package main

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

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(args MyFunctionsArguments) (*mcp_golang.ToolResponse, error) {
		return mcp_golang.NewToolResponse(mcp_golang.NewTextContent(fmt.Sprintf("Hello, %server!", args.Submitter))), nil
	})
	if err != nil {
		panic(err)
	}

	err = server.RegisterPrompt("promt_test", "This is a test prompt", func(args Content) (*mcp_golang.PromptResponse, error) {
		return mcp_golang.NewPromptResponse("description", mcp_golang.NewPromptMessage(mcp_golang.NewTextContent(fmt.Sprintf("Hello, %server!", args.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:

// 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)

The above examples demonstrate how to use the stdio and HTTP transports respectively. Note that while HTTP supports request-response scenarios, STDIO offers bidirectional communication capabilities.

⚙️ MCP Architecture & Protocol Implementation

mcp-golang implements a comprehensive protocol stack following Model Context Protocol standards:

• Tool Endpoint: Registers tools for clients to call.
• Prompt Endpoint: Handles prompt calls from clients.
• Resource Endpoint: Manages shared resources between servers and clients.

MCP Protocol Flow Diagram

graph TD
    A[AI Application] -->|MCP Client| B[MCP Protocol]
    B --> C[mcp-golang Server]
    C --> D[Data Source/Tool]
    style A fill:#e1f5fe
    style C fill:#f3e5f5
    style D fill:#e8f5e8

The diagram illustrates the communication flow from an AI application (MCP client) through the mcp-golang server to underlying data sources or tools.

🚀 Getting Started with Installation

To get started, you can install the mcp-golang library via Go's standard package manager:

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

This command will fetch the necessary dependencies and integrate them into your project.

💡 Key Use Cases in AI Workflows

Use Case: Integrating with a Knowledge Base System

Imagine incorporating mcp-golang into an application that needs to query a knowledge base system for relevant information. You could register a tool within your server and allow CLUDE Desktop or other MCP clients to query the knowledge base seamlessly.

server.RegisterTool("knowledge_base", "Query a knowledge base", func(args QueryArgs) (*mcp_golang.ToolResponse, error) {
    // Implementation here...
})

Use Case: Real-Time Data Processing

Suppose you want to process real-time data from various sources. Using mcp-golang, you can define tools that consume and produce data in real time.

• Tool: A tool that reads sensor data.

  server.RegisterTool("realtime_sensors", "Collect data from sensors", func(args SensorArgs) (*mcp_golang.ToolResponse, error) {
      // Implementation here...
  })
  

• MCP Client Integration: Using CLUDE Desktop or other MCP clients to consume and act on these sensor data.

  client.CallTool("realtime_sensors", args)
  

🔌 Integration with MCP Clients

mcp-golang is compatible with several MCP clients, including:

• Claude Desktop: ✅ (Full Support for Resources & Tools)
• Continue: ✅ (Full Support for Resources & Tools)
• Cursor: ❌ (Partial Support - Only Resources)

These integrations enable seamless communication and data exchange between your Go-based server application and popular AI client applications.

📊 Performance & Compatibility Matrix

MCP Client Compatibility: mcp-golang supports the following MCP clients with varying levels of integration:

MCP Client	Resources	Tools	Prompts	Status
Claude Desktop	✅	✅	✅	Full Support
Continue	✅	✅	✅	Full Support
Cursor	❌	✅	❌	Tools Only

🛠️ Advanced Configuration & Security

For advanced configurations, you can customize the server's behavior:

{
  "mcpServers": {
    "myCustomMCP": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-mycustom"],
      "env": {
        "API_KEY": "your-api-key"
      }
    }
  }
}

MCP Configuration Sample

The configuration sample above illustrates how to set up environment variables for security and customization purposes.

❓ Frequently Asked Questions (FAQ)

1. Q: How does mcp-golang handle data privacy?
   • A: Data transmitted over the protocol is encrypted using standard encryption protocols, ensuring secure communication.
2. Q: Can I use mcp-golang with other languages besides Go?
   • A: Currently, mcp-golang is only compatible with Go due to its implementation specifics; however, similar libraries are being developed for other languages as part of the broader MCP ecosystem.
3. Q: What kind of tools can be registered with mcp-golang?
   • A: Any tool that processes data and returns a response over the protocol can be registered, including querying databases, performing calculations, or generating reports.
4. Q: How do I debug an issue with my MCP client and server interaction?
   • A: You can use network monitoring tools like Wireshark to capture packets and analyze them for issues in data transmission or interaction flow.
5. Q: Is there any performance overhead associated with using mcp-golang?
   • A: The overhead is minimal, especially when comparing it to custom implementations since the protocol stack minimizes additional layers.

👨‍💻 Development & Contribution Guidelines

Contributors are welcome to enhance and improve mcp-golang. To contribute:

1. Fork the repository from GitHub.
2. Develop your changes on a branch.
3. Ensure tests pass with make test.
4. Submit a pull request describing new features, bug fixes, or other improvements.

🌐 MCP Ecosystem & Resources

To stay updated and engage within the broader MCP ecosystem:

• GitHub Repository: mcp-golang
• Documentation: Comprehensive guides for both users and developers.
• Community Slack Group: Connect with other contributors, ask questions, and share ideas.

By integrating mcp-golang, you open up new possibilities for AI application development by enabling seamless integration across different tools and clients. Whether you're building a knowledge management system or real-time data processing applications, this protocol stack provides robust support for MCP-based integrations.