AI上下文工程知识图谱集成：提示工程架构师的扩展性设计

想象你是一家智能客服公司的技术负责人：最初，客服AI只需回答"产品价格"“售后政策"等简单问题，上下文管理很简单——把最近3轮对话存起来就行。信息过载：对话历史+产品手册+用户订单+配件型号…上下文长度远超模型限制；知识碎片化：用户问题涉及的"旧型号洗衣机参数"“保修政策条款”"配件兼容性规则"分散在不同文档中，AI难以关联；扩展性差：新增产品线时，需要重写大量提示词，系统像"用胶水粘起来的积木"

大厂前端小白菜

1020人浏览 · 2025-09-01 03:47:20

大厂前端小白菜 · 2025-09-01 03:47:20 发布

AI上下文工程知识图谱集成：提示工程架构师的扩展性设计

关键词：AI上下文工程、知识图谱集成、提示工程、架构扩展性、上下文管理、知识图谱构建、提示设计模式

摘要：在AI大模型时代，“上下文"是决定AI响应质量的核心要素——就像人类对话需要结合背景信息才能理解对方意图，AI系统也需要准确、完整的上下文才能生成相关响应。但随着AI应用场景复杂化（如多轮对话、跨领域任务、动态知识更新），传统上下文管理方式面临"信息过载”“知识碎片化”“扩展性不足"三大挑战。本文将以"提示工程架构师"的视角，用生活化的比喻和实例，系统讲解如何通过知识图谱集成破解这些难题：从核心概念（上下文工程、知识图谱、提示工程的"三角关系”）到架构设计（如何像搭乐高一样构建可扩展的上下文系统），再到实战落地（用Python实现知识图谱驱动的上下文增强），最终帮助读者掌握"让AI既能记住短期对话，又能调用长期知识"的扩展性设计方法论。

背景介绍

目的和范围

想象你是一家智能客服公司的技术负责人：最初，客服AI只需回答"产品价格"“售后政策"等简单问题，上下文管理很简单——把最近3轮对话存起来就行。但随着业务扩展，AI需要处理"帮我查去年3月买的冰箱保修状态”"这款洗衣机和我家旧型号的配件通用吗"等复杂问题，这时候传统上下文管理就"卡壳"了：

信息过载：对话历史+产品手册+用户订单+配件型号…上下文长度远超模型限制；
知识碎片化：用户问题涉及的"旧型号洗衣机参数"“保修政策条款”"配件兼容性规则"分散在不同文档中，AI难以关联；
扩展性差：新增产品线时，需要重写大量提示词，系统像"用胶水粘起来的积木"，一碰就散。

本文目的：解决上述问题——讲解如何将知识图谱（结构化的"知识大脑"）集成到AI上下文工程中，让提示工程架构师能设计出"像乐高一样可扩展"的系统：新增知识时只需"拼上新积木"，无需重构整体；上下文管理时"按需调取知识"，避免信息过载；知识关联时"通过图谱路径自动串联"，破解碎片化难题。

范围：覆盖上下文工程与知识图谱的核心概念、集成架构、关键算法、实战代码（Python实现知识图谱驱动的上下文增强）、应用场景及扩展性设计原则，不涉及底层大模型训练细节。

预期读者

提示工程架构师：负责设计AI系统提示流程和上下文管理框架的工程师；
AI应用开发者：需要将知识图谱与大模型结合的工程师（如智能客服、医疗诊断AI开发者）；
技术产品经理：希望理解AI系统扩展性设计原理的产品负责人；
对AI系统设计感兴趣的学习者：想深入了解上下文管理与知识工程的同学。

文档结构概述

本文像"拆乐高玩具"一样分步骤讲解：

拆包装（背景介绍）：为什么需要知识图谱集成？解决什么问题？
认零件（核心概念）：上下文工程、知识图谱、提示工程分别是什么？它们如何配合？
看图纸（架构设计）：知识图谱如何嵌入上下文工程？有哪些关键模块？
拼积木（算法与实战）：用Python代码实现知识图谱查询、上下文增强、提示生成的全流程；
玩场景（应用与扩展）：在智能客服、医疗诊断等场景中如何扩展这套架构？

术语表

核心术语定义

