提示工程架构师进阶指南：Agentic AI与NLP的融合之道——从规则到智能体的跨越

一、引言：静态提示的局限，是Agentic AI的机会

你是否遇到过这样的场景？
用"帮我总结这篇文章的核心观点"这样的静态提示词调用LLM，能得到不错的结果，但当任务变得复杂——比如多轮客户咨询（需要记住上下文）、需要推理的问题（比如“根据用户的购买记录推荐产品”）、需要调用外部工具的任务（比如“查一下明天的天气，然后建议穿什么衣服”）——静态提示就显得力不从心了：

• 要么需要不断调整提示词，效率极低；
• 要么输出不符合预期（比如忘记之前的对话内容）；
• 要么无法处理需要“行动”的任务（比如调用天气API）。

这不是你的提示词写得不好，而是静态提示的“一次性”特性，无法满足复杂任务的“动态性”需求。而解决这个问题的关键，就是将提示工程与Agentic AI（智能体AI）结合——让AI从“执行单一指令的工具”，变成“能自主感知、决策、行动的智能体”。

本文要做什么？

本文将带你从提示工程架构师的视角，拆解Agentic AI与NLP的融合逻辑：

• 先讲清楚Agentic AI的核心组件，以及NLP在其中的作用；
• 再用LangChain（主流的智能体开发框架）手把手教你搭建一个能处理复杂任务的智能体；
• 最后通过智能客服案例，展示如何用提示工程优化智能体的决策能力。

读完你能获得什么？

• 理解Agentic AI的本质：不是“更强大的LLM”，而是“用提示工程连接LLM与外部世界的系统”；
• 掌握智能体的搭建流程：从感知输入到决策行动的全链路设计；
• 学会用NLP增强智能体：比如用文本分类优化输入处理、用链式推理提升决策准确性；
• 获得可复用的代码模板：比如智能体的提示模板、工具调用逻辑。

二、准备工作：你需要具备这些基础

在开始之前，确保你已经掌握以下知识/工具：

1. 技术栈要求

• NLP基础：了解Transformer模型、prompt engineering（比如Few-Shot、Chain-of-Thought）；
• Agentic AI概念：知道智能体的核心循环（感知→决策→行动→记忆）；
• 编程语言：Python（熟练使用函数、类，了解装饰器更佳）；
• 工具框架：LangChain（用于快速搭建智能体）、OpenAI SDK（或其他LLM API）、Transformers（可选，用于本地部署LLM）。

2. 环境搭建

• 安装Python 3.8+（推荐3.10）；
• 安装依赖库：

  pip install langchain openai python-dotenv transformers
  

• 配置OpenAI API密钥（或其他LLM的API密钥）：
  创建.env文件，添加：

  OPENAI_API_KEY=your-api-key
  

三、核心内容：Agentic AI与NLP的融合实践

（一）先搞懂：Agentic AI的核心组件，以及NLP在哪里？

Agentic AI（智能体AI）的本质是**“能自主完成复杂任务的系统”**，它的核心循环是：

感知（Perceive）→ 决策（Decide）→ 行动（Act）→ 记忆（Remember）

而NLP（自然语言处理）是连接这些组件的“桥梁”——几乎每个环节都需要NLP技术：

组件	作用	NLP技术的角色
感知模块	处理用户输入（文本、语音等）	文本分类、实体识别、意图检测（比如判断用户是“咨询”还是“投诉”）
决策模块	决定下一步做什么（比如“调用工具”或“直接回答”）	提示工程（用Prompt引导LLM做决策）、链式推理（Chain-of-Thought）
行动模块	执行决策（比如调用API、生成回答）	生成式NLP（比如用LLM生成自然语言回答）、工具调用（用NLP解析工具返回结果）
记忆模块	存储上下文（比如多轮对话历史）	摘要技术（总结长对话）、向量检索（快速查找相关上下文）

简单来说：Agentic AI是“系统框架”，NLP是“功能实现的工具”，而提示工程是“让系统更智能的关键”。

（二）步骤一：用LangChain搭建基础智能体——从0到1实现“能调用工具的AI”

