mcp

package
v0.5.12 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 13, 2026 License: Apache-2.0 Imports: 18 Imported by: 0

Documentation

Overview

Package mcp 实现 Model Context Protocol (MCP) 支持

本文件实现 MCP 与 ai-core tool.Tool 之间的适配

Package mcp 实现 Model Context Protocol (MCP) 支持

MCP 是 Anthropic 提出的标准协议，用于 LLM 与外部工具/数据源通信。

主要功能：

  • MCP 客户端：连接 MCP 服务器，调用远程工具
  • MCP 服务器：暴露本地工具为 MCP 服务
  • 工具适配器：将 MCP 工具转换为 Hexagon 工具

使用示例： 

client := mcp.NewClient("localhost:8080")
tools, _ := client.ListTools(ctx)
result, _ := client.CallTool(ctx, "calculator", map[string]any{"a": 1, "b": 2})

Package mcp 实现 Model Context Protocol (MCP) 支持

本文件实现将远程 MCP 工具包装为 ai-core tool.Tool 的代理

Package mcp 提供 MCP（Model Context Protocol）客户端与服务端能力

本文件实现 MCP 工具集的自动重连：当与远端 MCP 服务器的连接出现瞬时故障 （网络抖动、服务器重启等）时，按指数退避重试初始化握手，恢复后重新拉取工具列表。 重连退避复用 toolkit/util/retry，不重复实现退避逻辑。

Package mcp 实现 Model Context Protocol (MCP) 支持

本文件实现 ai-core Schema 与 MCP JSONSchema 之间的双向转换

Package mcp 实现 Model Context Protocol (MCP) 支持

本文件实现 MCP 服务器，用于将 Hexagon 工具暴露为 MCP 服务

Package mcp 实现 Model Context Protocol (MCP) 支持

本文件定义 MCP 传输层接口及 HTTP 实现

Package mcp 实现 Model Context Protocol (MCP) 支持

本文件实现 Stdio 传输层，用于与本地 MCP 进程通信

Index

Constants

View Source 
const (
	ErrorCodeParseError     = -32700
	ErrorCodeInvalidRequest = -32600
	ErrorCodeMethodNotFound = -32601
	ErrorCodeInvalidParams  = -32602
	ErrorCodeInternalError  = -32603
)

标准错误码

View Source 
const MCPVersion = "2024-11-05"

MCPVersion MCP 协议版本

Variables

This section is empty.

Functions

func ConnectMCPServer deprecated 

func ConnectMCPServer(ctx context.Context, endpoint string) ([]tool.Tool, error)

ConnectMCPServer 连接 MCP 服务器并返回工具列表

Deprecated: 请使用 ConnectMCPServerV2，基于官方 Go SDK 实现。

这是最常用的便捷函数，一行代码即可获取远程 MCP 工具

示例： 

tools, err := mcp.ConnectMCPServer(ctx, "http://localhost:8080")
if err != nil {
    log.Fatal(err)
}

agent := agent.New(
    agent.WithTools(tools...),
)

func ConnectMCPServerV2 

func ConnectMCPServerV2(ctx context.Context, transport sdkmcp.Transport) ([]tool.Tool, io.Closer, error)

ConnectMCPServerV2 使用官方 SDK 连接 MCP Server 并获取工具列表

返回的 []tool.Tool 可直接用于 Hexagon Agent。 调用方需要在使用完毕后调用 closer.Close() 释放连接。

transport: 官方 SDK 的 Transport（如 &mcp.CommandTransport{}, &mcp.SSEClientTransport{}）

示例： 

// 连接 SSE 服务器
transport := &mcp.SSEClientTransport{Endpoint: "http://localhost:8080/sse"}
tools, closer, err := mcp.ConnectMCPServerV2(ctx, transport)
defer closer.Close()

func ConnectSSEServerV2 

func ConnectSSEServerV2(ctx context.Context, endpoint string) ([]tool.Tool, io.Closer, error)

ConnectSSEServerV2 使用官方 SDK 连接 SSE MCP Server

通过 Server-Sent Events 协议通信，适合远程 MCP 服务。

示例： 

tools, closer, err := mcp.ConnectSSEServerV2(ctx, "http://localhost:8080/sse")
defer closer.Close()

func ConnectStdioServer deprecated 

func ConnectStdioServer(ctx context.Context, command string, args ...string) ([]tool.Tool, func(), error)

ConnectStdioServer 连接本地 MCP 进程并返回工具列表

Deprecated: 请使用 ConnectStdioServerV2，基于官方 Go SDK 实现。

这是连接本地 MCP 服务的便捷函数。 返回的 cleanup 函数用于关闭进程和释放资源。

示例： 

// 连接 filesystem MCP 服务
tools, cleanup, err := mcp.ConnectStdioServer(ctx, "npx", "-y",
    "@modelcontextprotocol/server-filesystem", "/tmp")
if err != nil {
    log.Fatal(err)
}
defer cleanup()