术语	通俗定义（小学生能懂版）	专业定义
AI上下文工程	AI的"短期记忆管家"：负责记录对话中的关键信息（如用户说过"我买了冰箱"），并决定哪些信息需要"记住"、哪些可以"忘记"，确保AI回答时不"失忆"也不"啰嗦"。	在AI交互过程中，动态管理上下文信息（对话历史、用户状态、任务背景等）的生命周期（采集、存储、筛选、更新、销毁），以优化AI理解与响应质量的工程实践。
知识图谱	AI的"结构化百科全书"：像族谱一样，把知识拆成"实体"（如"冰箱"）和"关系"（如"属于→家电产品"），用图形展示谁和谁有关系，方便AI快速查找和关联知识。	以实体为节点、关系为边，结构化表示知识的有向图数据模型，支持实体间语义关系的存储、查询与推理。
提示工程	给AI"写说明书"：告诉AI"你现在是客服，要礼貌回答，遇到不知道的问题就说’我帮你转接人工’"，让AI知道该做什么、怎么做。	通过设计提示词（Prompt）引导AI生成期望输出的技术，包括指令设计、上下文组织、格式约束等技巧。
架构扩展性	系统的"可成长性"：像可扩展的书包，新增课本时不用换书包，直接加个隔层就行；新增功能时不用重写所有代码，只需加个模块。	系统在新增功能、数据或用户规模时，保持低修改成本、高复用性的设计特性，通常通过模块化、松耦合、标准化接口实现。

缩略词列表

KG：知识图谱（Knowledge Graph）
CE：上下文工程（Context Engineering）
PE：提示工程（Prompt Engineering）
LLM：大语言模型（Large Language Model）
SPARQL：知识图谱查询语言（Simple Protocol and RDF Query Language）

核心概念与联系

故事引入：“智能客服的成长烦恼”

第1幕：简单对话时代
2022年，小A公司的智能客服AI"小服"刚上线，只能回答简单问题：

用户：“你们的冰箱多少钱？”
小服：“冰箱A型号2999元，B型号3999元。”

这时上下文管理很简单：小服只需记住用户当前问题（“冰箱多少钱”），提示词也很简单："你是客服，回答用户关于产品价格的问题，用列表形式。"

第2幕：信息爆炸危机
2023年，用户开始问复杂问题：

用户：“我去年3月15日买的冰箱A型号，现在不制冷了，还在保修期吗？需要带什么凭证？另外，这款冰箱的压缩机和B型号通用吗？我想换个静音的。”

小服的"大脑"开始混乱：

上下文过载：用户问题涉及"购买时间"“型号”“故障”“保修政策”“凭证要求”“压缩机型号”“兼容性”，传统上下文窗口存不下这么多信息；
知识碎片化：保修政策在PDF手册第5页，压缩机型号在产品参数表，兼容性数据在配件数据库，小服无法关联；
扩展性差：新增C型号冰箱时，需要重写提示词，把C型号的参数手动加进去，否则小服"不认识"。

第3幕：知识图谱来救场
小A公司请提示工程架构师老王设计了"知识图谱+上下文工程"系统：

构建产品知识图谱：实体包括"冰箱A型号""保修政策2023"“压缩机M100”，关系包括"A型号→使用→压缩机M100"“保修政策2023→适用→A型号”；
设计上下文动态增强模块：用户提到"A型号冰箱"，系统自动查询知识图谱，提取"购买时间是否在保修期"“压缩机型号”"兼容性"等相关知识，只把有用信息加入上下文，避免过载；
实现模块化提示模板：新增C型号时，只需往知识图谱加实体和关系，提示词无需修改——系统会自动从图谱中拉取C型号的信息。

现在小服的回答变得清晰准确：

小服：“根据您的购买时间（2023年3月15日）和保修政策，冰箱A型号仍在2年保修期内（截止2025年3月14日）。需携带购买发票或订单截图作为凭证。您的冰箱使用的是压缩机M100，与B型号的压缩机M200不通用，但我们有静音版压缩机M100S可直接替换，是否需要为您转接配件部门？”

这个故事里，知识图谱就像"智能客服的大脑记忆库"，上下文工程是"记忆管家"，提示工程是"说话顾问"——三者协作，让AI从"健忘的新手"变成"专业的专家"。

核心概念解释（像给小学生讲故事一样）

核心概念一：AI上下文工程——AI的"短期记忆管家"

想象你和朋友打电话，对方说：“昨天我们聊的那个电影，主角叫什么来着？“你能回答，是因为你"记住了昨天的对话”——这就是"上下文”。AI的上下文工程，就是给AI当"记忆管家"，负责三件事：

记什么：从对话中挑出关键信息（如用户说"我买了冰箱"，要记住"用户购买了冰箱"这个事实）；
记多久：有些信息要长期记（如用户的会员等级），有些临时记（如当前对话中的问题）；
怎么用：回答时把相关记忆"调出来"（用户问保修时，调出"购买时间"）。

生活例子：上下文工程就像学校里的"值日生"：