LangChain是目前最流行的智能体开发框架，它提供了Agent（智能体）、Tool（工具）、PromptTemplate（提示模板）等核心组件，能快速搭建智能体。

1. 目标：创建一个“天气推荐智能体”

需求：用户问“明天北京的天气怎么样？穿什么衣服合适？”，智能体需要：

• 感知：理解用户的问题（需要查天气+推荐衣服）；
• 决策：判断需要调用天气API；
• 行动：调用天气API获取数据；
• 记忆：记住用户的位置（北京）和问题类型（天气+穿搭）。

2. 代码实现：

（1）定义工具（Tool）：调用天气API的工具
首先，我们需要一个能获取天气的工具。这里用OpenWeatherMap的API（需要注册获取API密钥）：

from langchain.tools import Tool
import requests
from dotenv import load_dotenv
import os

# 加载.env文件中的API密钥
load_dotenv()
OPENWEATHER_API_KEY = os.getenv("OPENWEATHER_API_KEY")

# 定义获取天气的函数
def get_weather(city: str) -> str:
    """获取指定城市的天气信息（摄氏度）"""
    url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={OPENWEATHER_API_KEY}&units=metric"
    response = requests.get(url)
    data = response.json()
    if data["cod"] != 200:
        return f"无法获取{city}的天气信息：{data['message']}"
    weather = data["weather"][0]["description"]
    temp = data["main"]["temp"]
    return f"{city}明天的天气：{weather}，气温：{temp}℃"

# 将函数封装成LangChain的Tool
weather_tool = Tool(
    name="WeatherTool",
    func=get_weather,
    description="用于获取指定城市的天气信息，输入参数是城市名称（比如“北京”）"
)

说明：Tool类需要指定name（工具名称）、func（工具函数）、description（工具描述，用于提示LLM判断是否需要调用）。

（2）定义智能体（Agent）：用ZeroShotAgent实现决策
ZeroShotAgent是LangChain中最常用的智能体类型，它通过提示模板引导LLM做决策（比如“是否需要调用工具？”“调用哪个工具？”）。
首先，定义提示模板：

from langchain.agents import ZeroShotAgent, AgentExecutor
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI

# 初始化LLM（这里用OpenAI的gpt-3.5-turbo-instruct）
llm = OpenAI(temperature=0, model_name="gpt-3.5-turbo-instruct")

# 定义提示模板（关键：引导LLM判断是否需要调用工具）
prompt_template = """你是一个智能助手，需要帮助用户解决问题。你可以使用以下工具：

{tools}

使用工具的格式要求：
如果需要调用工具，请用<|FunctionCallBegin|>和<|FunctionCallEnd|>包裹函数调用信息，例如：
<|FunctionCallBegin|>[{"name":"工具名称","parameters":{"参数名":"参数值"}}]<|FunctionCallEnd|>

如果不需要调用工具，请直接回答用户的问题。

现在处理用户的问题：{input}

上下文历史：{history}

请思考：是否需要调用工具？如果需要，调用哪个工具？参数是什么？"""

# 生成Agent的提示（结合工具描述）
agent_prompt = ZeroShotAgent.create_prompt(
    tools=[weather_tool],
    prefix=prompt_template.split("{tools}")[0],
    suffix=prompt_template.split("{tools}")[1],
    input_variables=["input", "history"]
)

说明：提示模板的核心是告诉LLM“有哪些工具可用”以及“如何调用工具”。ZeroShotAgent.create_prompt会自动将工具的description插入到{tools}位置，让LLM知道每个工具的用途。

（3）创建智能体执行器（AgentExecutor）：

from langchain.memory import ConversationBufferMemory

# 初始化记忆模块（存储对话历史）
memory = ConversationBufferMemory(memory_key="history")

# 创建Agent
agent = ZeroShotAgent(llm_chain=llm_chain, tools=[weather_tool], verbose=True)

# 创建Agent执行器（负责运行智能体循环：感知→决策→行动→记忆）
agent_executor = AgentExecutor.from_agent_and_tools(
    agent=agent,
    tools=[weather_tool],
    memory=memory,
    verbose=True  # 打印详细流程（方便调试）
)

（4）测试智能体：

