Prompt、Agent、Function Call、Skill、MCP 概念辨析与 Java 实现

这里的 SystemPrompt 和 UserPrompt 就是最基础的 Prompt 形式。

它们决定了 AI 的身份和你要问的问题。

1.2 Prompt 的高级玩法

光有基础 Prompt 还不够，在实际应用中我们经常需要提示词工程来引导 AI 做出更好的回答。比如：

public String generateJavaCode(String requirement) {
    String promptTemplate = """
        你是一个资深的 Java 开发工程师。
        请根据以下需求生成 Java 代码，代码要包含必要的注释，并考虑异常处理：
        需求：%s
        请输出完整的 Java 类代码。
        """;
    String prompt = String.format(promptTemplate, requirement);
    return chatClient.call(new Prompt(prompt)).getResult().getOutput().getContent();
}

Prompt 的本质：它是人类意图与 AI 能力之间的'翻译官'。

Prompt 写得好，AI 才能干得好。

第二层：Function Calling——让 AI 从'说话'到'动手'

Prompt 只能让 AI'说话'，但 AI 想干点实事（比如查数据库、发邮件、调用第三方 API）时，就无能为力了。

Function Calling（函数调用） 就是来解决这个问题的。

2.1 什么是 Function Calling？

Function Calling 允许开发者在调用大模型时，注册一系列函数（工具），模型在生成回复时如果判断需要调用外部工具，就会返回一个结构化的请求，由开发者执行真实的函数，再把结果返回给模型生成最终答案。

原理图如下：

2.2 Java 实现 Function Calling

我用 LangChain4j 来演示，因为它对 Java 开发者很友好。首先定义工具函数：

import dev.langchain4j.agent.tool.Tool;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class WeatherTool {
    @Tool("获取指定城市的实时天气")
    public String getWeather(String city) {
        // 这里应该是真实的 API 调用，为了演示我们模拟数据
        if ("北京".equals(city)) {
            return "北京当前天气：晴，温度 25℃，湿度 40%";
        } else if ("上海".equals(city)) {
            return "上海当前天气：小雨，温度 22℃，湿度 80%";
        } else {
            return "抱歉，暂不支持该城市天气查询";
        }
    }

    @Tool("获取当前时间")
    public String getCurrentTime() {
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }
}

然后创建 AI 服务并绑定工具：

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.service.AiServices;

public class WeatherAssistant {
    interface Assistant {
        String chat(String userMessage);
    }

    public static void main(String[] args) {
        ChatLanguageModel model = OpenAiChatModel.builder()
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .modelName("gpt-4")
            .build();
        
        Assistant assistant = AiServices.builder(Assistant.class)
            .chatLanguageModel(model)
            .tools(new WeatherTool()) // 注册工具
            .build();

        // 用户提问
        String response = assistant.chat("北京现在天气怎么样？");
        System.out.println(response);
        response = assistant.chat("现在几点了？");
        System.out.println(response);
    }
}

当用户问天气时，模型会判断需要调用 getWeather 函数，LangChain4j 自动处理了函数调用的整个流程，最后把结果整合成自然语言返回。

2.3 Function Calling 的核心价值

让 AI 从'静态知识'变成'动态能力'。

没有 Function Calling，AI 只能回答训练数据里的内容；有了它，AI 可以实时获取最新信息，甚至可以操作你的系统。

第三层：Agent——会思考、会规划的'智能体'

Function Calling 让 AI 能调用工具，但它还是被动的一问一答。

如果遇到复杂任务，比如'帮我规划一次杭州三日游'，需要查天气、查景点、查酒店、算预算……这时候就需要Agent（智能体） 出场。

3.1 什么是 Agent？

Agent 是一个能够感知环境、做出决策并执行动作的自主系统。

它不像 Function Calling 那样只是'单次工具调用'，而是具备完整的'思考 - 行动 - 观察'闭环能力。

通俗说，Function Calling 是'会用手'，Agent 是'有大脑'。

3.2 ReAct：Agent 的核心决策模式

目前主流 Agent 都采用ReAct（Reasoning + Acting）框架。