早上来（对话开始）：擦黑板（清空旧上下文），准备粉笔（初始化必要信息，如用户ID）；
上课中（对话进行）：老师写重点时记笔记（提取关键上下文），擦掉无关的草稿（清理冗余信息）；
提问时（AI生成响应）：把笔记递给老师参考（将上下文传入提示词）。

核心概念二：知识图谱——AI的"结构化百科全书"

如果说上下文工程是"短期记忆"，知识图谱就是AI的"长期记忆百科全书"。但它不是普通百科全书，而是"带索引的族谱"：

实体：百科全书中的"词条名"（如"冰箱A型号"“保修政策”）；
关系：词条间的"连接线"（如"A型号→属于→冰箱系列"）；
属性：词条的"详情"（如"A型号的价格：2999元，保修期：2年"）。

生活例子：知识图谱就像"家庭相册的关系图"：

实体：你、爸爸、妈妈、爷爷（每个人是一个"节点"）；
关系：你→儿子→爸爸，爸爸→儿子→爷爷（关系是"连接线"）；
属性：爸爸的生日是1980年（每个节点的"标签"）。
有了这个图，当有人问"你爷爷的孙子是谁"，你能立刻顺着连接线找到答案——AI用知识图谱查知识，也是这个道理。

核心概念三：提示工程——给AI的"任务说明书"

AI是个"聪明但不知道该做什么的助手"，提示工程就是"给AI写任务说明书"，告诉它：

你是谁（角色：“你是客服”）；
做什么（任务：“回答保修问题”）；
怎么做（规则：“回答要简洁，用口语化中文”）。

生活例子：提示工程就像"给新来的同学写值日指南"：

角色：“今天你是值日生”；
任务：“擦黑板、整理讲台、倒垃圾”；
规则：“擦黑板要擦到边框，垃圾要分类”。
写得越清楚，新来的同学（AI）就做得越好。

核心概念四：架构扩展性——AI系统的"可成长骨架"

扩展性就是"系统长大的能力"。就像搭积木：

差的扩展性：用胶水把积木粘死，想加新积木只能把原来的拆掉；
好的扩展性：用卡扣连接积木，新增积木直接扣上，不用拆原来的。

提示工程架构师设计扩展性，就是"给AI系统设计卡扣"：新增知识（如新产品）、新功能（如多语言支持）时，不用重写整个系统，只需加个"新积木"。

生活例子：扩展性好的系统就像"可扩展的书包"：

刚开始上学（简单需求）：用小书包（基础系统）；
加课本（新增知识）：书包有拉链隔层（模块化设计），直接加一层；
加水壶（新增功能）：书包侧面有网兜（预留接口），直接挂上。

核心概念之间的关系（用小学生能理解的比喻）

上下文工程 × 知识图谱：短期记忆+长期记忆=完整记忆

上下文工程（短期记忆）和知识图谱（长期记忆）的关系，就像"考试时的草稿纸和课本"：

草稿纸（上下文）：记临时信息（如题目中的数字）；
课本（知识图谱）：记长期知识（如公式、定理）；
合作方式：做题时，草稿纸写计算过程，遇到忘了的公式就翻课本——AI回答问题时，上下文存对话中的临时信息（用户说"我买了冰箱"），知识图谱存背景知识（冰箱保修期2年），两者结合才能算出"是否在保修期"。

具体例子：用户问"我的冰箱能保修吗"：

上下文工程：从对话中找到"用户购买冰箱的时间是2023年3月"（草稿纸记数字）；
知识图谱：查到"冰箱保修期是2年"（课本查公式）；
结合计算：2023+2=2025，当前是2024年→在保修期内（用草稿纸数字+课本公式算结果）。

提示工程 × 知识图谱：说明书+百科全书=专业指南

提示工程（说明书）和知识图谱（百科全书）的关系，就像"厨师的菜谱和食材库"：

菜谱（提示工程）：告诉厨师"怎么做菜"（AI怎么回答）；
食材库（知识图谱）：提供做菜的原料（AI回答需要的知识）；
合作方式：菜谱说"放2勺盐"，厨师从食材库拿盐——提示工程说"回答保修问题"，AI从知识图谱拿保修政策。

具体例子：提示词是"你是客服，回答用户的保修问题"：

提示工程：规定回答格式（“先说明是否在保，再列需带凭证”）；
知识图谱：提供保修政策（“保修期2年，凭证包括发票”）；
结合生成：AI按提示格式，用知识图谱中的政策生成回答。

上下文工程 × 提示工程：记忆+说明书=精准执行

上下文工程（记忆）和提示工程（说明书）的关系，就像"快递员的送货单和包裹"：