# 测试问题1：需要调用工具
response = agent_executor.run("明天北京的天气怎么样？穿什么衣服合适？")
print("回答：", response)

# 测试问题2：不需要调用工具（利用记忆）
response = agent_executor.run("那上海呢？")
print("回答：", response)

3. 运行结果解析：

• 对于第一个问题，智能体的决策过程是：
  1. 感知：用户问的是“北京明天的天气+穿什么衣服”；
  2. 决策：需要调用WeatherTool获取天气数据；
  3. 行动：调用get_weather("北京")，得到天气信息；
  4. 记忆：存储“北京”这个城市（方便后续问题使用）。
• 对于第二个问题，智能体的决策过程是：
  1. 感知：用户问“上海呢？”（结合历史上下文，知道是问上海的天气）；
  2. 决策：需要调用WeatherTool获取上海的天气；
  3. 行动：调用get_weather("上海")，得到天气信息；
  4. 记忆：更新对话历史。

为什么这么做？

• 工具（Tool）：将外部功能（比如查天气）封装成智能体可调用的模块，扩展智能体的能力；
• 提示模板（PromptTemplate）：引导LLM做决策，解决“什么时候调用工具”“调用哪个工具”的问题；
• 记忆模块（Memory）：保持上下文一致性，让智能体“记住”之前的对话内容。

（三）步骤二：用提示工程优化智能体——从“能做”到“会做”

上面的基础智能体能完成简单的工具调用，但面对复杂任务（比如“根据用户的购买记录推荐产品”），需要优化提示工程来提升决策准确性。

1. 问题：基础智能体的决策局限

比如，当用户问“我昨天买了一件羽绒服，今天想再买一条裤子，推荐一下？”，基础智能体可能会直接回答“推荐牛仔裤”，但其实需要：

• 感知：用户的购买记录（羽绒服）；
• 决策：需要调用“用户购买记录工具”获取更多信息（比如羽绒服的风格、颜色）；
• 行动：根据购买记录推荐搭配的裤子。

基础智能体的问题在于提示模板没有引导LLM“思考用户的潜在需求”，所以需要优化提示模板。

2. 优化方法1：加入“链式推理（Chain-of-Thought）”

链式推理是提示工程中的常用技巧，通过让LLM“一步步思考”来提升决策准确性。我们可以在提示模板中加入**“思考过程”**的要求：

# 优化后的提示模板（加入链式推理）
prompt_template_with_cot = """你是一个智能助手，需要帮助用户解决问题。你可以使用以下工具：

{tools}

使用工具的格式要求：
如果需要调用工具，请用<|FunctionCallBegin|>和<|FunctionCallEnd|>包裹函数调用信息，例如：
<|FunctionCallBegin|>[{"name":"工具名称","parameters":{"参数名":"参数值"}}]<|FunctionCallEnd|>

如果不需要调用工具，请直接回答用户的问题。

现在处理用户的问题：{input}

上下文历史：{history}

请按照以下步骤思考：
1. 用户的问题需要哪些信息？（比如“购买记录”“天气”等）
2. 我是否已经有这些信息？（来自上下文历史或之前的工具调用）
3. 如果没有，需要调用哪个工具来获取？（工具的描述是什么？）
4. 调用工具的参数是什么？（比如城市名称、用户ID等）

请输出你的思考过程，然后决定是否调用工具。"""

说明：通过让LLM“一步步思考”，强制它考虑“是否需要更多信息”，从而减少“直接回答”的错误。

3. 优化方法2：加入“Few-Shot Prompting”（少样本提示）

少样本提示是指给LLM展示几个“正确的决策案例”，让它学会类似的决策方式。比如，对于“推荐产品”的任务，我们可以在提示模板中加入：

