跳至主要內容

第1941篇：Model Context Protocol（MCP）深度解析——AI工具集成的新标准

老张2026/4/30大约 10 分钟

第1941篇：Model Context Protocol（MCP）深度解析——AI工具集成的新标准

去年底Anthropic发布MCP的时候，我第一反应是"又一个造轮子的协议"。但真正动手用了一个月之后，我改变了看法。MCP解决的问题不是"怎么调用工具"，而是"怎么让AI系统和工具之间建立一种可以互信、可以互操作的关系"。这两者差距挺大的。

今天把我的理解和踩过的坑都写出来，如果你在做AI工具集成，这篇可能会帮你少走不少弯路。

为什么会有MCP

在MCP出现之前，我们做AI工具集成是什么状态？

每个AI框架都有自己的工具调用规范。OpenAI有Function Calling，LangChain有Tool接口，AutoGPT有插件机制。表面上看都差不多——定义一个函数描述，让模型决定什么时候调用，调用的时候传参数进来，拿到结果再继续。

问题在于：这些工具是绑定在具体框架上的。你给LangChain写的工具，换到Autogen就得重写一遍。更烦的是，有些工具是有状态的——比如你要让AI操作一个数据库连接，这个连接是要复用的，但大多数Function Calling设计压根不考虑这件事。

另一个问题是上下文。AI需要知道当前环境是什么样的，才能正确地使用工具。比如"当前打开的文件是什么"、"数据库里有哪些表"——这些不是工具调用结果，而是环境上下文，过去基本靠开发者手动塞进prompt里，既粗糙又不可扩展。

MCP想做的事情，是把"给AI用的工具"这件事标准化，定义一套Server/Client协议，让工具提供方和AI应用方可以按照统一的规范对接，互不依赖。

MCP的核心架构

MCP是一个基于JSON-RPC 2.0的客户端-服务端协议，传输层支持标准输入输出（stdio）和HTTP+SSE两种方式。

架构里有几个核心概念要搞清楚：

Resources（资源）：服务端提供的数据，类似REST的资源概念。客户端可以读取，比如文件内容、数据库记录。资源是被动的，不执行逻辑。

Tools（工具）：可执行的函数。客户端发起调用，服务端执行并返回结果。这是MCP里最核心的能力。

Prompts（提示模板）：服务端定义的提示词模板，客户端可以列举和使用。这个功能很多人忽略，但在企业场景里挺有用——把标准化的操作流程封装成Prompt，AI不用每次从头推理。

Sampling（采样回调）：这是MCP里最有意思也最少被讨论的特性。服务端可以请求客户端（AI宿主）做一次推理。换句话说，工具可以主动"问AI一个问题"。这为实现真正自主的AI工具开了个口子。

用Java实现一个MCP Server

先从最简单的例子入手，写一个能查询数据库的MCP服务端。目前Java生态里MCP的SDK选择不多，官方的@modelcontextprotocol/sdk是TypeScript的，Java这边用得比较多的是Spring团队在Spring AI里内置的MCP支持，或者直接自己实现JSON-RPC层。

我下面演示的是Spring AI的方案，因为实际项目里Spring用得最多，集成起来最顺手。

引入依赖：

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-mcp-server-spring-boot-starter</artifactId>
    <version>1.0.0-M6</version>
</dependency>

定义工具类：

@Component
public class DatabaseQueryTool {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 执行SQL查询并返回结果
     * 注意：实际生产中要做SQL注入防护，这里为了演示简化了
     */
    @Tool(description = "执行只读SQL查询，返回查询结果的JSON字符串。只支持SELECT语句。")
    public String executeQuery(
            @ToolParam(description = "要执行的SELECT SQL语句") String sql,
            @ToolParam(description = "最大返回行数，默认100") Integer maxRows) {

        if (!sql.trim().toUpperCase().startsWith("SELECT")) {
            return "{\"error\": \"只允许SELECT查询\"}";
        }

        int limit = maxRows != null ? Math.min(maxRows, 500) : 100;

        try {
            List<Map<String, Object>> rows = jdbcTemplate.queryForList(
                sql + " LIMIT " + limit
            );
            return new ObjectMapper().writeValueAsString(rows);
        } catch (Exception e) {
            return "{\"error\": \"" + e.getMessage() + "\"}";
        }
    }

    @Tool(description = "列出数据库中所有可用的表名")
    public String listTables() {
        try {
            List<Map<String, Object>> tables = jdbcTemplate.queryForList(
                "SELECT table_name FROM information_schema.tables " +
                "WHERE table_schema = DATABASE()"
            );
            List<String> tableNames = tables.stream()
                .map(row -> (String) row.get("table_name"))
                .collect(Collectors.toList());
            return new ObjectMapper().writeValueAsString(tableNames);
        } catch (Exception e) {
            return "{\"error\": \"" + e.getMessage() + "\"}";
        }
    }