送货单（提示工程）：告诉快递员"送什么、送到哪"（AI的任务和规则）；
包裹（上下文工程）：要送的东西（对话中的关键信息）；
合作方式：快递员按送货单地址，把包裹送给收件人——AI按提示词规则，用上下文信息生成响应。

具体例子：用户问"我的订单到哪了"：

上下文工程：从对话中提取"用户订单号：12345"（包裹）；
提示工程：提示词是"你是客服，用订单号查询物流，回复格式：‘订单12345当前状态：XX，预计送达时间：XX’"（送货单）；
结合执行：AI用订单号查物流，按提示格式回复。

三者协同：记忆管家+百科全书+说明书=智能AI

把三个概念放一起，就像"侦探破案"：

上下文工程（记忆管家）：收集案发现场的线索（对话中的用户信息）；
知识图谱（百科全书）：提供犯罪学知识、嫌疑人背景（背景知识）；
提示工程（说明书）：告诉侦探"按逻辑链推理，用简洁语言汇报"（任务规则）。
三者合作，侦探（AI）才能快速破案（生成准确响应）。

核心概念原理和架构的文本示意图（专业定义）

AI上下文工程的原理架构

AI上下文工程是"上下文信息的全生命周期管理系统"，核心模块包括：

上下文采集模块：从对话（文本/语音）、用户画像、外部系统（如订单数据库）中提取上下文信息（实体、属性、意图）；
上下文存储模块：分级存储上下文（短期缓存：对话历史；长期存储：用户偏好），支持动态更新；
上下文筛选模块：根据当前任务相关性，筛选出需传入提示词的上下文（如回答保修问题时，只保留"购买时间"“产品型号”）；
上下文增强模块：通过外部知识（如知识图谱）补充上下文（如根据产品型号从图谱中提取保修政策）。

架构示意图：

用户输入 → 上下文采集（提取实体/意图） → 上下文存储（分级缓存） → 上下文筛选（选相关信息） → 上下文增强（知识图谱补充） → 传入提示词 → AI响应  
       ↑                                                                                                 ↓  
       └────────────────────────────────── 上下文反馈（将新信息存入存储） ───────────────────────────────┘

知识图谱的原理架构

知识图谱是"语义网络的工程化实现"，核心组成包括：

数据层：存储三元组（实体1，关系，实体2）和实体属性（实体，属性名，属性值），如（冰箱A型号，价格，2999元）；
模式层：定义知识的结构（本体），如"产品"类包含"冰箱""洗衣机"子类，"价格"是"产品"的属性；
查询推理层：支持知识查询（如SPARQL）和推理（如通过"A是B的儿子，B是C的儿子"推出"A是C的孙子"）；
接口层：提供API供外部系统（如上下文工程模块）调用查询。

架构示意图：

本体定义（模式层） → 数据录入（实体/关系/属性） → 存储三元组（数据层） → 查询推理（查询推理层） → API接口（接口层） → 上下文工程模块

提示工程的原理架构

提示工程是"提示词的设计、优化与管理系统"，核心要素包括：

角色定义：指定AI的身份（如"客服"“医生”）；
任务描述：明确AI要完成的任务（如"回答问题"“生成报告”）；
上下文占位符：预留位置插入上下文信息（如"用户购买时间：{{purchase_time}}"）；
输出格式约束：规定响应的结构（如JSON、列表）；
优化策略：通过少样本示例、思维链提示等技巧提升效果。

架构示意图：

角色定义 + 任务描述 + 上下文占位符 + 输出格式 → 提示模板 → 填入上下文信息 → 完整提示词 → 输入大模型 → AI响应

知识图谱集成到上下文工程的整体架构

当三者集成时，形成"知识驱动的上下文增强架构"，核心流程如下：

用户输入解析：用户提问后，先提取实体（如"冰箱A型号"）和意图（“查询保修”）；
知识图谱查询：根据实体和意图，从知识图谱中查询相关知识（如A型号的保修期、保修政策）；
上下文融合：将查询到的知识与对话历史上下文（如购买时间）融合，形成"增强上下文"；
提示生成：将增强上下文填入提示模板，生成完整提示词；
AI响应与反馈：大模型生成响应，同时将新信息（如用户接受建议）存入上下文存储，更新知识图谱（如用户购买了配件）。

Mermaid 流程图 (知识图谱集成上下文工程的核心流程)

流程图说明：

从用户输入开始，先提取实体（如"冰箱A型号"）；
有实体则查知识图谱，获取相关知识（如保修期）；
无实体则直接用对话历史作为上下文；
融合知识与历史上下文，形成"增强上下文"；
填入提示模板生成提示词，大模型输出响应；
最后反馈更新上下文存储和知识图谱（如用户新购买的配件信息存入图谱）。

