一、基础概念

1. 大模型的两大核心能力底座

       在大模型技术体系中，Skill（技能） 和 Function Call（函数调用） 是支撑模型从文本生成走向实用工具的两大核心机制。如果把大模型比作一个全能助手：

• Skill是助手天生自带的专业能力，比如会写代码、会翻译、会数据分析；
• Function Call是助手调用外部工具的能力，比如可以查天气、查数据库、调用计算器、控制智能家居。

二者共同解决了大模型的核心痛点：

• 纯文本大模型只能基于训练数据生成内容，无法获取实时信息、无法执行精准操作、无法对接现实世界系统；
• 而Skill 让模型具备专业领域的深度能力，Function Call让模型突破自身限制，连接物理世界与数字系统。

2. Skill 的核心定义与本质

       Skill是大模型通过预训练、微调、Prompt 工程、领域适配形成的固有推理与生成能力，是模型内置的、无需外部依赖即可独立完成任务的专业技能集合。

本质原理：

• 大模型的底层是 Transformer 架构，通过海量文本、代码、多模态数据训练，学习到了语言规律、逻辑规则、领域知识、操作范式。
• Skill就是这些学习成果的具象化体现，是模型权重中固化的知识与能力，不需要调用任何外部接口、函数、工具，仅依靠模型自身的参数和推理引擎即可完成任务。

核心特征：

• 1. 内生性：能力来源于模型自身训练数据与参数，无外部依赖；
• 2. 静态性：技能边界由训练阶段决定，推理阶段无法动态扩展；
• 3. 通用性：基础Skill适用于全场景，领域 Skill 适用于垂直行业；
• 4. 推理型：核心是 "理解 - 分析 - 生成"，不产生实际操作行为；
• 5. 无状态：不依赖外部系统状态，仅基于输入文本生成输出。

典型Skill分类：

• 基础语言 Skill：文本生成、摘要、翻译、纠错、对话；
• 逻辑推理 Skill：数学计算、逻辑判断、因果分析、规划；
• 专业领域 Skill：代码编写、SQL 生成、医疗问诊、法律分析；
• 多模态 Skill：图像描述、语音转文字、视频理解。

3. Function Call 核心定义与本质

       Function Call是大模型的工具调用能力，指模型在推理过程中，主动识别用户需求需要外部工具支持，自动生成符合规范的函数调用指令，调用外部 API、函数、数据库、系统，获取结果后整合为自然语言返回给用户的机制。

本质原理：

• Function Call是大模型的"接口交互能力"，模型不再是孤立的文本生成器，而是成为了系统调度中枢。
• 其核心逻辑是：模型学习了 "函数调用格式+需求与工具的匹配规则"，当判断自身无法完成任务时，触发调用流程，通过外部工具补全能力，最终完成闭环。

核心特征：

• 1. 外生性：能力来源于外部工具、函数、系统，模型仅负责调度；
• 2. 动态性：可随时新增或删除外部函数，动态扩展模型能力；
• 3. 精准性：解决实时数据、精准计算、系统操作等内生 Skill 无法完成的任务；
• 4. 操作型：核心是 "识别需求 - 调用工具 - 获取结果 - 整合输出"，可产生实际操作；
• 5. 有状态：依赖外部系统的状态、数据、接口可用性。

核心价值：

       彻底打破了大模型的数据孤岛：训练数据是静态的，而现实世界是动态的实时天气、股票价格、用户私有数据，Function Call让模型能够实时获取外部信息，执行实际操作，从聊天机器人升级为智能执行体。

4. 两者的核心差异

• Skill：模型自己会，不用找外援，纯内生能力；
• Function Call：模型自己不会或做不好，调用外部工具，内外协同能力。

二、基础原理与流程

1. Skill 基础原理

1.1 大模型内生技能的构建逻辑

• 1. 意图识别：模型基于元数据精准匹配用户需求，自动触发对应技能模块。
• 2. 上下文注入：按需加载核心指令与参考资料，确保模型聚焦当前任务。
• 3. 逻辑执行：遵循预设SOP调用工具或脚本，实现确定性的业务处理。
• 4. 结果封装：将执行结果标准化输出，完成从“对话”到“行动”的闭环。