for _, t := range tools {
    fmt.Printf("Tool: %s - %s\n", t.Name(), t.Description())
}

func ConnectStdioServerV2 

func ConnectStdioServerV2(ctx context.Context, command string, args ...string) ([]tool.Tool, func(), error)

ConnectStdioServerV2 使用官方 SDK 连接 Stdio MCP Server

启动子进程并通过 stdin/stdout 通信。 返回的 cleanup 函数会终止子进程并释放资源。

示例： 

tools, cleanup, err := mcp.ConnectStdioServerV2(ctx, "npx", "-y", "@modelcontextprotocol/server-filesystem", "/tmp")
defer cleanup()

func ConnectStdioServerV2WithEnv 

func ConnectStdioServerV2WithEnv(ctx context.Context, command string, env map[string]string, args ...string) ([]tool.Tool, func(), error)

ConnectStdioServerV2WithEnv 同 ConnectStdioServerV2，但向子进程注入额外环境变量。

数据连接器走 MCP 的地基：MySQL/Redis 等 stdio MCP server 通过 env 配置连接信息 （如 MYSQL_HOST / MYSQL_PASSWORD）。env 合并进 os.Environ()（保留 PATH 等，否则 npx/uvx 不可用）。

示例： 

tools, cleanup, err := mcp.ConnectStdioServerV2WithEnv(ctx, "npx",
    map[string]string{"MYSQL_HOST": "localhost"}, "-y", "@benborla29/mcp-server-mysql")

func ConnectStreamableServerV2 

func ConnectStreamableServerV2(ctx context.Context, endpoint string) ([]tool.Tool, io.Closer, error)

ConnectStreamableServerV2 uses Streamable HTTP transport (MCP 2025-03-26 standard).

Single-endpoint bidirectional communication via HTTP POST + optional SSE response.

Example: 

tools, closer, err := mcp.ConnectStreamableServerV2(ctx, "http://localhost:8080/mcp")
defer closer.Close()

func SchemaFromMCP 

func SchemaFromMCP(js *JSONSchema) *llm.Schema

SchemaFromMCP 将 MCP JSONSchema 转换为 ai-core Schema

支持的字段映射：

  • Type -> Type
  • Description -> Description
  • Properties -> Properties (递归转换)
  • Required -> Required
  • Items -> Items (数组元素)
  • Enum -> Enum

示例： 

mcpTools, _ := client.ListTools(ctx)
for _, t := range mcpTools {
    aiSchema := mcp.SchemaFromMCP(t.InputSchema)
}

func WrapMCPTools 

func WrapMCPTools(client *TransportClient, mcpTools []Tool) []tool.Tool

WrapMCPTools 将 MCP 工具列表包装为 ai-core tool.Tool 列表

这是一个便捷函数，用于快速将 MCP 工具转换为 Hexagon 可用的工具

示例： 

mcpTools, _ := client.ListTools(ctx)
tools := mcp.WrapMCPTools(client, mcpTools)

Types

type Client 

type Client struct {
	// contains filtered or unexported fields
}

Client MCP 客户端

func NewClient 

func NewClient(endpoint string, opts ...ClientOption) *Client

NewClient 创建 MCP 客户端

func (*Client) CallTool 

func (c *Client) CallTool(ctx context.Context, name string, args map[string]any) (*ToolCallResponse, error)

CallTool 调用工具

func (*Client) GetPrompt 

func (c *Client) GetPrompt(ctx context.Context, name string, args map[string]string) ([]PromptMessage, error)

GetPrompt 获取提示

func (*Client) GetServerCapabilities 

func (c *Client) GetServerCapabilities() *ServerCapabilities

GetServerCapabilities 获取服务器能力

func (*Client) Initialize 

func (c *Client) Initialize(ctx context.Context) error

Initialize 初始化客户端

func (*Client) ListPrompts 

func (c *Client) ListPrompts(ctx context.Context) ([]Prompt, error)

ListPrompts 列出可用提示

func (*Client) ListResources 

func (c *Client) ListResources(ctx context.Context) ([]Resource, error)

ListResources 列出可用资源

func (*Client) ListTools 

func (c *Client) ListTools(ctx context.Context) ([]Tool, error)

ListTools 列出可用工具

func (*Client) ReadResource 

func (c *Client) ReadResource(ctx context.Context, uri string) (*ResourceContent, error)

ReadResource 读取资源

type ClientOption 

type ClientOption func(*Client)

ClientOption 客户端选项

func WithHTTPClientOption 

func WithHTTPClientOption(client *http.Client) ClientOption

WithHTTPClientOption 设置 HTTP 客户端

type ContentBlock 

type ContentBlock struct {
	Type     string `json:"type"`
	Text     string `json:"text,omitempty"`
	Data     string `json:"data,omitempty"`
	MimeType string `json:"mimeType,omitempty"`
}

ContentBlock 内容块

type HTTPTransport 