核心算法原理 & 具体操作步骤

算法一：实体提取算法——从用户输入中"挑出关键角色"

问题：用户输入是自然语言（如"我的冰箱A型号坏了"），AI需要先找到"冰箱A型号"这个实体，才能去知识图谱中查信息。实体提取就是"从句子中挑出关键角色"的算法。

原理：基于BERT等预训练模型的命名实体识别（NER），通过标注数据训练模型识别特定领域的实体（如产品名、用户ID）。

操作步骤：

数据准备：标注训练数据（如"冰箱A型号"）；
模型训练：用标注数据微调BERT，让模型学会识别"产品"实体；
实体提取：输入用户句子，模型输出实体及类型（如"冰箱A型号：产品"）；
实体消歧：如果有多个同名实体（如"A型号可能是冰箱或洗衣机"），通过上下文判断（用户说"制冷"→冰箱）。

Python代码示例（用Hugging Face的transformers库实现）：

from transformers import pipeline  

# 加载预训练NER模型（可替换为微调后的领域模型）  
ner_pipeline = pipeline("ner", model="dbmdz/bert-large-cased-finetuned-conll03-english")  

# 用户输入  
user_input = "My refrigerator Model A is not cooling"  

# 提取实体  
entities = ner_pipeline(user_input)  

# 筛选产品实体（假设模型已微调，将"Model A"标记为"PRODUCT"）  
product_entities = [ent for ent in entities if ent["entity"] == "B-PRODUCT" or ent["entity"] == "I-PRODUCT"]  

# 拼接实体名称（如"B-PRODUCT"是开头，"I-PRODUCT"是后续字符）  
if product_entities:  
    product_name = " ".join([ent["word"] for ent in product_entities])  
    print(f"提取到产品实体：{product_name}")  # 输出：提取到产品实体：Model A  
else:  
    print("未提取到产品实体")

算法二：知识图谱查询算法——在"百科全书"中找答案

问题：提取到实体后，需要从知识图谱中查询相关知识（如"冰箱A型号的保修期"），这就需要知识图谱查询算法。

原理：基于SPARQL查询语言，通过三元组模式匹配获取实体的关系和属性。

操作步骤：

构建查询模板：根据意图（如"查询保修"）定义SPARQL模板（如"SELECT ?warranty WHERE {?product :has_warranty ?warranty . ?product :name ‘Model A’}"）；
执行查询：调用知识图谱API（如Neo4j的Python驱动）执行SPARQL；
结果解析：将查询结果转换为自然语言知识片段（如"保修期：2年"）。

Python代码示例（用Neo4j Python驱动查询）：

from neo4j import GraphDatabase  

# 连接Neo4j知识图谱  
class KnowledgeGraphQuery:  
    def __init__(self, uri, user, password):  
        self.driver = GraphDatabase.driver(uri, auth=(user, password))  

    def close(self):  
        self.driver.close()  

    def get_warranty(self, product_name):  
        # SPARQL查询模板（Cypher是Neo4j的查询语言，类似SPARQL）  
        query = """  
        MATCH (p:Product {name: $product_name})-[:HAS_WARRANTY]->(w:Warranty)  
        RETURN w.duration AS duration, w.condition AS condition  
        """  
        with self.driver.session() as session:  
            result = session.run(query, product_name=product_name)  
            record = result.single()  
            if record:  
                return f"保修期：{record['duration']}，条件：{record['condition']}"  
            else:  
                return "未找到该产品的保修信息"  

# 使用示例  
kg = KnowledgeGraphQuery("bolt://localhost:7687", "neo4j", "password")  
product_name = "Model A"  
warranty_info = kg.get_warranty(product_name)  
print(warranty_info)  # 输出：保修期：2年，条件：需提供购买凭证  
kg.close()

算法三：上下文相关性筛选算法——“只带有用的记忆”

问题：上下文信息可能很多（如10轮对话历史），直接全部传入提示词会导致信息过载（超过模型上下文窗口），需要筛选出与当前任务相关的上下文。

原理：计算每条上下文与当前用户意图的余弦相似度，保留相似度高的Top-K条。

操作步骤：

向量化：将上下文文本和用户意图转换为向量（用Sentence-BERT等模型）；
计算相似度：用余弦相似度公式 $Similarity(A,B)=\frac{A \cdot B}{||A|| \cdot ||B||}$ 计算相关性；
筛选Top-K：保留相似度最高的前K条上下文。

Python代码示例（用Sentence-BERT计算相似度）：

from sentence_transformers import SentenceTransformer, util  