1.2 底层技术支撑

Skill 的形成完全基于Transformer架构的自注意力机制与预训练 - 微调范式：

• 1. 预训练阶段：模型学习海量通用数据，掌握语言、逻辑、常识，形成通用基础Skill；
• 2. 有监督微调（SFT）阶段：用标注数据优化特定任务，强化专业Skill；
• 3. 人类反馈强化学习（RLHF）阶段：对齐人类意图，让 Skill更符合用户需求；
• 4. 领域微调：用垂直领域数据训练，形成行业专属Skill。

1.3 Skill标准执行流程

流程说明：

• 1. 输入接收：模型接收用户的文本或多模态输入；
• 2. 语义理解：通过编码层将输入转化为向量，理解用户意图；
• 3. 技能匹配：推理引擎在模型权重中匹配对应的内生 Skill；
• 4. 内容生成：基于Skill完成推理、计算、分析，生成输出文本；
• 5. 结果输出：返回纯文本或多模态结果，无任何外部交互。

       Skill的执行效率完全由模型参数量、推理引擎、算力决定，无网络请求、无外部交互，延迟最低，但能力上限固定。例如：模型自带的数学Skill只能做简单计算，复杂计算会出现误差，因为这是内生推理，不是精准计算器。

2. Function Call 基础原理

2.1 大模型工具调度逻辑

• 1. 工具定义：开发者通过Schema描述函数名称、参数及功能，建立外部能力索引。
• 2. 意图解析：模型分析用户输入，智能决策是否调用工具并生成结构化参数。
• 3. 外部执行：系统捕获模型输出的JSON对象，在本地或云端执行具体代码逻辑。
• 4. 结果回传：将工具执行结果作为新上下文反馈给模型，辅助其生成最终回答。

2.2 底层技术支撑

Function Call基于指令微调 + 格式约束 + 工具注册机制：

• 1. 模型通过微调学习JSON/XML 函数调用格式；
• 2. 预先注册外部函数（定义函数名、参数、功能描述）；
• 3. 模型学习 "用户需求 ↔ 注册函数" 的匹配规则；
• 4. 推理阶段严格按照格式生成调用指令，对接外部系统。

2.3  Function Call 标准执行流程

流程说明：

• 1. 函数注册：核心前提需要开发者提前定义所有可用的外部函数；
• 2. 需求识别：模型分析用户输入，判断是否需要外部工具；
• 3. 指令生成：若需要，自动生成符合格式的调用参数，如城市、日期；
• 4. 外部调用：系统执行函数，调用API、数据库或硬件；
• 5. 结果回传：外部工具返回结构化数据给模型；
• 6. 结果整合：模型将结构化数据转化为自然语言；
• 7. 最终输出：返回给用户完整答案。

       Function Call必须满足格式规范性，模型生成的调用指令必须严格匹配函数入参，否则调用失败；同时依赖外部接口的可用性，有网络延迟，但能力无上限，只要注册新函数，模型就能获得新能力。

3. 核心原理对比

三、核心差异分析

1. 能力本质与来源

Skill：先天能力，由模型训练决定，是模型的 "本能"。

• 比如人类天生会说话、会思考，对应大模型的文本生成、逻辑推理 Skill。
• 能力不可更改，除非重新训练模型。

Function Call：后天工具，由外部函数决定，是模型的 "外挂"。

• 比如人类使用计算器、手机、电脑，对应大模型调用天气 API、数据库。
• 能力可随时增减，无需训练模型。

2. 依赖条件

Skill：零依赖，只要模型加载完成，断网、离线、无外部系统均可正常使用。所有能力封装在模型文件中。

Function Call：强依赖，必须联网、必须有可用的外部接口、必须完成函数注册、必须有调用权限。缺一不可，否则机制失效。

3. 数据时效性与准确性

Skill：数据静态过时，基于训练截止日期前的数据，无法获取实时信息。