type HTTPTransport struct {
	// contains filtered or unexported fields
}

HTTPTransport HTTP 传输层实现

通过 HTTP POST 请求与 MCP 服务器通信，使用 JSON-RPC 2.0 协议。

示例： 

transport := mcp.NewHTTPTransport("http://localhost:8080")
client := mcp.NewClientWithTransport(transport)

func NewHTTPTransport 

func NewHTTPTransport(endpoint string, opts ...HTTPTransportOption) *HTTPTransport

NewHTTPTransport 创建 HTTP 传输层

endpoint 是 MCP 服务器的 HTTP 地址，如 "http://localhost:8080"

示例： 

transport := mcp.NewHTTPTransport("http://localhost:8080",
    mcp.WithTimeout(60*time.Second),
)

func (*HTTPTransport) Close 

func (t *HTTPTransport) Close() error

Close 关闭 HTTP 传输层

func (*HTTPTransport) Send 

func (t *HTTPTransport) Send(ctx context.Context, req *MCPRequest) (*MCPResponse, error)

Send 发送 MCP 请求

type HTTPTransportOption 

type HTTPTransportOption func(*HTTPTransport)

HTTPTransportOption HTTP 传输层选项

func WithHTTPClient 

func WithHTTPClient(client *http.Client) HTTPTransportOption

WithHTTPClient 设置自定义 HTTP 客户端

func WithTimeout 

func WithTimeout(timeout time.Duration) HTTPTransportOption

WithTimeout 设置超时时间

type HexagonToolAdapter deprecated 

type HexagonToolAdapter struct {
	// contains filtered or unexported fields
}

HexagonToolAdapter 将 Hexagon 工具转换为 MCP 工具（兼容旧版本）

Deprecated: 请使用 Server.RegisterAICoreTool

func NewHexagonToolAdapter deprecated 

func NewHexagonToolAdapter(server *Server) *HexagonToolAdapter

NewHexagonToolAdapter 创建 Hexagon 工具适配器

Deprecated: 请使用 Server.RegisterAICoreTools

func (*HexagonToolAdapter) RegisterToolDefinition 

func (a *HexagonToolAdapter) RegisterToolDefinition(def ToolDefinition)

RegisterToolDefinition 注册工具定义为 MCP 工具

func (*HexagonToolAdapter) RegisterToolDefinitions 

func (a *HexagonToolAdapter) RegisterToolDefinitions(defs []ToolDefinition)

RegisterToolDefinitions 批量注册工具定义

type JSONSchema 

type JSONSchema struct {
	Type        string                 `json:"type"`
	Properties  map[string]*JSONSchema `json:"properties,omitempty"`
	Required    []string               `json:"required,omitempty"`
	Description string                 `json:"description,omitempty"`
	Enum        []any                  `json:"enum,omitempty"`
	Items       *JSONSchema            `json:"items,omitempty"`
}

JSONSchema JSON Schema 定义

func SchemaToMCP 

func SchemaToMCP(s *llm.Schema) *JSONSchema

SchemaToMCP 将 ai-core Schema 转换为 MCP JSONSchema

支持的字段映射：

  • Type -> Type
  • Description -> Description
  • Properties -> Properties (递归转换)
  • Required -> Required
  • Items -> Items (数组元素)
  • Enum -> Enum

示例： 

aiSchema := llm.SchemaOf[MyInput]()
mcpSchema := mcp.SchemaToMCP(aiSchema)

type LoggingCapability 

type LoggingCapability struct{}

LoggingCapability 日志能力

type MCPError 

type MCPError struct {
	Code    int    `json:"code"`
	Message string `json:"message"`
	Data    any    `json:"data,omitempty"`
}

MCPError MCP 错误

type MCPProxyTool 

type MCPProxyTool struct {
	// contains filtered or unexported fields
}

MCPProxyTool 将远程 MCP 工具包装为 ai-core tool.Tool

这是 MCP 适配层的核心组件，它允许将任意 MCP 服务器上的工具 直接用于 Hexagon Agent，无需任何额外适配代码。

示例： 

// 连接 MCP 服务器并获取工具
tools, _ := mcp.ConnectMCPServer(ctx, "http://localhost:8080")

// 直接用于 Agent
agent := agent.New(
    agent.WithTools(tools...),
)

func NewMCPProxyTool 

func NewMCPProxyTool(mcpTool Tool, client *TransportClient) *MCPProxyTool

NewMCPProxyTool 创建 MCP 代理工具

mcpTool 是从 MCP 服务器获取的工具定义 client 是用于调用工具的传输客户端

func (*MCPProxyTool) Description 

func (t *MCPProxyTool) Description() string

Description 返回工具描述

func (*MCPProxyTool) Execute 

func (t *MCPProxyTool) Execute(ctx context.Context, args map[string]any) (tool.Result, error)

Execute 执行工具

将调用请求发送到远程 MCP 服务器，并将响应转换为 tool.Result

func (*MCPProxyTool) Name 