# 加载句子向量模型  
model = SentenceTransformer('all-MiniLM-L6-v2')  

# 对话历史上下文（多条）  
contexts = [  
    "用户：我想买一台冰箱",  
    "客服：推荐Model A和Model B，价格分别是2999和3999",  
    "用户：我选Model A",  
    "客服：好的，已下单，订单号12345",  
    "用户：我的洗衣机坏了"  # 无关上下文  
]  

# 当前用户意图（用户输入："我的冰箱A型号能保修吗"）  
user_intent = "查询冰箱Model A的保修信息"  

# 向量化  
context_embeddings = model.encode(contexts, convert_to_tensor=True)  
intent_embedding = model.encode(user_intent, convert_to_tensor=True)  

# 计算相似度  
cos_scores = util.cos_sim(intent_embedding, context_embeddings)[0]  

# 按相似度排序，取Top-3  
top_k = min(3, len(contexts))  
top_results = torch.topk(cos_scores, k=top_k)  

# 输出筛选后的上下文  
print("筛选后的相关上下文：")  
for score, idx in zip(top_results.values, top_results.indices):  
    print(f"相似度：{score.item():.4f}，上下文：{contexts[idx]}")  

# 输出结果（无关的"洗衣机"上下文被筛掉）：  
# 相似度：0.8921，上下文：用户：我选Model A  
# 相似度：0.7832，上下文：客服：推荐Model A和Model B，价格分别是2999和3999  
# 相似度：0.6510，上下文：用户：我想买一台冰箱

算法四：提示生成算法——“把记忆和知识装进说明书”

问题：有了增强上下文（筛选后的历史+知识图谱信息），需要填入提示模板，生成大模型能理解的提示词。

原理：基于模板引擎，将增强上下文动态填充到提示模板的占位符中。

操作步骤：

定义提示模板：包含角色、任务、上下文占位符、输出格式（如"你是客服，根据以下信息回答用户问题：{{enhanced_context}}。输出格式：先说明是否在保，再列需带凭证。"）；
填充占位符：将增强上下文替换占位符；
生成提示词：拼接模板和填充内容，形成完整提示词。

Python代码示例（用字符串格式化实现）：

def generate_prompt(template, enhanced_context):  
    """填充提示模板"""  
    return template.format(enhanced_context=enhanced_context)  

# 定义提示模板  
prompt_template = """  
你是智能客服助手，负责回答用户关于产品保修的问题。  
根据以下增强上下文信息，用自然语言回答用户问题，要求：  
1. 先明确说明是否在保修期内；  
2. 列出需要携带的凭证；  
3. 语言简洁，口语化。  

增强上下文：  
{{enhanced_context}}  
"""  

# 增强上下文（筛选后的历史+知识图谱信息）  
enhanced_context = """  
用户购买产品：Model A冰箱  
购买时间：2023年3月15日  
保修期：2年，条件：需提供购买凭证  
当前时间：2024年5月20日  
"""  

# 生成提示词  
prompt = generate_prompt(prompt_template, enhanced_context)  
print(prompt)

生成的提示词：

你是智能客服助手，负责回答用户关于产品保修的问题。  
根据以下增强上下文信息，用自然语言回答用户问题，要求：  
1. 先明确说明是否在保修期内；  
2. 列出需要携带的凭证；  
3. 语言简洁，口语化。  

增强上下文：  
用户购买产品：Model A冰箱  
购买时间：2023年3月15日  
保修期：2年，条件：需提供购买凭证  
当前时间：2024年5月20日

数学模型和公式 & 详细讲解 & 举例说明

模型一：上下文相关性计算——余弦相似度

问题：如何量化上下文与用户意图的相关性？

数学模型：余弦相似度（Cosine Similarity），衡量两个向量的夹角余弦值，值越接近1，相关性越高。

公式：
对于两个向量 $A=(a_1,a_2,...,a_n)$ 和 $B=(b_1,b_2,...,b_n)$ ，余弦相似度为：
$Similarity(A,B)=\frac{\sum_{i=1}^{n}a_i b_i}{\sqrt{\sum_{i=1}^{n}a_i^2} \cdot \sqrt{\sum_{i=1}^{n}b_i^2}}$

分子：向量点积（ $\cdot B$ ），衡量向量同向程度；
分母：向量模长乘积（ $\cdot ||B||$ ），归一化处理，消除向量长度影响。

举例说明：
假设上下文句子和用户意图的向量如下（简化为二维向量）：