• 例如：2024年训练的模型，无法回答2025年的天气、股票、新闻。

Function Call：数据实时精准，直接调用外部最新数据，100% 精准。

• 例如：调用天气接口，返回当前实时温度、风力；调用计算器，无任何计算误差。

4. 操作权限与行为

Skill：只读不操作，仅生成文本内容，不会对现实世界、用户系统、数据产生任何修改、操作、影响。绝对安全。

Function Call：可读写可操作，可以执行增删改查、控制硬件、修改数据、发送消息等实际操作。存在安全风险，需要权限控制。

5. 开发与维护成本

Skill：高成本、低灵活，扩展技能需要重新训练或微调模型，消耗大量算力、数据、时间，维护成本极高。

Function Call：低成本、高灵活，扩展能力仅需新增一个函数或接口，无需修改模型，几分钟即可完成，维护成本极低。

6. 错误表现与处理

Skill：幻觉错误，模型会编造不存在的信息、错误的知识、过时的数据，无法修正，只能通过 Prompt 优化。

Function Call：执行错误，错误来源于外部（接口超时、参数错误、权限不足），可通过重试、参数校验、日志排查修复，无幻觉。

7. 大模型角色定位

Skill：专家大脑，负责思考、理解、分析、生成，是核心决策单元。

Function Call：工具手臂，负责执行、获取、操作，是能力扩展单元。

8. 差异总结

二者是互补关系，非替代关系：

• Skill是大模型的核心灵魂，没有 Skill，模型无法理解用户需求；
• Function Call 是大模型的四肢，没有 Function Call，模型只能空想，无法落地。

大模型的终极形态 = 强大的Skill充当大脑 + 完善的Function Call组建四肢。

四、应用场景匹配

1. Skill 独家适用场景

       Skill 适用于无需实时数据、无需外部操作、纯理解与生成的场景，是大模型最基础、最高频的应用：

1.1 内容创作场景

• 文案写作、小说生成、演讲稿、诗歌、短视频脚本，纯文本生成，无需外部数据，Skill完美适配。

1.2 语言处理场景

• 文本翻译、摘要、纠错、润色、关键词提取，基于语言规则的内生能力，离线可用。

1.3 逻辑推理场景

• 逻辑题解答、思路规划、因果分析、观点提炼，纯大脑推理，无外部依赖。

1.4 专业知识问答场景

• 历史、物理、化学、法律、医疗等静态知识问答，主要应用非实时数据。

1.5 代码理解场景

• 代码注释、代码解释、代码优化建议，基于模型训练的代码Skill。

2. Function Call 独家适用场景

Function Call适用于Skill绝对无法完成的场景，是大模型落地的核心：

2.1 实时数据查询场景

• 实时天气、股票价格、新闻资讯、快递物流、航班信息，核心是数据的动态变化。

2.2 精准计算与操作场景

• 科学计算、财务计算、计算器、单位换算，避免模型计算误差。

2.3 私有数据访问场景

• 企业数据库查询、用户订单查询、个人文件读取，这些情况都是模型未训练私有数据。

2.3 系统执行与控制场景

• 发送邮件、创建日程、控制智能家居、操作 CRM 系统、执行 SQL 语句。

2.5 第三方服务对接场景

• 支付接口、地图导航、语音合成、图像识别API调用。

3. Skill + Function Call协同场景

这是大模型实际落地应用的标准模式，举例：

• 用户需求：帮我查一下北京今天的天气，然后写一篇出行文案。

执行流程：

• 1. 模型用 Skill 理解需求；
• 2. 模型用 Function Call 调用天气 API，获取实时数据；
• 3. 模型用 Skill 基于天气数据生成出行文案；
• 4. 最终返回完整结果。

五、应用实践

1. Skill 基础示例

       纯内生能力，无外部调用，模型基于内置规则自主执行文本摘要，无需API，通过内部推理完成信息压缩。

