MCP Golang

🚀 MCP Server Client and Server Functionality Implemented in Go

This project offers a detailed implementation of MCP server client and server - side functions in Go. It enables bidirectional communication between the client and the server, with several core functional modules.

🚀 Quick Start

The project focuses on implementing bidirectional communication between the client and the server. It provides multiple core function modules, including tool calls, prompt calls, and resource management, which greatly enhance the flexibility and efficiency of the system.

✨ Features

Tool Call

• Feature Description:
  • Supports tool calls. Users can extend functionality through the defined tool interfaces.
  • Uses native Go structs as parameters to ensure the security and type - safety of data transfer.
  • Provides an endpoint for programmatically generating a tool list, facilitating clients to dynamically obtain information about available tools.
  • Implements a change notification mechanism, enabling clients to promptly learn about tool updates on the server.
  • Supports pagination, suitable for efficient data management when there are a large number of tools.

Prompt Call

• Feature Description:
  • Supports prompt calls. Users can interact with the server through preset prompt templates.
  • Also uses Go structs as parameters to ensure data consistency and security.
  • Automatically generates a prompt list endpoint, allowing clients to dynamically obtain information about available prompts.
  • Implements a change notification mechanism to keep client - server information synchronized.
  • Supports pagination, suitable for managing a large number of prompt templates.

Resource Management

• Feature Description:
  • Supports create, read, update, and delete operations on resources, enabling users to conveniently manage various configurations and data.
  • Automatically generates a resource list endpoint, allowing clients to obtain the latest resource information in real - time.
  • Implements a change notification mechanism to ensure data synchronization between the client and the server.
  • Supports pagination, suitable for efficient management of a large number of resources.

💻 Usage Examples

Tool Call - Basic Usage

package main

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

// Define the parameter structure for tool calls
type CalculateArgs struct {
    Operation string `json:"operation"`
    A         int    `json:"a"`
    B         int    `json:"b"`
}

func main() {
    // Create and initialize the client
    transport := stdio.NewStdioServerTransport()
    client := mcp.NewClient(transport)

    if _, err := client.Initialize(context.Background()); err != nil {
        log.Fatalf("Failed to initialize: %v", err)
    }

    // Example of calling a tool
    args := CalculateArgs{
        Operation: "add",
        A:         10,
        B:         5,
    }
    
    response, err := client.CallTool(context.Background(), "calculate", args)
    if err != nil {
        log.Fatalf("Failed to call tool: %v", err)
    }

    if response != nil && len(response.Content) > 0 {
        log.Printf("Result: %s", response.Content[0].TextContent.Text)
    }
}

Prompt Call - Basic Usage

package main

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

// Define the parameter structure for prompt calls
type QueryArgs struct {
    Keywords    []string `json:"keywords"`
    PageSize   int      `json:"page_size"`
    PageNumber int      `json:"page_number"`
}

func main() {
    transport := stdio.NewStdioServerTransport()
    client := mcp.NewClient(transport)

    if _, err := client.Initialize(context.Background()); err != nil {
        log.Fatalf("Failed to initialize: %v", err)
    }

    // Example of calling a prompt
    args := QueryArgs{
        Keywords:    []string{"big data", "analysis"},
        PageSize:   10,
        PageNumber: 1,
    }
    
    response, err := client.CallPrompt(context.Background(), "data_analysis", args)
    if err != nil {
        log.Fatalf("Failed to call prompt: %v", err)
    }

    if response != nil && len(response.Content) > 0 {
        log.Printf("Result: %s", response.Content[0].TextContent.Text)
    }
}

Resource Management - Basic Usage

package main

import (
    "context"
    "log"
    mcp "github.com/metoro-io/mcp-golang"
    "github.com/metoro-io/mcp-golang/transport/stdio"
)
// The code for resource management continues...