它的工作流程是：

1. 思考（Thought）：分析当前状态，决定下一步要做什么
2. 行动（Action）：调用某个工具
3. 观察（Observation）：获取工具返回的结果
4. 循环：直到任务完成

3.3 Java 实现一个简单的 ReAct Agent

我们用 LangChain4j 的 AiServices 结合工具来实现 Agent。

首先定义多个工具：

import dev.langchain4j.agent.tool.Tool;

public class TravelTools {
    @Tool("查询某城市未来一周的天气")
    public String queryWeather(String city) {
        // 模拟天气查询
        return city + "未来一周天气：前三天晴，后四天多云，气温 20-28℃";
    }

    @Tool("查询某城市的知名景点")
    public String queryAttractions(String city) {
        // 模拟景点查询
        if ("杭州".equals(city)) {
            return "杭州知名景点：西湖、灵隐寺、西溪湿地、宋城";
        } else if ("上海".equals(city)) {
            return "上海知名景点：外滩、东方明珠、迪士尼乐园";
        }
        return "暂无该城市景点信息";
    }

    @Tool("计算预算")
    public String calculateBudget(String city, int days) {
        // 模拟预算计算
        int base = 500;
        int total = base * days;
        return city + days + "天游预算约为：" + total + "元（不含大交通）";
    }
}

然后创建 Agent：

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;

public class TravelAgent {
    interface TravelPlanner {
        String planTrip(String request);
    }

    public static void main(String[] args) {
        ChatLanguageModel model = OpenAiChatModel.builder()
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .modelName("gpt-4")
            .build();

        TravelPlanner agent = AiServices.builder(TravelPlanner.class)
            .chatLanguageModel(model)
            .tools(new TravelTools())
            .chatMemory(MessageWindowChatMemory.withMaxMessages(20)) // 记忆，让 Agent 能记住上下文
            .build();

        String result = agent.planTrip("帮我规划一个 3 天的杭州游，包括天气、景点和预算");
        System.out.println(result);
    }
}

这个 Agent 会自己决定先查天气、再查景点、再算预算，然后把所有信息整合成一份完整的旅行计划。整个过程是自主的，不需要我们写死流程。

3.4 Agent 与 Function Calling 的关系

Function Calling 是 Agent 的'手'，Agent 是拥有'大脑'的完整系统。

Agent 通过 Function Calling 调用工具，但 Agent 多了'规划'和'记忆'能力，能处理更复杂的任务。

第四层：Skill——封装专业知识的'技能包'

当 Agent 需要处理不同领域的任务时，如果让一个 Agent 掌握所有知识和工具，会变得臃肿且容易出错。

这时候就需要Skill（技能） 的概念。

4.1 什么是 Skill？

Skill 是一套封装了特定领域知识、最佳实践和工具组合的'技能包'。

它就像我们人类的职业资格证书——一个医生有'看病技能'，一个程序员有'写代码技能'。

Anthropic 最早提出 Skill 概念，一个 Skill 通常包含：

• 领域专用的提示词模板
• 一组相关的工具函数
• 特定的工作流逻辑

4.2 Java 中如何组织 Skill？

我们可以把 Skill 定义为一个独立的模块，包含自己的工具类和提示模板。

例如，一个'前端开发 Skill'：

// 前端技能专属工具
public class FrontendTools {
    @Tool("生成 React 组件代码")
    public String generateReactComponent(String componentName, String props) {
        return """
            import React from 'react';
            const %s = (%s) => { return <div>Hello, {props.name}</div>; };
            export default %s;
            """.formatted(componentName, props, componentName);
    }

    @Tool("检查 CSS 命名规范")
    public String checkCssNaming(String cssCode) {
        // 模拟 CSS 检查逻辑
        return "CSS 规范检查通过";
    }
}

// 前端技能的提示词模板
public class FrontendPrompts {
    public static final String SYSTEM_PROMPT = """
        你是一个资深前端开发工程师，精通 React、Vue、CSS 等前端技术。
        请严格按照前端最佳实践生成代码，确保代码可维护。
        """;
}