from transformers import AutoTokenizer, AutoModelForCausalLM
from modelscope import snapshot_download
# 下载模型到指定文件夹
model_name = "qwen/Qwen1.5-1.8B-Chat"
cache_dir = "D:\\modelscope\\hub"
print("正在下载/校验模型缓存...")
local_model_path = snapshot_download(model_name, cache_dir=cache_dir)
# 加载模型
tokenizer = AutoTokenizer.from_pretrained(local_model_path, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(local_model_path, trust_remote_code=True).eval()
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token
print("模型加载完成！")
# ==================== Skill 演示：文本生成 + 翻译（纯内生能力）====================
def skill_demo(user_input):
    """
    Skill 功能：模型自带的对话、翻译技能，无任何外部调用
    """
    text = tokenizer.apply_chat_template([{"role": "user", "content": user_input}], 
                                          tokenize=False, 
                                          add_generation_prompt=True)
    encoding = tokenizer(text, return_tensors="pt")
    input_ids = encoding["input_ids"]
    input_length = input_ids.shape[1]
    outputs = model.generate(
        input_ids, 
        max_new_tokens=512, 
        do_sample=False,
        pad_token_id=tokenizer.pad_token_id
    )
    response = tokenizer.decode(outputs[0][input_length:], skip_special_tokens=True)
    return response
# 测试1：文本创作 Skill
print("\n=== 测试1：文本创作 Skill（内生能力）===")
result1 = skill_demo("写一段关于春天的短句")
print(result1)
# 测试2：翻译 Skill
print("\n=== 测试2：翻译 Skill（内生能力）===")
result2 = skill_demo("把这句话翻译成英文：Skill 是大模型的内生能力")
print(result2)

输出结果：

正在下载/校验模型缓存...

模型加载完成！

=== 测试1：文本创作 Skill（内生能力）===

春风吹绿江南岸，万物复苏生机盎然。花儿含笑绽放，鸟儿欢歌歌唱，大地披上新装，一片生机勃勃的景象。春天，是生命的季节，是希望的象征，是大自然的馈赠，让我们感受到生活的美好和力量。

=== 测试2：翻译 Skill（内生能力）===

Skill is the inherent ability of large models.

2. Function Call 基础示例

       工具调用，外部协同，模型解析意图生成JSON参数，触发外部天气API，实现实时数据获取。

import os
import requests
import json
# ==================== 步骤1：注册外部函数（Function Call 核心）====================
def get_weather(city: str):
    """
    外部函数：获取实时天气（Skill 无法完成，必须外部调用）
    """
    try:
        api_key = os.getenv("WEATHER_API_KEY","5c7018*********1")
        # 调用公开天气 API
        url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric&lang=zh_cn"
        res = requests.get(url, timeout=10)
        print(f"原始响应: {res.text}")  # 完整输出接口返回
        data = res.json()
        print(f"JSON解析后: {json.dumps(data, ensure_ascii=False, indent=2)}")  # 格式化输出
        if data.get("cod") != 200:
            return f"查询失败：{data.get('message', '未知错误')}"
        return f"城市：{city}，天气：{data['weather'][0]['description']}，温度：{data['main']['temp']}°C"
    except Exception as e:
        return f"天气查询失败：{str(e)}"
# 函数注册列表（告诉模型可用工具）
FUNCTIONS = [
    {
        "name": "get_weather",
        "description": "查询指定城市的实时天气",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "城市名称"}
            },
            "required": ["city"]
        }
    }
]
# ==================== 步骤2：模拟大模型 Function Call 逻辑 ====================
def function_call_demo(user_query):
    """
    Function Call 执行流程：识别需求 → 调用函数 → 返回结果
    """
    print(f"用户需求：{user_query}")
    
    # 模拟模型判断：需要调用天气函数
    print("模型判断：需要调用外部函数 get_weather")
    
    # 模拟模型生成调用参数
    call_params = {"city": "hangzhou"}
    print(f"模型生成调用参数：{call_params}")
    
    # 执行外部函数（核心：Function Call 动作）
    print("执行外部函数调用...")
    tool_result = get_weather(**call_params)
    
    # 模型整合结果（Skill + Function Call 协同）
    final_response = f"根据查询结果：{tool_result}，建议出行携带雨具"
    return final_response