    @Tool(description = "获取指定表的字段结构信息")
    public String describeTable(
            @ToolParam(description = "表名") String tableName) {
        try {
            List<Map<String, Object>> columns = jdbcTemplate.queryForList(
                "SELECT column_name, data_type, is_nullable, column_comment " +
                "FROM information_schema.columns " +
                "WHERE table_schema = DATABASE() AND table_name = ?",
                tableName
            );
            return new ObjectMapper().writeValueAsString(columns);
        } catch (Exception e) {
            return "{\"error\": \"" + e.getMessage() + "\"}";
        }
    }
}

配置MCP Server：

@Configuration
public class McpServerConfig {

    @Bean
    public McpServerFeatures.SyncToolsRegistrar toolsRegistrar(
            DatabaseQueryTool databaseQueryTool) {
        return registry -> {
            // Spring AI会自动从@Tool注解扫描，这里做额外注册示例
            registry.register(ToolDefinition.builder()
                .name("execute_raw_query")
                .description("执行复杂的多表关联查询")
                .inputSchema(/* JSON Schema */ "...")
                .handler(params -> databaseQueryTool.executeQuery(
                    params.get("sql").toString(),
                    Integer.parseInt(params.getOrDefault("maxRows", "100").toString())
                ))
                .build());
        };
    }

    @Bean
    public McpServerFeatures.SyncResourcesRegistrar resourcesRegistrar() {
        return registry -> {
            // 注册数据库元信息作为资源
            registry.register(ResourceDefinition.builder()
                .uri("db://schema/overview")
                .name("数据库概览")
                .description("当前数据库的结构概览，包含所有表和关键字段")
                .mimeType("application/json")
                .handler(() -> {
                    // 返回数据库结构的静态快照
                    return ResourceContent.text(loadSchemaOverview());
                })
                .build());
        };
    }

    private String loadSchemaOverview() {
        // 实际实现中可以缓存这个结果
        return "{ \"tables\": [...] }";
    }
}

启动配置，选择stdio传输（适合本地工具集成）：

spring:
  ai:
    mcp:
      server:
        transport: stdio
        name: "database-mcp-server"
        version: "1.0.0"

MCP Client的Java实现

光有Server还不够，得有Client来调用它。下面展示如何在Spring AI里配置MCP Client：

@Configuration
public class McpClientConfig {

    /**
     * 配置一个连接到本地数据库MCP服务的客户端
     * 这个Server是通过子进程启动的，用stdio通信
     */
    @Bean
    public McpSyncClient databaseMcpClient() {
        // 定义如何启动MCP Server进程
        ServerParameters serverParams = ServerParameters.builder()
            .command("java")
            .args("-jar", "/path/to/database-mcp-server.jar")
            .build();

        McpSyncClient client = McpClient.sync(
            new StdioClientTransport(serverParams)
        ).build();

        // 初始化连接
        client.initialize();
        return client;
    }

    /**
     * 把MCP工具注册到Spring AI的工具体系里
     */
    @Bean
    public List<McpFunctionCallback> mcpFunctionCallbacks(
            McpSyncClient databaseMcpClient) {
        return McpToolUtils.toSyncLangChainTools(databaseMcpClient)
            .stream()
            .map(tool -> new McpFunctionCallback(databaseMcpClient, tool))
            .collect(Collectors.toList());
    }
}

把MCP工具注入到AI对话里：

@Service
public class AiDataAnalysisService {

    @Autowired
    private ChatClient chatClient;

    @Autowired
    private List<McpFunctionCallback> mcpFunctionCallbacks;

    public String analyzeData(String userQuestion) {
        // 构建带工具的ChatClient
        return chatClient.prompt()
            .user(userQuestion)
            .functions(mcpFunctionCallbacks.toArray(new McpFunctionCallback[0]))
            .call()
            .content();
    }
}

踩过的坑

说实话，MCP这套东西看起来简洁，实际上有不少细节坑。

第一个坑：进程生命周期管理

用stdio传输的时候，MCP Server是作为子进程运行的。如果你的主进程崩了或者重启了，子进程怎么处理？Spring AI的默认实现在应用关闭时会发送终止信号，但如果子进程没有正确处理SIGTERM，就会变成孤儿进程。我们在生产上碰过两次服务重启后内存占用一直升的问题，最后排查到是MCP子进程没被清理干净。

解决方案是加一个ShutdownHook：