func (t *MCPProxyTool) Name() string

Name 返回工具名称

func (*MCPProxyTool) Schema 

func (t *MCPProxyTool) Schema() *llm.Schema

Schema 返回工具参数的 JSON Schema

func (*MCPProxyTool) Validate 

func (t *MCPProxyTool) Validate(args map[string]any) error

Validate 验证参数

type MCPProxyToolV2 

type MCPProxyToolV2 struct {
	// contains filtered or unexported fields
}

MCPProxyToolV2 将官方 SDK 获取的远程 MCP 工具包装为 ai-core tool.Tool

使用官方 Go SDK 通信，支持最新协议特性。

示例： 

tools, closer, _ := mcp.ConnectMCPServerV2(ctx, transport)
defer closer.Close()
agent := agent.New(agent.WithTools(tools...))

func (*MCPProxyToolV2) Description 

func (t *MCPProxyToolV2) Description() string

func (*MCPProxyToolV2) Execute 

func (t *MCPProxyToolV2) Execute(ctx context.Context, args map[string]any) (tool.Result, error)

Execute 调用远程 MCP 工具

func (*MCPProxyToolV2) Name 

func (t *MCPProxyToolV2) Name() string

func (*MCPProxyToolV2) Schema 

func (t *MCPProxyToolV2) Schema() *llm.Schema

func (*MCPProxyToolV2) Validate 

func (t *MCPProxyToolV2) Validate(args map[string]any) error

Validate 校验工具参数

type MCPRequest 

type MCPRequest struct {
	JSONRPC string `json:"jsonrpc"`
	ID      any    `json:"id,omitempty"`
	Method  Method `json:"method"`
	Params  any    `json:"params,omitempty"`
}

MCPRequest MCP 请求

type MCPResponse 

type MCPResponse struct {
	JSONRPC string    `json:"jsonrpc"`
	ID      any       `json:"id,omitempty"`
	Result  any       `json:"result,omitempty"`
	Error   *MCPError `json:"error,omitempty"`
}

MCPResponse MCP 响应

type MCPToolAdapter deprecated 

type MCPToolAdapter struct {
	// contains filtered or unexported fields
}

MCPToolAdapter 将 MCP 工具转换为可调用格式（兼容旧版本）

Deprecated: 请使用 ConnectMCPServer 或 MCPProxyTool

func LoadMCPTools deprecated 

func LoadMCPTools(ctx context.Context, endpoint string) (*MCPToolAdapter, error)

LoadMCPTools 从 MCP 服务器加载工具

Deprecated: 请使用 ConnectMCPServer

func NewMCPToolAdapter deprecated 

func NewMCPToolAdapter(client *Client) *MCPToolAdapter

NewMCPToolAdapter 创建 MCP 工具适配器

Deprecated: 请使用 ConnectMCPServer

func (*MCPToolAdapter) CallTool 

func (a *MCPToolAdapter) CallTool(ctx context.Context, name string, args map[string]any) (string, error)

CallTool 调用 MCP 工具

func (*MCPToolAdapter) GetMCPTools 

func (a *MCPToolAdapter) GetMCPTools() []Tool

GetMCPTools 获取 MCP 工具列表

func (*MCPToolAdapter) LoadTools 

func (a *MCPToolAdapter) LoadTools(ctx context.Context) error

LoadTools 从 MCP 服务器加载工具

type MCPToolSet 

type MCPToolSet struct {
	// contains filtered or unexported fields
}

MCPToolSet 管理一组来自同一 MCP 服务器的工具

使用 MCPToolSet 可以方便地管理多个 MCP 工具， 并提供统一的生命周期管理（如关闭连接）

func ConnectMCPServerWithToolSet deprecated 

func ConnectMCPServerWithToolSet(ctx context.Context, endpoint string) (*MCPToolSet, error)

ConnectMCPServerWithToolSet 连接 MCP 服务器并返回工具集合

Deprecated: 请使用 ConnectMCPServerV2，基于官方 Go SDK 实现。

与 ConnectMCPServer 类似，但返回 MCPToolSet 以便管理生命周期

示例： 

toolSet, err := mcp.ConnectMCPServerWithToolSet(ctx, "http://localhost:8080")
if err != nil {
    log.Fatal(err)
}
defer toolSet.Close()

agent := agent.New(
    agent.WithTools(toolSet.Tools()...),
)

func ConnectStdioServerWithToolSet deprecated 

func ConnectStdioServerWithToolSet(ctx context.Context, command string, args ...string) (*MCPToolSet, func(), error)

ConnectStdioServerWithToolSet 连接本地 MCP 进程并返回工具集合

Deprecated: 请使用 ConnectStdioServerV2，基于官方 Go SDK 实现。

与 ConnectStdioServer 类似，但返回 MCPToolSet 以便管理生命周期

示例： 

toolSet, cleanup, err := mcp.ConnectStdioServerWithToolSet(ctx,
    "npx", "-y", "@modelcontextprotocol/server-filesystem", "/tmp")