# 优化后的提示模板（加入少样本）
prompt_template_with_few_shot = """你是一个智能助手，需要帮助用户解决问题。你可以使用以下工具：

{tools}

使用工具的格式要求：
如果需要调用工具，请用<|FunctionCallBegin|>和<|FunctionCallEnd|>包裹函数调用信息，例如：
<|FunctionCallBegin|>[{"name":"工具名称","parameters":{"参数名":"参数值"}}]<|FunctionCallEnd|>

如果不需要调用工具，请直接回答用户的问题。

以下是几个正确的决策案例：
案例1：
用户问题：“我昨天买了一件黑色羽绒服，今天想再买一条裤子，推荐一下？”
思考过程：
1. 用户的问题需要“羽绒服的风格、颜色”（来自购买记录）；
2. 我没有这些信息（上下文历史中没有）；
3. 需要调用“UserPurchaseTool”获取用户的购买记录；
4. 参数是用户ID（假设用户已登录，ID为123）。
决策：调用UserPurchaseTool，参数{"user_id": "123"}。

案例2：
用户问题：“明天北京的天气怎么样？穿什么衣服合适？”
思考过程：
1. 用户的问题需要“北京明天的天气”；
2. 我没有这些信息；
3. 需要调用“WeatherTool”获取天气信息；
4. 参数是城市名称“北京”。
决策：调用WeatherTool，参数{"city": "北京"}。

现在处理用户的问题：{input}

上下文历史：{history}

请按照案例中的思考过程，输出你的思考过程和决策。"""

说明：少样本提示能让LLM快速学会“如何根据问题类型选择工具”，尤其适合复杂任务。

4. 代码实现：用优化后的提示模板创建智能体

# 初始化LLM
llm = OpenAI(temperature=0, model_name="gpt-3.5-turbo-instruct")

# 定义优化后的提示模板（加入链式推理和少样本）
prompt_template = """你是一个智能助手，需要帮助用户解决问题。你可以使用以下工具：

{tools}

使用工具的格式要求：
如果需要调用工具，请用<|FunctionCallBegin|>和<|FunctionCallEnd|>包裹函数调用信息，例如：
<|FunctionCallBegin|>[{"name":"工具名称","parameters":{"参数名":"参数值"}}]<|FunctionCallEnd|>

如果不需要调用工具，请直接回答用户的问题。

以下是几个正确的决策案例：
案例1：
用户问题：“我昨天买了一件黑色羽绒服，今天想再买一条裤子，推荐一下？”
思考过程：
1. 用户的问题需要“羽绒服的风格、颜色”（来自购买记录）；
2. 我没有这些信息（上下文历史中没有）；
3. 需要调用“UserPurchaseTool”获取用户的购买记录；
4. 参数是用户ID（假设用户已登录，ID为123）。
决策：调用UserPurchaseTool，参数{"user_id": "123"}。

案例2：
用户问题：“明天北京的天气怎么样？穿什么衣服合适？”
思考过程：
1. 用户的问题需要“北京明天的天气”；
2. 我没有这些信息；
3. 需要调用“WeatherTool”获取天气信息；
4. 参数是城市名称“北京”。
决策：调用WeatherTool，参数{"city": "北京"}。

现在处理用户的问题：{input}

上下文历史：{history}

请按照案例中的思考过程，输出你的思考过程和决策。"""

# 生成Agent的提示
agent_prompt = ZeroShotAgent.create_prompt(
    tools=[weather_tool, user_purchase_tool],  # 假设已经定义了UserPurchaseTool
    prefix=prompt_template.split("{tools}")[0],
    suffix=prompt_template.split("{tools}")[1],
    input_variables=["input", "history"]
)

# 创建LLM链
llm_chain = LLMChain(llm=llm, prompt=agent_prompt)

# 创建Agent
agent = ZeroShotAgent(llm_chain=llm_chain, tools=[weather_tool, user_purchase_tool], verbose=True)

# 创建Agent执行器
agent_executor = AgentExecutor.from_agent_and_tools(
    agent=agent,
    tools=[weather_tool, user_purchase_tool],
    memory=memory,
    verbose=True
)

5. 效果对比：

优化后的智能体面对“我昨天买了一件羽绒服，今天想再买一条裤子，推荐一下？”的问题，会：

• 思考过程：“用户的问题需要羽绒服的风格、颜色（来自购买记录），我没有这些信息，需要调用UserPurchaseTool，参数是用户ID”；
• 决策：调用UserPurchaseTool获取用户的购买记录；
• 行动：根据购买记录（比如“黑色羽绒服，休闲风格”）推荐“黑色休闲裤”。

而基础智能体可能会直接回答“推荐牛仔裤”，忽略了用户的购买记录。