@PreDestroy
public void cleanup() {
    try {
        databaseMcpClient.closeGracefully().block(Duration.ofSeconds(5));
    } catch (Exception e) {
        log.error("MCP client关闭异常", e);
    }
}

第二个坑：工具描述的质量直接影响模型调用准确率

这个不是工程问题，是体验问题，但影响很大。工具的description写得含糊，模型就会乱调用。我测试过把execute_query的描述从"执行SQL"改成"执行只读SELECT SQL查询，返回JSON格式的结果数组，每行是一个对象"，调用准确率从大约70%提升到90%+。

描述要说清楚：输入是什么格式、输出是什么格式、什么情况下该用这个工具、什么情况下不该用。

第三个坑：Tool调用的循环问题

模型有时候会陷入循环，反复调用同一个工具，每次都稍微改一点参数，然后觉得还不够，继续调。这个问题在ReAct框架下尤其明显。

我们加了一个调用计数器中间件：

@Component
public class ToolCallLimitInterceptor implements ToolCallInterceptor {

    private final ThreadLocal<Map<String, Integer>> callCounts =
        ThreadLocal.withInitial(HashMap::new);

    @Override
    public ToolCallResult intercept(ToolCall toolCall, ToolCallChain chain) {
        Map<String, Integer> counts = callCounts.get();
        String toolName = toolCall.name();

        int count = counts.getOrDefault(toolName, 0);
        if (count >= 5) {
            return ToolCallResult.error(
                "工具 " + toolName + " 已调用" + count + "次，请基于已有信息给出答案"
            );
        }

        counts.put(toolName, count + 1);
        return chain.proceed(toolCall);
    }

    public void reset() {
        callCounts.remove();
    }
}

第四个坑：SSE传输的连接超时

如果用HTTP+SSE模式（适合远程工具服务），长时间没有交互的连接会被Nginx等代理层切断。要么配置心跳，要么在代理层加proxy_read_timeout。我们最初用的默认60秒超时，结果用户稍微等久点就报连接断开。

// SSE客户端配置
McpSyncClient client = McpClient.sync(
    new SseClientTransport(
        WebClient.builder()
            .baseUrl("http://localhost:8080/mcp")
            .defaultHeader("Connection", "keep-alive")
            .build()
    )
).requestTimeout(Duration.ofSeconds(30))
 .build();

企业级MCP架构设计

生产环境里，单一MCP Server显然不够。我们内部用的是一个多层架构：

关键设计决策：

工具路由层：不同的AI应用有权限使用不同的工具集。销售团队的AI助手不应该能操作财务数据库，这个控制要在路由层做，不能靠AI模型自己判断。

审计日志：每次工具调用都要记录——谁调的、什么时间、传了什么参数、返回了什么结果。这是合规要求，也是排查问题的关键。

工具版本管理：工具接口变更要做版本控制，不然工具升级了但有旧版本Client还在跑，会出现奇怪的不兼容问题。

@McpServer(version = "2.0.0")
public class DatabaseQueryToolV2 {

    @Tool(description = "v2: 支持多数据库查询的增强版SQL执行器")
    @ToolVersion(since = "2.0.0", deprecates = "execute_query")
    public QueryResult executeQueryV2(
            @ToolParam("目标数据库") String database,
            @ToolParam("SQL语句") String sql,
            @ToolParam("超时秒数") Integer timeoutSeconds) {
        // 实现...
        return new QueryResult();
    }
}

MCP vs Function Calling：该怎么选

这个问题被问了很多次，我的判断标准：

如果你只是在单个AI应用里加几个工具，用框架原生的Function Calling就够了，引入MCP反而增加复杂度。

如果你有多个AI应用需要共享同一套工具，或者工具需要和AI应用解耦独立部署，MCP的价值就出来了。

如果你的工具有状态（需要维护连接、会话等），MCP的Server模型比无状态的Function定义更合适。

如果你要构建一个企业级的AI能力平台，统一管理所有可供AI调用的工具，MCP是目前最成熟的协议规范。

对MCP未来的判断

我认为MCP会成为AI工具集成事实上的标准，原因不是它技术上多先进，而是Anthropic、微软、Google这几家都在推，Claude Desktop、VS Code Copilot、Google的ADK都在接入。生态一旦形成，网络效应就会让它自我强化。

但MCP现在仍然很早期，规范本身还在快速迭代，Java生态的支持比TypeScript/Python少很多。如果你现在要在生产上用，要做好两件事：

  1. 把MCP依赖隔离在一个适配层里，上层业务不要直接依赖SDK，方便后续版本升级
  2. 做好降级方案，如果MCP调用失败，有本地fallback实现

这是我在实际项目里的经验，不是教条。

编辑此页
最近更新:
贡献者: xiaozhangge