# 测试 Function Call
print("=== Function Call 演示：实时天气查询 ===")
result = function_call_demo("杭州今天天气怎么样？")
print("\n最终输出：", result)

输出结果：

=== Function Call 演示：实时天气查询 ===

用户需求：杭州今天天气怎么样？

模型判断：需要调用外部函数 get_weather

模型生成调用参数：{'city': 'hangzhou'}

执行外部函数调用...

原始响应: {"coord":{"lon":120.1614,"lat":30.2937},"weather":[{"id":804,"main":"Clouds","description":"阴，多云","icon":"04d"}],"base":"stations","main":{"temp":17.95,"feels_like":18.15,"temp_min":17.95,"temp_max":17.95,"pressure":1012,"humidity":90,"sea_level":1012,"grnd_level":1010},"visibility":10000,"wind":{"speed":0.77,"deg":83,"gust":1.07},"clouds":{"all":100},"dt":1776159325,"sys":{"type":1,"id":9651,"country":"CN","sunrise":1776116025,"sunset":1776162319},"timezone":28800,"id":1808926,"name":"Hangzhou","cod":200}

最终输出： 根据查询结果：城市：hangzhou，天气：阴，多云，温度：17.95°C，建议出行携带雨具

3. 协调应用示例

结合以上两个基础示例，我们实现一个协同应用的场景：

用户：帮我查一下今天北京的天气，如果下雨，帮我生成一条提醒文案发给家人。

核心分工：

• Skill：理解意图、规划步骤、写文案、组织语言
• Function Call：查天气、调用消息接口

执行过程：

- 1. 用户输入

帮我查一下今天北京的天气，如果下雨，帮我生成一条提醒文案发给家人。

- 2. Skill 理解 + 规划

模型用语言理解 Skill + 逻辑规划 Skill 做三件事：

• 1. 识别地点：北京
• 2. 识别需求：查今日天气
• 3. 识别条件：如果下雨 → 生成提醒文案 → 发送
• 4. 输出一个执行计划

这一步完全是模型内生能力，没有任何外部调用。

- 3. Skill 判断需要外部数据 → 触发 Function Call

模型知道：

• 天气是实时动态数据
• 自己的 Skill 只能推理，不能获取真实数据

于是主动生成函数调用指令：

{
  "name": "get_realtime_weather",
  "parameters": {
    "city": "北京"
  }
}

- 4. Function Call 执行外部工具干活

系统调用天气接口，返回真实结果：北京，今日小雨，气温 12℃，建议带伞

-5. Skill 理解结果 + 决策

模型用逻辑判断 Skill：

• 识别到“小雨” → 满足“下雨”条件
• 启动文案生成 Skill，写一条温馨提醒
• 生成文案：今天北京有小雨，气温偏低，出门记得带好雨具，注意保暖哦～

- 6. Skill 判断需要执行动作 → 再次 Function Call

模型理解用户最后一句：发给家人

于是再次生成工具调用，触发消息发送接口：

{
  "name": "send_message",
  "parameters": {
    "target": "家人",
    "content": "今天北京有小雨，气温偏低，出门记得带好雨具，注意保暖哦～"
  }
}

- 7. Function Call 发送消息

工具执行发送，返回成功。

-8. Skill 最终回复用户

已为你查询北京今日天气：小雨。已自动生成提醒并发送给家人。

示例代码：

# 模拟：Skill 理解 + Function Call 执行 协同示例
# ====================== 外部工具（Function Call）======================
def get_realtime_weather(city):
    """外部天气接口"""
    return {"city": city, "weather": "小雨", "temp": "12℃", "tip": "需要带伞"}
def send_message(target, content):
    """外部消息发送接口"""
    print(f"[消息发送] 向 {target} 发送：{content}")
    return True