（四）步骤三：用NLP技术增强智能体——从“会做”到“做好”

Agentic AI的性能不仅取决于提示工程，还取决于NLP技术的应用。比如，感知模块的文本分类能让智能体更快理解用户意图，记忆模块的摘要技术能减少冗余信息。

1. 用文本分类优化感知模块：快速判断用户意图

用户的输入可能是模糊的（比如“我想选一件衣服”），需要用文本分类来判断用户的意图（比如“购买推荐”“查询订单”“投诉”）。

（1）定义意图分类器：
用Transformers库中的预训练模型（比如bert-base-chinese）实现文本分类：

from transformers import BertTokenizer, BertForSequenceClassification
import torch

# 加载预训练模型（用于意图分类）
tokenizer = BertTokenizer.from_pretrained("bert-base-chinese")
model = BertForSequenceClassification.from_pretrained("bert-base-chinese", num_labels=3)  # 3个意图：购买推荐、查询订单、投诉

# 定义意图标签
intent_labels = {0: "购买推荐", 1: "查询订单", 2: "投诉"}

# 定义意图分类函数
def classify_intent(text: str) -> str:
    """分类用户输入的意图"""
    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
    outputs = model(**inputs)
    predictions = torch.argmax(outputs.logits, dim=1)
    return intent_labels[predictions.item()]

（2）将意图分类整合到智能体的感知模块：

from langchain.schema import HumanMessage

# 定义感知函数（处理用户输入）
def perceive(input_text: str, history: list) -> dict:
    """感知用户输入，返回意图和处理后的输入"""
    # 分类意图
    intent = classify_intent(input_text)
    # 处理输入（比如提取实体）
    # 这里用简单的字符串处理示例，实际可以用实体识别模型
    if "天气" in input_text:
        city = input_text.split(" ")[-1]  # 假设用户输入是“明天北京的天气怎么样？”
    else:
        city = None
    # 返回感知结果
    return {
        "intent": intent,
        "city": city,
        "input_text": input_text,
        "history": history
    }

# 修改智能体的运行流程（加入感知模块）
def run_agent(input_text: str):
    # 感知用户输入
    perceive_result = perceive(input_text, memory.load_memory_variables({})["history"])
    # 将感知结果传入智能体
    response = agent_executor.run(
        input=perceive_result["input_text"],
        history=perceive_result["history"],
        intent=perceive_result["intent"],
        city=perceive_result["city"]
    )
    # 存储记忆
    memory.save_context({"input": input_text}, {"output": response})
    return response

说明：感知模块的作用是将用户的原始输入转化为智能体可理解的结构化信息，比如意图、实体（城市、用户ID等），这样智能体的决策模块能更高效地处理。

2. 用摘要技术优化记忆模块：减少冗余信息

当对话历史很长时，记忆模块会存储大量冗余信息（比如重复的问题），导致LLM的输入过长（超过上下文窗口）。这时可以用摘要技术总结对话历史，减少冗余。

（1）定义摘要函数：
用Transformers库中的预训练模型（比如facebook/bart-large-cnn）实现文本摘要：

from transformers import BartTokenizer, BartForConditionalGeneration

# 加载预训练模型（用于文本摘要）
tokenizer = BartTokenizer.from_pretrained("facebook/bart-large-cnn")
model = BartForConditionalGeneration.from_pretrained("facebook/bart-large-cnn")

# 定义摘要函数
def summarize(text: str, max_length: int = 100) -> str:
    """总结长文本"""
    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
    outputs = model.generate(
        inputs.input_ids,
        max_length=max_length,
        min_length=30,
        length_penalty=2.0,
        num_beams=4,
        early_stopping=True
    )
    return tokenizer.decode(outputs[0], skip_special_tokens=True)

（2）将摘要技术整合到记忆模块：

from langchain.memory import ConversationSummaryBufferMemory

# 初始化记忆模块（用摘要技术总结长对话）
memory = ConversationSummaryBufferMemory(
    memory_key="history",
    llm=llm,  # 用于生成摘要的LLM
    max_token_limit=500  # 当对话历史超过500 tokens时，总结 oldest 的对话
)