// 创建前端专家 Agent
public class FrontendAgent {
    public static void main(String[] args) {
        ChatLanguageModel model = OpenAiChatModel.builder()
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .modelName("gpt-4")
            .build();

        Developer assistant = AiServices.builder(Developer.class)
            .chatLanguageModel(model)
            .tools(new FrontendTools())
            .systemMessageProvider(ignored -> FrontendPrompts.SYSTEM_PROMPT)
            .build();

        String code = assistant.generateCode("创建一个计数器组件，有加一减一按钮");
        System.out.println(code);
    }
}

4.3 Skill 与 Agent 的关系

在大型系统中，我们通常会有多个 Agent，每个 Agent 加载不同的 Skill：

• 前端 Agent：加载 ReactSkill、CSSSkill
• 后端 Agent：加载 SpringSkill、DatabaseSkill
• 运维 Agent：加载 K8sSkill、MonitoringSkill

每个 Agent 只拥有完成自己领域任务所需的最小知识集，既提高了精准度，又保障了安全。

4.4 Function Call 和 Skill 有什么区别？

一句话说清本质：

• Function Call 是一种能力：让 AI 能够调用外部函数（工具）
• Skill 是一个模块：封装了特定领域的知识、最佳实践和一组相关的 Function Call

用个比喻：

• Function Call 像锤子、螺丝刀、扳手这些具体工具
• Skill 像木工工具箱：里面有锤子、锯子、尺子，还附带一本《木工操作手册》

下面从代码看看它们的区别。

Function Call：单个工具

public class WeatherTool {
    @Tool("获取天气")
    public String getWeather(String city) {
        // 调用天气 API
        return callWeatherAPI(city);
    }
}

这个工具只能干一件事：查天气。

Skill：完整的专业能力包

// 前端开发 Skill - 包含多个工具 + 专业知识
public class FrontendSkill {
    // 工具 1：生成 React 组件
    @Tool("生成 React 组件")
    public String generateComponent(String name) {
        return "React 组件代码...";
    }

    // 工具 2：检查 CSS 规范
    @Tool("检查 CSS 规范")
    public String checkCss(String css) {
        return "检查结果...";
    }

    // 工具 3：优化性能建议
    @Tool("提供前端性能优化建议")
    public String performanceAdvice(String code) {
        return "优化建议...";
    }

    // 还有领域知识（不是工具，而是提示词模板）
    public static final String SYSTEM_PROMPT = "你是一个资深前端专家，精通 React、Vue、CSS 优化...";
}

这个 Skill 包含了多个工具，还带有领域知识。

核心区别对比表：

为什么需要区分这两个概念？

1. 设计层面的解耦：Function Call 是底层能力，Skill 是业务封装。底层能力稳定，上层业务可以灵活组合。
2. 复用性：好的 Skill 可以跨项目复用，就像代码库里的工具包。
3. 安全性：可以给不同的 Agent 分配不同的 Skill，实现权限隔离（前端 Agent 不能调用后端数据库）。

总结：

• Function Call：AI 的'手'，能干活
• Skill：AI 的'职业培训证书'，让 AI 知道怎么干好某个领域的事

Function Call + 领域知识 + 最佳实践 = Skill

下次再有人问这个问题，你可以直接甩给他这张表，然后说：'锤子是 Function Call，工具箱是 Skill，懂了吗？'

第五层：MCP——统一工具调用的'世界语'

随着 Agent 越来越多，每个 Agent 都要接入不同的工具，每个 AI 模型（OpenAI、Claude、文心一言）的 Function Calling 格式还不一样。

这就导致开发者要针对每个模型写一套工具适配代码，非常痛苦。

MCP（Model Context Protocol，模型上下文协议） 就是来解决这个问题的。

5.1 什么是 MCP？

MCP 是 Anthropic 提出的一个标准化协议，它定义了一套统一的接口，让 AI 模型可以像 USB 设备一样动态发现和调用工具。

核心思想：

• 工具以 Server 的形式暴露（MCP Server）
• AI 应用作为 Client（MCP Client）连接 Server
• Server 提供工具清单和调用接口
• Client 统一格式调用，无需关心底层工具具体实现