# ====================== 模型 Skill 能力 ======================
def skill_understand_intent(query):
    """Skill：理解用户意图 + 规划"""
    print("\n=== Skill 开始理解意图 ===")
    plan = {
        "need_weather": True,
        "city": "北京",
        "need_generate_text": True,
        "need_send_message": True
    }
    print("Skill 规划结果:", plan)
    return plan
def skill_judge_weather(weather_info):
    """Skill：逻辑判断"""
    return "雨" in weather_info["weather"]
def skill_generate_reminder(weather_info):
    """Skill：文案生成"""
    return f"今天{weather_info['city']}有{weather_info['weather']}，气温{weather_info['temp']}，出门记得带伞保暖~"
# ====================== 协同主流程 ======================
def agent_workflow(user_query):
    print("用户问题:", user_query)
    # 1. Skill 理解意图
    plan = skill_understand_intent(user_query)
    # 2. Function Call 查天气
    print("\n=== Function Call 调用天气接口 ===")
    weather = get_realtime_weather(plan["city"])
    print("天气结果:", weather)
    # 3. Skill 判断是否下雨
    print("\n=== Skill 逻辑判断 ===")
    need_remind = skill_judge_weather(weather)
    if need_remind:
        # 4. Skill 生成文案
        print("\n=== Skill 生成提醒文案 ===")
        msg = skill_generate_reminder(weather)
        print("文案:", msg)
        # 5. Function Call 发送消息
        print("\n=== Function Call 发送消息 ===")
        send_message("家人", msg)
    # 6. Skill 最终回复
    print("\n=== Skill 最终回复用户 ===")
    print("已查询北京天气为小雨，并已发送温馨提醒给家人。")
# 执行
agent_workflow("帮我查一下今天北京的天气，如果下雨，帮我生成一条提醒文案发给家人。")

输出结果：

用户问题: 帮我查一下今天北京的天气，如果下雨，帮我生成一条提醒文案发给家人。

=== Skill 开始理解意图 ===

Skill 规划结果: {'need_weather': True, 'city': '北京', 'need_generate_text': True, 'need_send_message': True}

=== Function Call 调用天气接口 ===

天气结果: {'city': '北京', 'weather': '小雨', 'temp': '12℃', 'tip': '需要带伞'}

=== Skill 逻辑判断 ===

=== Skill 生成提醒文案 ===

文案: 今天北京有小雨，气温12℃，出门记得带伞保暖~

=== Function Call 发送消息 ===

[消息发送] 向 家人 发送：今天北京有小雨，气温12℃，出门记得带伞保暖~

=== Skill 最终回复用户 ===

已查询北京天气为小雨，并已发送温馨提醒给家人。

协同的核心价值：

• 1. Skill 负责：听懂人话、做逻辑判断、做规划、写文案、组织自然语言
• 2. Function Call 负责：查真实实时数据、执行系统操作、保证结果准确、连接外部世界
• 3. 协同后才具备的能力：能理解复杂意图、能获取真实信息、能做条件判断、能自动执行动作、能自然语言交互

六、总结

       大模型的Skill与Function Call机制的核心逻辑：Skill是模型与生俱来的内生能力，负责理解、推理、规划与内容生成，相当于智能体的大脑；而Function Call是模型连接外部世界的工具调用能力，负责获取实时数据、执行精准操作，相当于智能体的手脚。二者并非替代关系，而是深度互补。单独依靠 Skill，模型容易出现幻觉、计算不准、信息过时；只依赖Function Call，模型又缺乏理解意图、逻辑判断和自然表达的能力。只有当 Skill负责决策规划，Function Call负责落地执行，才能形成“思考 — 调用 — 整合 — 输出”的完整闭环，这也是企业级应用和 AI Agent 真正可用的关键。

       大模型的强大从来不只在于参数多大，而在于能不能把内生智能和外部工具高效协同起来。先吃透 Skill 的推理逻辑和提示词技巧，再掌握Function Call的注册、调度与异常处理，最后多做协同场景练习，从“理解 + 执行”的整体视角去设计应用，这样做出的系统才稳定、可靠、有实际价值。