说明：ConversationSummaryBufferMemory会自动总结超过max_token_limit的对话历史，保持记忆模块的简洁，同时保留关键信息。

（五）步骤四：案例实战——搭建智能客服Agent

现在，我们将前面的知识整合起来，搭建一个智能客服Agent，需求如下：

• 能处理多轮对话（比如“我昨天买的衣服到哪了？”→“什么时候能送到？”）；
• 能调用工具（比如查询订单状态、获取用户购买记录）；
• 能生成自然的回答（比如用用户的语言风格回复）。

1. 架构设计

智能客服Agent的架构如下：

用户输入 → 感知模块（意图分类、实体识别） → 决策模块（用提示工程引导LLM做决策） → 行动模块（调用工具或生成回答） → 记忆模块（存储对话历史，用摘要技术优化） → 用户输出

2. 代码实现

（1）定义工具：

# 定义查询订单状态的工具
def get_order_status(order_id: str) -> str:
    """查询订单状态（模拟）"""
    # 假设从数据库中获取订单状态
    order_status = {
        "123456": "已发货，预计明天到达",
        "789012": "未付款",
        "345678": "已签收"
    }
    return order_status.get(order_id, "订单ID不存在")

# 定义获取用户购买记录的工具
def get_user_purchase(user_id: str) -> str:
    """获取用户购买记录（模拟）"""
    # 假设从数据库中获取用户购买记录
    purchase_history = {
        "123": "2024-05-01 购买了黑色羽绒服（订单ID：123456）；2024-04-20 购买了白色运动鞋（订单ID：789012）",
        "456": "2024-05-02 购买了蓝色牛仔裤（订单ID：345678）"
    }
    return purchase_history.get(user_id, "用户ID不存在")

# 封装成LangChain的Tool
order_tool = Tool(
    name="OrderTool",
    func=get_order_status,
    description="用于查询订单状态，输入参数是订单ID（比如“123456”）"
)

purchase_tool = Tool(
    name="PurchaseTool",
    func=get_user_purchase,
    description="用于获取用户购买记录，输入参数是用户ID（比如“123”）"
)

（2）定义感知模块：

from transformers import BertTokenizer, BertForSequenceClassification
import torch

# 加载意图分类模型（假设已经训练好）
tokenizer = BertTokenizer.from_pretrained("bert-base-chinese")
model = BertForSequenceClassification.from_pretrained("bert-base-chinese", num_labels=3)  # 3个意图：查询订单、购买推荐、投诉

# 定义意图标签
intent_labels = {0: "查询订单", 1: "购买推荐", 2: "投诉"}

# 定义实体识别函数（模拟）
def extract_entities(text: str) -> dict:
    """提取用户输入中的实体（订单ID、用户ID）"""
    entities = {}
    if "订单" in text:
        # 假设用户输入是“我的订单123456到哪了？”
        order_id = text.split("订单")[-1].strip()
        entities["order_id"] = order_id
    if "用户ID" in text:
        # 假设用户输入是“我的用户ID是123，查一下购买记录”
        user_id = text.split("用户ID是")[-1].strip()
        entities["user_id"] = user_id
    return entities

# 定义感知函数
def perceive(input_text: str, history: list) -> dict:
    """感知用户输入，返回意图和实体"""
    # 分类意图
    inputs = tokenizer(input_text, return_tensors="pt", padding=True, truncation=True)
    outputs = model(**inputs)
    intent = intent_labels[torch.argmax(outputs.logits, dim=1).item()]
    # 提取实体
    entities = extract_entities(input_text)
    # 返回感知结果
    return {
        "intent": intent,
        "entities": entities,
        "input_text": input_text,
        "history": history
    }

（3）定义提示模板（加入链式推理和少样本）：

from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI

# 初始化LLM
llm = OpenAI(temperature=0.5, model_name="gpt-3.5-turbo-instruct")  # 增加temperature，让回答更自然