if err != nil {
    log.Fatal(err)
}
defer cleanup()

agent := agent.New(
    agent.WithTools(toolSet.Tools()...),
)

func NewMCPToolSet 

func NewMCPToolSet(client *TransportClient, mcpTools []Tool) *MCPToolSet

NewMCPToolSet 从 MCP 服务器创建工具集合

func (*MCPToolSet) Close 

func (s *MCPToolSet) Close() error

Close 关闭工具集合（关闭底层传输连接）

func (*MCPToolSet) Get 

func (s *MCPToolSet) Get(name string) (tool.Tool, bool)

Get 按名称获取工具

func (*MCPToolSet) HandleListChanged 

func (s *MCPToolSet) HandleListChanged(ctx context.Context) error

HandleListChanged 是 MCP notifications/tools/list_changed 通知的处理入口， 语义等价于 Refresh——收到该通知时调用即可动态更新工具集。

func (*MCPToolSet) Reconnect 

func (s *MCPToolSet) Reconnect(ctx context.Context) error

Reconnect 主动按指数退避重连远端 MCP 服务器并刷新工具集。

未设置策略时使用 DefaultReconnectConfig。重连恢复连接后会重新拉取工具列表 并触发 OnToolsChanged 回调。重试耗尽仍失败则返回错误。

注意：本方法重试的是初始化握手，可恢复传输层能自愈的瞬时故障（HTTP/SSE 抖动、服务器重启后可重新连上）。对子进程已退出的 stdio 传输，进程重启属传输 层职责，本层重试会耗尽并返回错误。

func (*MCPToolSet) Refresh 

func (s *MCPToolSet) Refresh(ctx context.Context) error

Refresh 重新从 MCP 服务器拉取工具列表并重建工具集（动态发现）。

适用场景：收到 notifications/tools/list_changed 通知时、或需要主动刷新远端 工具时调用。客户端在初始化握手中已声明 tools.listChanged 能力，服务器据此 在工具集变化时推送通知；上层把通知路由到本方法即可实现动态工具发现。 成功刷新后若注册了 OnToolsChanged 回调会被触发。 若配置了重连策略（SetReconnectPolicy），首次拉取失败时会按指数退避自动重连 后再列一次；重连仍失败才返回错误。未配置策略时行为不变（失败即返回）。

func (*MCPToolSet) SetOnToolsChanged 

func (s *MCPToolSet) SetOnToolsChanged(fn func([]tool.Tool))

SetOnToolsChanged 注册工具集变化回调。

Refresh 重建工具集后会触发该回调，便于上层（如 Agent 工具注册表）同步 动态发现的工具集。传 nil 可清除回调。

func (*MCPToolSet) SetReconnectPolicy 

func (s *MCPToolSet) SetReconnectPolicy(cfg *ReconnectConfig)

SetReconnectPolicy 设置工具集的自动重连策略。

设置后，Refresh 在拉取失败时会按该策略指数退避重连；传 nil 关闭自动重连。

func (*MCPToolSet) Tools 

func (s *MCPToolSet) Tools() []tool.Tool

Tools 返回所有工具（并发安全：与 Refresh 互斥）

type MessageType 

type MessageType string

MessageType 消息类型 

const (
	MessageTypeRequest      MessageType = "request"
	MessageTypeResponse     MessageType = "response"
	MessageTypeNotification MessageType = "notification"
)

type Method 

type Method string

Method MCP 方法 

const (
	// 初始化
	MethodInitialize Method = "initialize"

	// 工具相关
	MethodToolsList Method = "tools/list"
	MethodToolsCall Method = "tools/call"

	// 资源相关
	MethodResourcesList      Method = "resources/list"
	MethodResourcesRead      Method = "resources/read"
	MethodResourcesSubscribe Method = "resources/subscribe"

	// 提示相关
	MethodPromptsList Method = "prompts/list"
	MethodPromptsGet  Method = "prompts/get"

	// 采样
	MethodSamplingCreateMessage Method = "sampling/createMessage"

	// 日志
	MethodLoggingSetLevel Method = "logging/setLevel"
)

type Prompt 

type Prompt struct {
	Name        string           `json:"name"`
	Description string           `json:"description,omitempty"`
	Arguments   []PromptArgument `json:"arguments,omitempty"`
}

Prompt MCP 提示模板

type PromptArgument 

type PromptArgument struct {
	Name        string `json:"name"`
	Description string `json:"description,omitempty"`
	Required    bool   `json:"required,omitempty"`
}

PromptArgument 提示参数

type PromptHandler 

type PromptHandler func(ctx context.Context, args map[string]string) ([]PromptMessage, error)

PromptHandler 提示处理函数

type PromptMessage 

type PromptMessage struct {
	Role    string       `json:"role"`
	Content ContentBlock `json:"content"`
}

PromptMessage 提示消息

type PromptsCapability 