上下文A：“用户买了Model A冰箱” → 向量 $A = (0.8, 0.2)$ （第一个维度是"冰箱"相关度，第二个是"洗衣机"相关度）；
上下文B：“用户的洗衣机坏了” → 向量 $B = (0.2, 0.8)$ ；
用户意图：“查询Model A冰箱保修” → 向量 $I = (0.9, 0.1)$ 。

计算相似度：

$Similarity(A,I)=\frac{(0.8×0.9)+(0.2×0.1)}{\sqrt{0.8^2+0.2^2}×\sqrt{0.9^2+0.1^2}}=\frac{0.72+0.02}{\sqrt{0.68}×\sqrt{0.82}}≈\frac{0.74}{0.82×0.91}≈0.99$ （高度相关）；
$Similarity(B,I)=\frac{(0.2×0.9)+(0.8×0.1)}{\sqrt{0.2^2+0.8^2}×\sqrt{0.9^2+0.1^2}}=\frac{0.18+0.08}{\sqrt{0.68}×\sqrt{0.82}}≈\frac{0.26}{0.82×0.91}≈0.35$ （低相关）。

所以筛选时保留上下文A，丢弃上下文B，避免信息过载。

模型二：知识图谱路径推理——最短路径算法

问题：知识图谱中，实体间的关系可能需要多步推理（如"用户→购买→订单→包含→产品→属于→产品系列"），如何找到两个实体间的最短关系路径？

数学模型：广度优先搜索（BFS）算法，用于寻找图中两点间的最短路径。

原理：从起点实体开始，逐层遍历邻居节点，直到找到终点实体，记录路径长度，最短路径即首次到达终点的路径。

公式：路径长度=边的数量（如A→B→C的路径长度为2）。

举例说明：
知识图谱中有以下关系：

小明→购买→订单123
订单123→包含→冰箱A型号
冰箱A型号→属于→冰箱系列
冰箱系列→品牌→小A公司

用户问"小明买的产品的品牌是什么"，需要找到"小明"到"品牌"的最短路径：

BFS搜索步骤：

起点：小明 → 邻居：订单123（路径：小明-购买-订单123，长度1）；
订单123 → 邻居：冰箱A型号（路径：小明-购买-订单123-包含-冰箱A型号，长度2）；
冰箱A型号 → 邻居：冰箱系列（路径：长度3）；
冰箱系列 → 邻居：小A公司（路径：小明-购买-订单123-包含-冰箱A型号-属于-冰箱系列-品牌-小A公司，长度4）。

最短路径长度为4，从而推出品牌是小A公司。

项目实战：代码实际案例和详细解释说明

开发环境搭建

目标：搭建"知识图谱驱动的上下文增强"系统，实现智能客服对保修问题的回答。

环境要求：

Python 3.8+
知识图谱数据库：Neo4j Desktop（社区版免费）
Python库：neo4j（Neo4j驱动）、sentence-transformers（相似度计算）、transformers（实体提取）、python-dotenv（环境变量管理）

安装步骤：

安装Neo4j：从Neo4j官网下载Desktop版，创建数据库（默认密码设为"password"，端口7687）；
安装Python库：

pip install neo4j sentence-transformers transformers python-dotenv

源代码详细实现和代码解读

步骤1：构建产品知识图谱（Neo4j）

首先在Neo4j中创建产品知识图谱，包含实体（产品、保修政策、用户）、关系和属性。

Neo4j Cypher脚本（在Neo4j浏览器中执行，地址http://localhost:7474）：

// 创建产品实体  
CREATE (p1:Product {name: "冰箱A型号", price: 2999, category: "冰箱"})  
CREATE (p2:Product {name: "冰箱B型号", price: 3999, category: "冰箱"})  

// 创建保修政策实体  
CREATE (w1:Warranty {name: "冰箱保修政策", duration: "2年", condition: "需提供购买凭证"})  

// 创建关系：产品适用保修政策  
CREATE (p1)-[:HAS_WARRANTY]->(w1)  
CREATE (p2)-[:HAS_WARRANTY]->(w1)  

// 创建用户实体  
CREATE (u1:User {name: "小明", user_id: "user_001"})  

// 创建订单实体  
CREATE (o1:Order {order_id: "12345", purchase_time: "2023-03-15"})  

// 创建关系：用户购买订单，订单包含产品  
CREATE (u1)-[:PURCHASED]->(o1)  
CREATE (o1)-[:CONTAINS]->(p1)

图谱结构：用户→购买→订单→包含→产品→适用→保修政策。

步骤2：实现实体提取模块

从用户输入中提取产品名称、用户ID等实体。

# entity_extractor.py  
from transformers import pipeline  
import os  
from dotenv import load_dotenv  

load_dotenv()  # 加载环境变量  