# 定义提示模板
prompt_template = """你是一个智能客服，需要帮助用户解决问题。你可以使用以下工具：

{tools}

使用工具的格式要求：
如果需要调用工具，请用<|FunctionCallBegin|>和<|FunctionCallEnd|>包裹函数调用信息，例如：
<|FunctionCallBegin|>[{"name":"工具名称","parameters":{"参数名":"参数值"}}]<|FunctionCallEnd|>

如果不需要调用工具，请直接回答用户的问题。

以下是几个正确的决策案例：
案例1：
用户问题：“我的订单123456到哪了？”
意图：查询订单
实体：{"order_id": "123456"}
思考过程：
1. 用户的问题需要“订单123456的状态”；
2. 我没有这些信息（上下文历史中没有）；
3. 需要调用“OrderTool”查询订单状态；
4. 参数是订单ID“123456”。
决策：调用OrderTool，参数{"order_id": "123456"}。

案例2：
用户问题：“我昨天买了一件黑色羽绒服，今天想再买一条裤子，推荐一下？”
意图：购买推荐
实体：{"user_id": "123"}（来自上下文历史）
思考过程：
1. 用户的问题需要“羽绒服的风格、颜色”（来自购买记录）；
2. 我没有这些信息（上下文历史中没有）；
3. 需要调用“PurchaseTool”获取用户购买记录；
4. 参数是用户ID“123”。
决策：调用PurchaseTool，参数{"user_id": "123"}。

现在处理用户的问题：
输入文本：{input_text}
意图：{intent}
实体：{entities}
上下文历史：{history}

请按照案例中的思考过程，输出你的思考过程和决策。"""

# 生成Agent的提示
agent_prompt = ZeroShotAgent.create_prompt(
    tools=[order_tool, purchase_tool],
    prefix=prompt_template.split("{tools}")[0],
    suffix=prompt_template.split("{tools}")[1],
    input_variables=["input_text", "intent", "entities", "history"]
)

（4）创建智能体执行器：

from langchain.agents import ZeroShotAgent, AgentExecutor
from langchain.chains import LLMChain
from langchain.memory import ConversationSummaryBufferMemory

# 初始化记忆模块（用摘要技术总结长对话）
memory = ConversationSummaryBufferMemory(
    memory_key="history",
    llm=llm,
    max_token_limit=500
)

# 创建LLM链
llm_chain = LLMChain(llm=llm, prompt=agent_prompt)

# 创建Agent
agent = ZeroShotAgent(llm_chain=llm_chain, tools=[order_tool, purchase_tool], verbose=True)

# 创建Agent执行器
agent_executor = AgentExecutor.from_agent_and_tools(
    agent=agent,
    tools=[order_tool, purchase_tool],
    memory=memory,
    verbose=True
)

（5）定义运行函数（整合感知模块）：

def run_customer_service_agent(input_text: str):
    """运行智能客服Agent"""
    # 加载对话历史
    history = memory.load_memory_variables({})["history"]
    # 感知用户输入
    perceive_result = perceive(input_text, history)
    # 运行智能体
    response = agent_executor.run(
        input_text=perceive_result["input_text"],
        intent=perceive_result["intent"],
        entities=perceive_result["entities"],
        history=perceive_result["history"]
    )
    # 存储对话历史
    memory.save_context({"input": input_text}, {"output": response})
    # 返回回答
    return response

3. 测试智能客服Agent：

（1）测试“查询订单”：

input_text = "我的订单123456到哪了？"
response = run_customer_service_agent(input_text)
print("智能客服回答：", response)

运行结果：

思考过程：
1. 用户的问题需要“订单123456的状态”；
2. 我没有这些信息（上下文历史中没有）；
3. 需要调用“OrderTool”查询订单状态；
4. 参数是订单ID“123456”。
决策：<|FunctionCallBegin|>[{"name":"OrderTool","parameters":{"order_id":"123456"}}]<|FunctionCallEnd|>

调用OrderTool，得到结果：“已发货，预计明天到达”。

智能客服回答：你的订单123456已发货，预计明天到达。

（2）测试“购买推荐”（多轮对话）：

# 第一轮：用户提供用户ID
input_text1 = "我的用户ID是123，查一下购买记录"
response1 = run_customer_service_agent(input_text1)
print("智能客服回答1：", response1)

# 第二轮：用户请求推荐产品
input_text2 = "我昨天买了一件黑色羽绒服，今天想再买一条裤子，推荐一下？"
response2 = run_customer_service_agent(input_text2)
print("智能客服回答2：", response2)

