📋 本文目录
一、前言
1.1 工具化的上下文感知
把上下文感知功能拆分成5个独立工具，灵活组合使用：
-
可以单独使用某个工具
-
可以按顺序组合成工具链
-
可以集成到Agent中
1.2 你将学到什么？
-
✅ 实现上下文收集工具
-
✅ 实现上下文建模工具
-
✅ 实现上下文推理工具
-
✅ 实现情境响应工具
-
✅ 实现上下文管理工具
二、工具概览
2.1 5个工具
| 工具 | 文件 | 作用 |
|---|---|---|
| 上下文收集器 | tool_1_context_collector.py | 收集多源上下文信息 |
| 上下文建模器 | tool_2_context_modeler.py | 构建上下文表示 |
| 上下文推理器 | tool_3_context_reasoner.py | 基于上下文进行推断 |
| 情境响应器 | tool_4_situational_responder.py | 生成情境相关响应 |
| 上下文管理器 | tool_5_context_manager.py | 管理上下文生命周期 |
2.2 文件结构
05_context_awareness/
├── shared_context.py # 共享存储
├── tool_1_context_collector.py # 工具1
├── tool_2_context_modeler.py # 工具2
├── tool_3_context_reasoner.py # 工具3
├── tool_4_situational_responder.py # 工具4
├── tool_5_context_manager.py # 工具5
├── context_chain_demo.py # 工具链演示
├── context_agent_demo.py # Agent演示
└── sample_contexts.json # 示例数据三、工具1：上下文收集器
3.1 功能说明
从多个来源收集上下文信息：对话、用户、环境、任务。支持分类收集或一次性收集所有上下文。
3.2 核心代码
from langchain.tools import tool
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from shared_context import context_store, update_dialogue, update_user, update_environment, update_task, get_context, init_environment_context
@tool
def context_collector(context_type, data=None):
"""收集多源上下文信息
参数:
context_type: 上下文类型 (dialogue/user/environment/task/all)
data: 上下文数据，字典格式，可选
返回:
收集结果
"""
results = []
if context_type == "dialogue" and data:
# 收集对话上下文
role = data.get("role", "user")
content = data.get("content", "")
update_dialogue(role, content)
results.append(f"对话上下文已更新: {role} - {content[:30]}...")
elif context_type == "user" and data:
# 收集用户上下文
for key, value in data.items():
update_user(key, value)
results.append(f"用户上下文已更新: {', '.join(data.keys())}")
elif context_type == "environment":
# 收集环境上下文（自动更新）
init_environment_context()
env = context_store["environment"]
results.append(f"环境上下文已更新: {env.get('date', '')} {env.get('time', '')}")
elif context_type == "task" and data:
# 收集任务上下文
for key, value in data.items():
update_task(key, value)
results.append(f"任务上下文已更新: {', '.join(data.keys())}")
elif context_type == "all":
# 收集所有上下文
init_environment_context()
if data:
if "user" in data:
for key, value in data["user"].items():
update_user(key, value)
if "task" in data:
for key, value in data["task"].items():
update_task(key, value)
results.append("所有上下文已收集")
else:
results.append(f"未知的上下文类型: {context_type}")
return "\n".join(results)3.3 使用示例
# 收集环境上下文
result = context_collector.invoke({"context_type": "environment"})
print(result)
# 收集用户上下文
user_data = {
"name": "小明",
"age": 28,
"role": "开发工程师",
"preference": "喜欢Python编程"
}
result = context_collector.invoke({
"context_type": "user",
"data": user_data
})
print(result)
# 收集对话上下文
dialogue_data = {
"role": "user",
"content": "你好，我想了解一下上下文感知系统"
}
result = context_collector.invoke({
"context_type": "dialogue",
"data": dialogue_data
})
print(result)四、工具2：上下文建模器
4.1 功能说明
把收集到的上下文信息组织成结构化表示，支持单独建模某类上下文或全部上下文。
4.2 核心代码
from langchain.tools import tool
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from shared_context import context_store, get_context
@tool
def context_modeler(context_type=None):
"""构建上下文表示
参数:
context_type: 上下文类型 (dialogue/user/environment/task/all)，可选
返回:
结构化的上下文表示
"""
context = get_context()
result = []
if context_type is None or context_type == "all":
types_to_process = ["dialogue", "user", "environment", "task"]
else:
types_to_process = [context_type]
for ctx_type in types_to_process:
if ctx_type == "dialogue":
# 对话上下文建模
dialogue = context["dialogue"]
if dialogue:
result.append("【对话上下文】")
for i, msg in enumerate(dialogue[-5:], 1): # 只显示最近5条
result.append(f" {i}. [{msg['role']}] {msg['content'][:40]}...")
else:
result.append("【对话上下文】无对话记录")
elif ctx_type == "user":
# 用户上下文建模
user = context["user"]
if user:
result.append("【用户上下文】")
for key, value in user.items():
result.append(f" {key}: {value}")
else:
result.append("【用户上下文】无用户信息")
elif ctx_type == "environment":
# 环境上下文建模
env = context["environment"]
if env:
result.append("【环境上下文】")
result.append(f" 时间: {env.get('date', '')} {env.get('time', '')}")
result.append(f" 星期: {env.get('weekday', '')}")
result.append(f" 时段: {'上午' if env.get('hour', 0) < 12 else '下午' if env.get('hour', 0) < 18 else '晚上'}")
result.append(f" 周末: {'是' if env.get('is_weekend', False) else '否'}")
else:
result.append("【环境上下文】无环境信息")
elif ctx_type == "task":
# 任务上下文建模
task = context["task"]
if task:
result.append("【任务上下文】")
for key, value in task.items():
result.append(f" {key}: {value}")
else:
result.append("【任务上下文】无任务信息")
return "\n".join(result)4.3 使用示例
# 建模所有上下文
result = context_modeler.invoke({})
print(result)
# 只建模用户上下文
result = context_modeler.invoke({"context_type": "user"})
print(result)五、工具3：上下文推理器
5.1 功能说明
基于上下文信息进行智能推断，包括情境推理、意图推理和需求推理。
5.2 核心代码
from langchain.tools import tool
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from shared_context import context_store, get_context
@tool
def context_reasoner(reasoning_type="situation"):
"""基于上下文进行推断
参数:
reasoning_type: 推理类型 (situation/intent/need/all)
返回:
推理结果
"""
context = get_context()
results = []
if reasoning_type == "situation" or reasoning_type == "all":
# 情境推理
results.append("【情境推理】")
situation = infer_situation(context)
results.append(f" 当前情境: {situation}")
if reasoning_type == "intent" or reasoning_type == "all":
# 意图推理
results.append("【意图推理】")
intent = infer_intent(context)
results.append(f" 用户意图: {intent}")
if reasoning_type == "need" or reasoning_type == "all":
# 需求推理
results.append("【需求推理】")
needs = infer_needs(context)
results.append(f" 用户需求: {needs}")
return "\n".join(results)
def infer_situation(context):
"""推理当前情境"""
env = context["environment"]
hour = env.get("hour", 12)
is_weekend = env.get("is_weekend", False)
if is_weekend:
if 6 <= hour < 12:
return "周末上午，可能比较放松"
elif 12 <= hour < 18:
return "周末下午，适合休闲活动"
else:
return "周末晚上，休息时间"
else:
if 9 <= hour < 12:
return "工作日上午，工作时间"
elif 14 <= hour < 18:
return "工作日下午，工作时间"
elif 12 <= hour < 14:
return "工作日中午，午休时间"
else:
return "非工作时间"
def infer_intent(context):
"""推理用户意图"""
dialogue = context["dialogue"]
if not dialogue:
return "未知，需要更多对话"
last_msg = dialogue[-1]["content"].lower()
# 简单的关键词匹配
if any(keyword in last_msg for keyword in ["学习", "了解", "知道", "什么"]):
return "获取信息或学习"
elif any(keyword in last_msg for keyword in ["帮助", "帮我", "求助"]):
return "寻求帮助"
elif any(keyword in last_msg for keyword in ["问题", "错误", "bug"]):
return "解决问题"
elif any(keyword in last_msg for keyword in ["推荐", "建议", "选哪个"]):
return "寻求推荐"
else:
return "一般对话"
def infer_needs(context):
"""推理用户需求"""
user = context["user"]
needs = []
# 基于用户信息推理需求
if user.get("role") == "开发工程师":
needs.append("技术相关内容")
if "Python" in str(user.get("preference", "")):
needs.append("Python相关内容")
# 基于情境推理需求
env = context["environment"]
if not env.get("is_weekend", False) and 9 <= env.get("hour", 0) < 18:
needs.append("工作相关内容")
if not needs:
return "未明确特定需求"
return ", ".join(needs)5.3 使用示例
# 完整推理
result = context_reasoner.invoke({"reasoning_type": "all"})
print(result)
# 只做情境推理
result = context_reasoner.invoke({"reasoning_type": "situation"})
print(result)六、工具4：情境响应器
6.1 功能说明
根据上下文生成个性化的响应，包括问候、情境建议和上下文相关的内容回复。
6.2 核心代码
from langchain.tools import tool
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from shared_context import context_store, get_context, get_context_summary
@tool
def situational_responder(user_input=""):
"""生成情境相关响应
参数:
user_input: 用户输入文本
返回:
个性化响应
"""
context = get_context()
response_parts = []
# 1. 根据时间问候
env = context["environment"]
hour = env.get("hour", 12)
if 5 <= hour < 12:
greeting = "早上好"
elif 12 <= hour < 18:
greeting = "下午好"
else:
greeting = "晚上好"
response_parts.append(greeting)
# 2. 个性化称呼
user = context["user"]
if user.get("name"):
response_parts.append(f"{user['name']}！")
else:
response_parts.append("！")
# 3. 情境相关内容
situation = get_situation_suggestion(context)
if situation:
response_parts.append(f"\n{situation}")
# 4. 响应用户输入
if user_input:
response_parts.append(f"\n关于您说的「{user_input}」，")
response_parts.append(get_contextual_reply(user_input, context))
return "".join(response_parts)
def get_situation_suggestion(context):
"""获取情境建议"""
env = context["environment"]
hour = env.get("hour", 12)
is_weekend = env.get("is_weekend", False)
user = context["user"]
suggestions = []
# 基于时间的建议
if 11 <= hour < 13:
suggestions.append("现在是午餐时间，记得按时吃饭哦！")
elif 17 <= hour < 19:
suggestions.append("现在是下班时间，辛苦了！")
elif 22 <= hour or hour < 6:
suggestions.append("夜深了，注意休息！")
# 基于用户角色的建议
if user.get("role") == "开发工程师":
if not is_weekend and 9 <= hour < 18:
suggestions.append("工作期间注意劳逸结合！")
return "\n".join(suggestions) if suggestions else ""
def get_contextual_reply(user_input, context):
"""获取上下文相关回复"""
user = context["user"]
user_input_lower = user_input.lower()
# 基于用户偏好的回复
if "python" in user_input_lower and "Python" in str(user.get("preference", "")):
return "我知道您喜欢Python编程！Python是一门很棒的语言，广泛应用于AI、数据科学等领域。"
# 基于对话历史的回复
dialogue = context["dialogue"]
if len(dialogue) > 1:
return "我会记住我们的对话，为您提供连贯的服务。"
return "我正在努力理解您的需求，让我为您提供最好的帮助！"6.3 使用示例
# 测试问候响应
result = situational_responder.invoke({})
print(result)
# 测试用户输入响应
result = situational_responder.invoke({"user_input": "我想学习Python"})
print(result)七、工具5：上下文管理器
7.1 功能说明
管理上下文的生命周期：查看、更新、清除、导出等操作。
7.2 核心代码
from langchain.tools import tool
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from shared_context import context_store, get_context, clear_context, get_context_summary
@tool
def context_manager(command, key=None, value=None):
"""管理上下文生命周期
参数:
command: 命令 (get/set/delete/clear/summary/export)
key: 键名，用于set/delete
value: 值，用于set
返回:
操作结果
"""
if command == "get":
# 获取上下文
if key:
# 获取特定上下文
parts = key.split(".")
if len(parts) == 1:
result = context_store.get(parts[0], {})
else:
result = context_store.get(parts[0], {}).get(parts[1], "未找到")
return f"【{key}】\n{result}"
else:
# 获取所有上下文摘要
return context_summary()
elif command == "set":
# 设置上下文
if not key or value is None:
return "设置操作需要提供key和value参数"
parts = key.split(".")
if len(parts) == 2:
ctx_type, ctx_key = parts
if ctx_type in context_store:
if isinstance(context_store[ctx_type], dict):
context_store[ctx_type][ctx_key] = value
return f"已设置 {key} = {value}"
return f"设置失败: {key}"
elif command == "delete":
# 删除上下文
if not key:
return "删除操作需要提供key参数"
parts = key.split(".")
if len(parts) == 2:
ctx_type, ctx_key = parts
if ctx_type in context_store and ctx_key in context_store[ctx_type]:
del context_store[ctx_type][ctx_key]
return f"已删除 {key}"
return f"删除失败: {key}"
elif command == "clear":
# 清除所有上下文
clear_context()
return "所有上下文已清除"
elif command == "summary":
# 获取摘要
return context_summary()
elif command == "export":
# 导出上下文
import json
return json.dumps(get_context(), ensure_ascii=False, indent=2)
else:
return f"未知命令: {command}，支持的命令: get/set/delete/clear/summary/export"
def context_summary():
"""生成上下文摘要"""
context = get_context()
summary = []
summary.append("=" * 40)
summary.append("上下文摘要")
summary.append("=" * 40)
# 对话
dialogue_count = len(context["dialogue"])
summary.append(f"对话: {dialogue_count}条")
if dialogue_count > 0:
last_msg = context["dialogue"][-1]
summary.append(f" 最新: [{last_msg['role']}] {last_msg['content'][:30]}...")
# 用户
user_count = len(context["user"])
summary.append(f"用户: {user_count}项")
if user_count > 0:
user_info = ", ".join([f"{k}={v}" for k, v in list(context["user"].items())[:3]])
summary.append(f" 信息: {user_info}")
# 环境
env = context["environment"]
summary.append(f"环境: {env.get('date', '')} {env.get('time', '')}")
# 任务
task_count = len(context["task"])
summary.append(f"任务: {task_count}项")
summary.append("=" * 40)
return "\n".join(summary)7.3 使用示例
# 获取摘要
result = context_manager.invoke({"command": "summary"})
print(result)
# 获取特定上下文
result = context_manager.invoke({"command": "get", "key": "user.name"})
print(result)
# 设置上下文
result = context_manager.invoke({"command": "set", "key": "user.age", "value": 25})
print(result)
# 导出上下文
result = context_manager.invoke({"command": "export"})
print(result)
# 清除上下文
result = context_manager.invoke({"command": "clear"})
print(result)八、完整实战演示
8.1 工具链演示
我们将5个工具组合成完整的上下文处理流程：
from tool_1_context_collector import context_collector
from tool_2_context_modeler import context_modeler
from tool_3_context_reasoner import context_reasoner
from tool_4_situational_responder import situational_responder
from tool_5_context_manager import context_manager
# 步骤1: 收集上下文
user_data = {
"name": "小明",
"age": 28,
"role": "开发工程师",
"preference": "喜欢Python编程"
}
context_collector.invoke({"context_type": "user", "data": user_data})
task_data = {
"current_task": "学习上下文感知系统",
"progress": "开始阶段",
"priority": "high"
}
context_collector.invoke({"context_type": "task", "data": task_data})
# 收集对话
context_collector.invoke({
"context_type": "dialogue",
"data": {"role": "user", "content": "你好，我叫小明"}
})
# 步骤2: 建模上下文
context_model = context_modeler.invoke({})
print(context_model)
# 步骤3: 推理上下文
analysis = context_reasoner.invoke({"reasoning_type": "all"})
print(analysis)
# 步骤4: 生成响应
response = situational_responder.invoke({"user_input": "我想学习上下文感知系统"})
print(response)
# 步骤5: 管理上下文
summary = context_manager.invoke({"command": "summary"})
print(summary)8.2 运行演示
cd 05_context_awareness
python context_chain_demo.py8.3 演示内容
-
收集多种上下文信息（用户、任务、对话）
-
构建结构化的上下文模型
-
基于上下文进行智能推理（情境、意图、需求）
-
生成个性化的情境响应
-
管理上下文生命周期
九、思考与建议
9.1 从这5个工具中获得的启发
我们设计这5个上下文工具时，遵循了单一职责原则 和模块化设计。每个工具只做一件事，但组合起来就能完成复杂的上下文感知任务。
9.2 在你的业务中如何应用
思考一下你的业务场景：
-
电商客服：可以用上下文收集器记住用户浏览过的商品，用推理器分析用户意图，用响应器推荐相关商品
-
学习助手：可以用上下文管理器记住用户的学习进度，用情境响应器在合适的时间提醒复习
-
智能办公：可以用环境上下文（工作日/周末、工作时间/休息时间）来调整回复的紧急程度
9.3 扩展思路
当前的实现是基础版，你可以根据需求扩展：
-
接入真实传感器：环境上下文不只是时间，还可以接入GPS、天气API等
-
更智能的推理：可以接入大模型来做更复杂的意图识别和需求分析
-
持久化存储：可以把用户上下文保存到数据库，下次用户回来时还能记住
-
多用户支持：当前是单用户，可以扩展为多用户上下文管理
9.4 建议动手试试
-
先运行本文中的示例，看看效果
-
尝试修改工具代码，加入你自己的业务逻辑
-
把这些工具集成到你现有的应用中
十、总结与下一步
10.1 本文要点
| 要点 | 说明 |
|---|---|
| ✅ 上下文收集 | 多源信息收集 |
| ✅ 上下文建模 | 结构化表示 |
| ✅ 上下文推理 | 智能推断 |
| ✅ 情境响应 | 个性化回复 |
| ✅ 上下文管理 | 生命周期管理 |
点赞 + 关注，更新不迷路！🚀