type PromptsCapability struct {
	ListChanged bool `json:"listChanged,omitempty"`
}

PromptsCapability 提示能力

type ReconnectConfig 

type ReconnectConfig struct {
	// MaxAttempts 最大尝试次数（含首次）；零值表示执行一次、零次重试
	MaxAttempts int
	// InitialDelay 首次重试前的等待；零值使用默认值
	InitialDelay time.Duration
	// MaxDelay 退避上限；零值使用默认值
	MaxDelay time.Duration
	// Multiplier 退避倍数（指数退避）；零值使用默认值
	Multiplier float64
}

ReconnectConfig 自动重连策略。

退避序列：第 n 次重试等待 min(InitialDelay × Multiplier^(n-1), MaxDelay)。

func DefaultReconnectConfig 

func DefaultReconnectConfig() *ReconnectConfig

DefaultReconnectConfig 默认重连策略：最多 5 次、初始 500ms、上限 30s、倍数 2.0。

type RegisteredPrompt 

type RegisteredPrompt struct {
	Prompt  Prompt
	Handler PromptHandler
}

RegisteredPrompt 注册的提示

type RegisteredResource 

type RegisteredResource struct {
	Resource Resource
	Handler  ResourceHandler
}

RegisteredResource 注册的资源

type RegisteredTool 

type RegisteredTool struct {
	Tool    Tool
	Handler ToolHandler
}

RegisteredTool 注册的工具

type Resource 

type Resource struct {
	URI         string `json:"uri"`
	Name        string `json:"name"`
	Description string `json:"description,omitempty"`
	MimeType    string `json:"mimeType,omitempty"`
}

Resource MCP 资源

type ResourceContent 

type ResourceContent struct {
	URI      string `json:"uri"`
	MimeType string `json:"mimeType,omitempty"`
	Text     string `json:"text,omitempty"`
	Blob     string `json:"blob,omitempty"`
}

ResourceContent 资源内容

type ResourceHandler 

type ResourceHandler func(ctx context.Context) (*ResourceContent, error)

ResourceHandler 资源处理函数

type ResourcesCapability 

type ResourcesCapability struct {
	Subscribe   bool `json:"subscribe,omitempty"`
	ListChanged bool `json:"listChanged,omitempty"`
}

ResourcesCapability 资源能力

type Server 

type Server struct {
	// contains filtered or unexported fields
}

Server MCP 服务器

func NewServer 

func NewServer(config *ServerConfig) *Server

NewServer 创建 MCP 服务器

func ServeMCPTools deprecated 

func ServeMCPTools(addr string, tools []ToolDefinition) (*Server, error)

ServeMCPTools 将工具定义作为 MCP 服务器暴露

Deprecated: 请使用 ServeMCPToolsFromAICore

func ServeMCPToolsFromAICore 

func ServeMCPToolsFromAICore(addr string, tools ...tool.Tool) (*Server, error)

ServeMCPToolsFromAICore 将 ai-core 工具作为 MCP 服务暴露

这是一个便捷函数，一行代码即可启动 MCP 服务

示例： 

calculator := tool.NewFunc("calc", "计算器", calcFn)
searcher := tool.NewFunc("search", "搜索", searchFn)

server, err := mcp.ServeMCPToolsFromAICore(":8080", calculator, searcher)
if err != nil {
    log.Fatal(err)
}
defer server.Stop(context.Background())

func (*Server) RegisterAICoreTool 

func (s *Server) RegisterAICoreTool(t tool.Tool)

RegisterAICoreTool 将 ai-core tool.Tool 注册到 MCP 服务器

这允许将 Hexagon 工具暴露为 MCP 服务，供其他 MCP 客户端调用

示例： 

calculator := tool.NewFunc("calc", "计算器", calcFn)
server.RegisterAICoreTool(calculator)

func (*Server) RegisterAICoreTools 

func (s *Server) RegisterAICoreTools(tools ...tool.Tool)

RegisterAICoreTools 批量注册 ai-core 工具

示例： 

server.RegisterAICoreTools(calculator, searcher, fileReader)

func (*Server) RegisterPrompt 

func (s *Server) RegisterPrompt(prompt Prompt, handler PromptHandler)

RegisterPrompt 注册提示

func (*Server) RegisterResource 

func (s *Server) RegisterResource(resource Resource, handler ResourceHandler)

RegisterResource 注册资源

func (*Server) RegisterTool 

func (s *Server) RegisterTool(tool Tool, handler ToolHandler)

RegisterTool 注册工具

func (*Server) Start 

func (s *Server) Start() error

Start 启动服务器

func (*Server) Stop 

func (s *Server) Stop(ctx context.Context) error

Stop 停止服务器

type ServerCapabilities 

type ServerCapabilities struct {
	Tools     *ToolsCapability     `json:"tools,omitempty"`
	Resources *ResourcesCapability `json:"resources,omitempty"`
	Prompts   *PromptsCapability   `json:"prompts,omitempty"`
	Logging   *LoggingCapability   `json:"logging,omitempty"`
}