运行结果：

# 第一轮：
思考过程：
1. 用户的问题需要“用户123的购买记录”；
2. 我没有这些信息（上下文历史中没有）；
3. 需要调用“PurchaseTool”获取用户购买记录；
4. 参数是用户ID“123”。
决策：<|FunctionCallBegin|>[{"name":"PurchaseTool","parameters":{"user_id":"123"}}]<|FunctionCallEnd|>

调用PurchaseTool，得到结果：“2024-05-01 购买了黑色羽绒服（订单ID：123456）；2024-04-20 购买了白色运动鞋（订单ID：789012）”。

智能客服回答1：你的购买记录如下：2024-05-01 购买了黑色羽绒服（订单ID：123456）；2024-04-20 购买了白色运动鞋（订单ID：789012）。

# 第二轮：
思考过程：
1. 用户的问题需要“羽绒服的风格、颜色”（来自购买记录）；
2. 我已经有这些信息（上下文历史中存在：黑色羽绒服）；
3. 不需要调用工具；
4. 直接推荐搭配的裤子。
决策：不需要调用工具。

智能客服回答2：根据你的购买记录（黑色羽绒服），推荐你购买黑色休闲裤，搭配起来更协调。

四、进阶探讨：Agentic AI与NLP的未来方向

1. 多模态智能体：结合文本与图像/语音

目前的智能体主要处理文本输入，未来可以结合图像识别（比如用户发送一张衣服的照片，智能体推荐搭配）、语音识别（比如用户用语音咨询，智能体转换为文本处理），实现多模态交互。

2. 性能优化：处理大规模数据

当智能体需要处理大规模数据（比如百万级用户的购买记录）时，需要优化：

• 工具调用效率：用缓存（比如Redis）存储常用工具的返回结果，减少重复调用；
• LLM推理速度：用轻量化LLM（比如Llama 2 7B）或模型压缩技术（比如量化），减少延迟；
• 记忆模块效率：用向量数据库（比如Pinecone）存储对话历史，快速检索相关信息。

3. 伦理与安全：防止智能体“作恶”

智能体的自主决策能力带来了伦理风险（比如生成有害内容、调用恶意工具），需要：

• 提示工程约束：在提示模板中加入伦理要求（比如“不生成有害内容”）；
• 工具调用审核：对工具的调用进行权限控制（比如只有管理员才能调用删除数据的工具）；
• 输出过滤：用内容审核模型（比如OpenAI的Content Moderation API）过滤有害输出。

五、总结：从提示词到智能体，是提示工程架构师的进阶之路

本文从静态提示的局限入手，讲解了Agentic AI的核心组件，并通过LangChain手把手教你搭建了一个能处理复杂任务的智能体。我们还探讨了提示工程优化（链式推理、少样本提示）和NLP技术增强（文本分类、摘要技术）的方法，最后通过智能客服案例展示了这些技术的整合应用。

关键结论：

• Agentic AI不是“更强大的LLM”，而是“用提示工程连接LLM与外部世界的系统”；
• 提示工程是智能体的“大脑”，决定了智能体的决策能力；
• NLP技术是智能体的“感官”，决定了智能体的感知与表达能力。

通过本文的学习，你已经掌握了Agentic AI与NLP融合的核心逻辑，接下来可以尝试：

• 修改智能客服案例，添加新的工具（比如“投诉处理工具”）；
• 用多模态技术增强智能体（比如结合图像识别）；
• 优化智能体的性能（比如用向量数据库存储记忆）。

六、行动号召：一起探索Agentic AI的无限可能

如果你在实践中遇到任何问题，欢迎在评论区留言讨论！也可以分享你的智能体项目，让我们一起学习进步。

另外，如果你想深入学习Agentic AI，可以关注以下资源：

• LangChain官方文档：https://python.langchain.com/
• OpenAI Agentic AI指南：https://platform.openai.com/docs/guides/agents
• 《Agentic AI: A Comprehensive Guide》（书籍）。

让我们一起从“提示词工程师”进阶为“Agentic AI架构师”，用智能体改变世界！