5.2 MCP 的工作流程

5.3 Java 中使用 MCP

Spring AI 2.0 已经原生支持 MCP，可以非常方便地构建 MCP 客户端和服务器。

定义 MCP Server（工具提供方）：

import org.springframework.ai.mcp.server.McpServer;
import org.springframework.ai.mcp.server.McpServerFeatures;
import org.springframework.ai.mcp.server.McpServerRegistrar;
import org.springframework.ai.mcp.spec.McpSchema;

@Component
public class WeatherMcpServer {
    @Bean
    public McpServerRegistrar weatherServer() {
        // 定义工具
        McpSchema.Tool weatherTool = new McpSchema.Tool(
            "getWeather",
            "获取城市天气",
            new McpSchema.JsonSchema(Map.of(
                "type", "object",
                "properties", Map.of("city", Map.of("type", "string", "description", "城市名称")),
                "required", List.of("city")
            ))
        );

        // 创建 Server
        McpServerFeatures.AsyncServerSpec serverSpec = McpServerFeatures.async()
            .tool(weatherTool, (request) -> {
                String city = request.arguments().get("city").asText();
                // 执行真实逻辑
                String weather = "北京当前天气：晴，25℃";
                return CompletableFuture.completedFuture(
                    new McpSchema.CallToolResult(List.of(new McpSchema.TextContent(weather)), false)
                );
            });

        return McpServerRegistrar.builder()
            .name("weather-server")
            .server(serverSpec)
            .build();
    }
}

MCP Client 调用：

import org.springframework.ai.mcp.client.McpClient;
import org.springframework.ai.mcp.client.McpClientFeatures;

@Service
public class AIServiceWithMCP {
    private final ChatClient chatClient;
    private final McpClient mcpClient;

    public AIServiceWithMCP(ChatClient chatClient) {
        this.chatClient = chatClient;
        // 连接到 MCP Server
        this.mcpClient = McpClientFeatures.async()
            .connect("weather-server", "http://localhost:8080/mcp");
    }

    public String askWeather(String city) {
        // 通过 MCP 调用工具
        McpSchema.CallToolResult result = mcpClient.callTool("getWeather", Map.of("city", city)).join();
        String weather = result.content().get(0).text();
        // 也可以让 AI 自动决定是否调用工具
        Prompt prompt = new Prompt("查询" + city + "天气");
        return chatClient.call(prompt).getResult().getOutput().getContent();
    }
}

5.4 MCP 与 Skill 的关系

MCP 和 Skill 是互补的：

• MCP 解决'怎么连'的问题——标准化工具调用协议
• Skill 解决'连什么'的问题——封装专业知识和工具集合

一个典型的架构是：Agent 通过 MCP 调用各种 Skill 暴露的工具。

这样，无论底层工具如何变化，Agent 都不需要修改代码，只需要通过 MCP 动态发现即可。

一张表彻底分清五个概念

这五个概念构成了 AI 应用开发的完整分层：

• Prompt 是地基，没有它 AI 听不懂人话
• Function Call 是第一层楼，让 AI 能动手
• Agent 是第二层，让 AI 会思考
• Skill 是装修，让 AI 更专业
• MCP 是连接各层的管道，让整个系统灵活可扩展

总结

有些小伙伴可能会问：'我现在应该先学哪个？'

我的建议是：从 Prompt 开始，这是所有 AI 应用的基础。

理解了 Prompt，再逐步接触 Function Call，然后尝试搭建简单的 Agent。

至于 Skill 和 MCP，可以先了解概念，等你的应用复杂到需要多个 Agent 协作时，再深入学习也不迟。

Prompt、Function Call、Agent、Skill、MCP，正是 AI 应用开发的'五层楼'，每一层都让我们离业务更近，离底层细节更远。

开源地址：

• Spring AI：https://github.com/spring-projects/spring-ai
• LangChain4j：https://github.com/langchain4j/langchain4j
• MCP 规范：https://github.com/modelcontextprotocol