ServerCapabilities 服务器能力

type ServerConfig 

type ServerConfig struct {
	Name    string `json:"name"`
	Version string `json:"version"`
	Addr    string `json:"addr"`
}

ServerConfig 服务器配置

func DefaultServerConfig 

func DefaultServerConfig() *ServerConfig

DefaultServerConfig 默认服务器配置

type ServerV2 

type ServerV2 struct {
	// contains filtered or unexported fields
}

ServerV2 基于官方 SDK 的 MCP 服务器

将 Hexagon/ai-core 工具暴露为标准 MCP 服务， 支持 Stdio 和 HTTP 两种运行模式。

示例： 

server := mcp.NewMCPServerV2("my-tools", "1.0.0")
server.RegisterTool(myCalculator)
server.RegisterTool(myFileReader)

// Stdio 模式（CLI 工具）
server.ServeStdio(ctx)

// 或 HTTP 模式
server.ServeHTTP(ctx, ":8080")

func NewMCPServerV2 

func NewMCPServerV2(name, version string) *ServerV2

NewMCPServerV2 创建基于官方 SDK 的 MCP 服务器

func (*ServerV2) HTTPHandler 

func (s *ServerV2) HTTPHandler() http.Handler

HTTPHandler 返回基于 Streamable HTTP 传输的 http.Handler。

适合挂载到调用方自己的 mux/路由（如鉴权中间件之后），所有请求复用本服务器实例。 Streamable HTTP 是 MCP 的现代远程传输（单端点 POST + 可选 SSE 响应）。

func (*ServerV2) RegisterTool 

func (s *ServerV2) RegisterTool(t tool.Tool)

RegisterTool 注册单个 ai-core 工具到 MCP 服务器

自动将 ai-core Schema 转换为 MCP InputSchema

func (*ServerV2) RegisterTools 

func (s *ServerV2) RegisterTools(tools ...tool.Tool)

RegisterTools 批量注册 ai-core 工具

func (*ServerV2) SSEHandler 

func (s *ServerV2) SSEHandler() http.Handler

SSEHandler 返回基于 SSE 传输的 http.Handler（兼容较旧的 SSE 客户端）。

func (*ServerV2) ServeHTTP 

func (s *ServerV2) ServeHTTP(ctx context.Context, addr string) error

ServeHTTP 以 Streamable HTTP 模式在 addr 上运行 MCP 服务器。

阻塞直到 ctx 取消（取消时优雅关闭，最长等待 5s）。需要把 handler 挂到既有 HTTP 服务时改用 HTTPHandler()。

注意：本方法签名为 (ctx, addr)，与 http.Handler.ServeHTTP(w, r) 不同， ServerV2 不是 http.Handler。

func (*ServerV2) ServeSSE 

func (s *ServerV2) ServeSSE(ctx context.Context, addr string) error

ServeSSE 以 SSE 模式在 addr 上运行 MCP 服务器（兼容旧客户端）。

func (*ServerV2) ServeStdio 

func (s *ServerV2) ServeStdio(ctx context.Context) error

ServeStdio 以 Stdio 模式运行 MCP 服务器

通过 stdin/stdout 与客户端通信，适合作为 CLI 工具或 IDE 插件。 阻塞直到 context 取消或连接断开。

func (*ServerV2) Server 

func (s *ServerV2) Server() *sdkmcp.Server

Server 返回底层官方 SDK Server，用于高级配置

type StdioTransport 

type StdioTransport struct {
	// contains filtered or unexported fields
}

StdioTransport 标准输入输出传输层

通过 stdin/stdout 与本地 MCP 进程通信。 适用于 npx、uvx 等工具启动的本地 MCP 服务。

通信协议：

  • 每行一个 JSON-RPC 消息（以换行符分隔）
  • 请求发送到进程的 stdin
  • 响应从进程的 stdout 读取

示例： 

// 连接 filesystem MCP 服务
transport, cleanup, err := mcp.NewStdioTransport("npx", "-y",
    "@modelcontextprotocol/server-filesystem", "/tmp")
if err != nil {
    log.Fatal(err)
}
defer cleanup()

client := mcp.NewTransportClient(transport)

func NewStdioTransport 

func NewStdioTransport(command string, args ...string) (*StdioTransport, func(), error)

NewStdioTransport 创建 Stdio 传输层

command 是要执行的命令，args 是命令参数

返回值：

  • transport: Stdio 传输层实例
  • cleanup: 清理函数，用于关闭进程和释放资源
  • error: 错误信息

示例： 

// 使用 npx 启动 MCP 服务
transport, cleanup, err := mcp.NewStdioTransport("npx", "-y",
    "@modelcontextprotocol/server-filesystem", "/tmp")
if err != nil {
    log.Fatal(err)
}
defer cleanup()

