Prompt、Agent、Function Call、MCP：核心区别与实战应用指南

引言

最近AI的热度持续攀升，应用落地加速推进。

但在与许多开发者交流时，我注意到一个普遍困惑：大家对核心概念容易混淆。比如Prompt、Agent、Function Call、Skill、MCP…… 单独拎出来可能都听过，但放在一起就理不清关系，更别说分清楚各自职责了。

本文专门把这五个概念彻底梳理清楚，帮你搭建起AI应用开发的整体认知框架。

核心概念关系图

先上干货。下图从宏观层面展示五个概念如何分层递进、相互支撑：

一句话定位：

• Prompt：你表达意图的自然语言
• Function Call：赋予AI执行能力的“工具手”
• Agent：赋予AI自主规划的“决策脑”
• Skill：赋予AI领域专业性的“资格证”
• MCP：统一所有工具调用的“标准接口”

接下来，我们从最底层的Prompt开始，逐层上升，每层配以Java代码示例，确保理论与实践结合。

第一层：Prompt——与AI交互的通用语言

1.1 什么是Prompt？

Prompt（提示词） 是你输入给AI的指令文本，是人与模型沟通的桥梁。

类似在餐厅点餐：“您好，一份宫保鸡丁。”AI就是那位服务员，先听懂需求，再响应执行。

在Java世界里，调用AI模型的第一步就是构建Prompt。下面用Spring AI框架演示：

import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.SystemPrompt;
import org.springframework.ai.chat.prompt.UserPrompt;

@Service
public class AIService {

    private final ChatClient chatClient;

    public AIService(ChatClient chatClient) {
        this.chatClient = chatClient;
    }

    public String askAI(String question) {
        // 构建Prompt：包含系统消息和用户消息
        Prompt prompt = new Prompt(
            new SystemPrompt("你是一位Java架构师，擅长用通俗语言解释技术概念。"),
            new UserPrompt(question)
        );

        // 调用AI并返回结果
        return chatClient.call(prompt).getResult().getOutput().getContent();
    }
}

SystemPrompt 设定AI角色与风格，UserPrompt 承载具体问题，这是最基础的Prompt形式。

1.2 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给了AI“手”，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自主决策：先查天气确保行程可行，再查景点规划路线，然后计算预算。整个过程自行完成，无需硬编码流程，最后整合为结构化旅行攻略。这是Agent的真正价值。

3.4 Agent与Function Calling的关系

Function Calling是Agent的“手”，Agent是拥有“大脑”的完整系统。Agent通过Function Calling调用工具，但额外具备“规划”和“记忆”能力，因此能处理多步骤复杂任务。

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

当Agent需要处理不同领域的任务时，若让一个Agent掌握全部知识和工具，它会变得臃肿，像“万金油”一样样样不精。

这就需要Skill（技能） 来解耦。

4.1 什么是Skill？

Skill是一套封装了特定领域知识、最佳实践和工具组合的“技能包”。好比职业资格证书——医生有“诊疗技能”，程序员有“编码技能”。

该概念由Anthropic提出，标准Skill通常包含：

• 领域专属提示词模板（System Prompt）
• 一组相关工具函数（Function Call）
• 特定工作流逻辑或约束

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 
Hello, {props.name}
;
            };

            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，每个加载不同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包含多个工具，并附带整套领域知识和最佳实践（System Prompt）。

核心区别对比表：

为什么需要区分？

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

总结：

• Function Call：AI的“手”，能干活。
• Skill：AI的“职业培训证书”，告诉AI如何做好某个领域的事。

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

第五层：MCP——统一工具调用的通用协议

随着Agent和Skill增多，问题显现：每个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() {
        // 定义工具Schema
        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动态发现。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应用开发的完整体系。每一层都让我们更贴近业务逻辑，同时远离底层技术细节。掌握这个“五层楼”思维框架，再看各种AI框架和项目，便会豁然开朗。