class EntityExtractor:  
    def __init__(self):  
        # 加载NER模型（这里用预训练模型，实际应用需微调领域数据）  
        self.ner_model = pipeline(  
            "ner",  
            model=os.getenv("NER_MODEL", "dbmdz/bert-large-cased-finetuned-conll03-english"),  
            aggregation_strategy="simple"  
        )  

    def extract_product(self, user_input):  
        """提取用户输入中的产品实体"""  
        entities = self.ner_model(user_input)  
        # 筛选产品实体（假设模型将产品标记为"PRODUCT"类型）  
        product_entities = [ent for ent in entities if ent["entity_group"] == "PRODUCT"]  
        if product_entities:  
            return product_entities[0]["word"]  # 返回第一个产品实体  
        else:  
            return None  

# 测试  
extractor = EntityExtractor()  
user_input = "我的冰箱A型号坏了，能保修吗？"  
product_name = extractor.extract_product(user_input)  
print(f"提取到产品实体：{product_name}")  # 输出：提取到产品实体：冰箱A型号

步骤3：实现知识图谱查询模块

根据产品实体查询保修政策、用户购买时间等信息。

# kg_query.py  
from neo4j import GraphDatabase  
import os  
from dotenv import load_dotenv  

load_dotenv()  

class KnowledgeGraphQuery:  
    def __init__(self):  
        self.uri = os.getenv("NEO4J_URI", "bolt://localhost:7687")  
        self.user = os.getenv("NEO4J_USER", "neo4j")  
        self.password = os.getenv("NEO4J_PASSWORD", "password")  
        self.driver = GraphDatabase.driver(self.uri, auth=(self.user, self.password))  

    def close(self):  
        self.driver.close()  

    def get_warranty_info(self, product_name):  
        """查询产品保修信息"""  
        query = """  
        MATCH (p:Product {name: $product_name})-[:HAS_WARRANTY]->(w:Warranty)  
        RETURN w.duration AS duration, w.condition AS condition  
        """  
        with self.driver.session() as session:  
            result = session.run(query, product_name=product_name)  
            record = result.single()  
            if record:  
                return f"保修期：{record['duration']}，条件：{record['condition']}"  
            else:  
                return "未找到保修信息"  

    def get_purchase_time(self, user_id, product_name):  
        """查询用户购买产品的时间"""  
        query = """  
        MATCH (u:User {user_id: $user_id})-[:PURCHASED]->(o:Order)-[:CONTAINS]->(p:Product {name: $product_name})  
        RETURN o.purchase_time AS purchase_time  
        """  
        with self.driver.session() as session:  
            result = session.run(query, user_id=user_id, product_name=product_name)  
            record = result.single()  
            return record["purchase_time"] if record else None  

# 测试  
kg = KnowledgeGraphQuery()  
product_name = "冰箱A型号"  
warranty_info = kg.get_warranty_info(product_name)  
purchase_time = kg.get_purchase_time("user_001", product_name)  
print(f"保修信息：{warranty_info}")  # 输出：保修信息：保修期：2年，条件：需提供购买凭证  
print(f"购买时间：{purchase_time}")  # 输出：购买时间：2023-03-15  
kg.close()

步骤4：实现上下文筛选和增强模块

筛选相关历史上下文，结合知识图谱信息生成增强上下文。

# context_enhancer.py  
from sentence_transformers import SentenceTransformer, util  
import torch  

class ContextEnhancer:  
    def __init__(self):  
        self.model = SentenceTransformer('all-MiniLM-L6-v2')  # 句子向量模型  

    def filter_relevant_context(self, contexts, user_intent, top_k=3):  
        """筛选与用户意图相关的上下文"""  
        if not contexts:  
            return []  
        # 向量化  
        context_embeddings = self.model.encode(contexts, convert_to_tensor=True)  
        intent_embedding = self.model.encode(user_intent, convert_to_tensor=True)  
        # 计算相似度  
        cos_scores = util.cos_sim(intent_embedding, context_embeddings)[0]  
        # 取Top-K  
        top_results = torch.topk(cos_scores, k=min(top_k, len(contexts)))  
        # 返回筛选后的上下文  
        return [contexts[idx] for idx in top_results.indices]  

    def enhance_context(self, filtered_contexts, kg_info):  
        """融合筛选后的上下文和知识图谱信息，生成增强上下文"""  
        enhanced = "历史对话：\n" + "\n".join(filtered_contexts) + "\n\n知识信息：\n" + kg_info  
        return enhanced  

# 测试  
enhancer = ContextEnhancer()  
contexts = [  
    "用户：我想买冰箱",  
    "客服：推荐冰箱A型号（2999元）和B型号（3999元）",