// 使用 uvx 启动 Python MCP 服务
transport, cleanup, err := mcp.NewStdioTransport("uvx", "mcp-server-fetch")

func (*StdioTransport) Close 

func (t *StdioTransport) Close() error

Close 关闭 Stdio 传输层

func (*StdioTransport) Send 

func (t *StdioTransport) Send(ctx context.Context, req *MCPRequest) (*MCPResponse, error)

Send 发送 MCP 请求

type Tool 

type Tool struct {
	Name        string      `json:"name"`
	Description string      `json:"description,omitempty"`
	InputSchema *JSONSchema `json:"inputSchema"`
}

Tool MCP 工具定义

func ToolToMCPTool 

func ToolToMCPTool(t interface {
	Name() string
	Description() string
	Schema() *llm.Schema
}) Tool

ToolToMCPTool 将 ai-core tool.Tool 转换为 MCP Tool 定义

这是一个便捷函数，用于将 Hexagon 工具暴露为 MCP 服务时使用

示例： 

calculator := tool.NewFunc("calc", "计算器", calcFn)
mcpTool := mcp.ToolToMCPTool(calculator)

type ToolCallRequest 

type ToolCallRequest struct {
	Name      string         `json:"name"`
	Arguments map[string]any `json:"arguments,omitempty"`
}

ToolCallRequest 工具调用请求

type ToolCallResponse 

type ToolCallResponse struct {
	Content []ContentBlock `json:"content"`
	IsError bool           `json:"isError,omitempty"`
}

ToolCallResponse 工具调用响应

type ToolDefinition deprecated 

type ToolDefinition struct {
	Name        string         `json:"name"`
	Description string         `json:"description"`
	Parameters  map[string]any `json:"parameters,omitempty"`
	Handler     func(ctx context.Context, args map[string]any) (string, error)
}

ToolDefinition 工具定义（兼容旧版本）

Deprecated: 请使用 ai-core tool.Tool 接口

type ToolHandler 

type ToolHandler func(ctx context.Context, args map[string]any) (*ToolCallResponse, error)

ToolHandler 工具处理函数

type ToolsCapability 

type ToolsCapability struct {
	ListChanged bool `json:"listChanged,omitempty"`
}

ToolsCapability 工具能力

type Transport 

type Transport interface {
	// Send 发送 MCP 请求并返回响应
	// 实现应该处理 JSON-RPC 2.0 格式的请求和响应
	Send(ctx context.Context, req *MCPRequest) (*MCPResponse, error)

	// Close 关闭传输层
	// 释放相关资源（如进程句柄、网络连接等）
	Close() error
}

Transport MCP 传输层接口

Transport 定义了 MCP 客户端与服务器通信的方式。 支持多种实现：HTTP、Stdio 等。

type TransportClient 

type TransportClient struct {
	// contains filtered or unexported fields
}

TransportClient 基于 Transport 的 MCP 客户端

与 Client 类似，但使用 Transport 接口而非固定的 HTTP 通信

func NewTransportClient 

func NewTransportClient(transport Transport) *TransportClient

NewTransportClient 创建基于 Transport 的客户端

示例： 

// HTTP 传输
transport := mcp.NewHTTPTransport("http://localhost:8080")
client := mcp.NewTransportClient(transport)

// Stdio 传输
transport, _ := mcp.NewStdioTransport("npx", "-y", "@modelcontextprotocol/server-filesystem", "/tmp")
client := mcp.NewTransportClient(transport)

func (*TransportClient) CallTool 

func (c *TransportClient) CallTool(ctx context.Context, name string, args map[string]any) (*ToolCallResponse, error)

CallTool 调用工具

func (*TransportClient) Close 

func (c *TransportClient) Close() error

Close 关闭客户端

func (*TransportClient) GetPrompt 

func (c *TransportClient) GetPrompt(ctx context.Context, name string, args map[string]string) ([]PromptMessage, error)

GetPrompt 获取提示

func (*TransportClient) GetServerCapabilities 

func (c *TransportClient) GetServerCapabilities() *ServerCapabilities

GetServerCapabilities 获取服务器能力

func (*TransportClient) Initialize 

func (c *TransportClient) Initialize(ctx context.Context) error

Initialize 初始化客户端

func (*TransportClient) ListPrompts 

func (c *TransportClient) ListPrompts(ctx context.Context) ([]Prompt, error)

ListPrompts 列出可用提示

func (*TransportClient) ListResources 

func (c *TransportClient) ListResources(ctx context.Context) ([]Resource, error)

ListResources 列出可用资源

func (*TransportClient) ListTools 

func (c *TransportClient) ListTools(ctx context.Context) ([]Tool, error)

ListTools 列出可用工具

func (*TransportClient) ReadResource 

func (c *TransportClient) ReadResource(ctx context.Context, uri string) (*ResourceContent, error)

ReadResource 读取资源

func (*TransportClient) Transport 

func (c *TransportClient) Transport() Transport

Transport 返回底层传输层

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.