大模型系统开发能力体系

本文系统梳理了大模型开发的核心知识体系，分为底层认知层和模型演进层。底层认知层涵盖机器学习基础概念（张量、梯度、链式法则、概率分布）和LLM关键参数（Token、上下文窗口、温度等控制参数）。模型演进层分析主流架构发展：CNN通过局部感受野处理图像，RNN/LSTM用于序列建模但存在并行性差等问题，Transformer凭借自注意力机制实现全局依赖建模成为当前主流。全文提供了参数组合策略等技术细节

fids

1087人浏览 · 2026-01-12 11:26:50

fids · 2026-01-12 11:26:50 发布

大模型系统开发能力体系

一、底层认知层：数理、编程与AI演进逻辑
二、RAG（检索增强生成）
三、Agent与智能体层
四、系统集成与工程化层

一、底层认知层：数理、编程与AI演进逻辑

机器学习基础知识

张量

张量是深度学习中对多维数据的统一抽象，是模型处理信息的“基本语言”。

本质：张量是高维数组，可表示标量（0维）、向量（1维）、矩阵（2维）及更高维数据结构。
常见形式：
- 图像：(batch_size, channels, height, width)，如 (32, 3, 224, 224) 表示 32 张 RGB 图像，每张 224×224。
- 文本序列：(batch_size, sequence_length, embedding_dim)，如 (64, 512, 768) 表示 64 个句子，每个句子 512 个 token，每个 token 映射为 768 维向量。
作用：所有模型的输入、参数、中间结果与输出均以张量形式存在，是计算图的基础载体。
关键特性：支持并行计算、GPU 加速，是现代深度学习框架（如 PyTorch、TensorFlow）的核心数据结构。

梯度

梯度是模型优化的核心信号，指示参数更新的方向与强度。

定义：设损失函数为 $ L(\theta) $，梯度 $ \nabla_\theta L $ 是损失对模型参数 $ \theta $ 的偏导数向量。
物理意义：梯度方向为损失上升最快的方向，负梯度方向为下降最快方向，即“最优调整路径”。
更新公式：
$\theta_{\text{new}} = \theta_{\text{old}} - \eta \cdot \nabla_\theta L$
其中 $ \eta $ 为学习率，控制步长。
常见问题：
- 梯度消失：深层网络中梯度趋近于零，导致参数无法更新。
- 梯度爆炸：梯度过大引发数值溢出，训练发散。
解决方法：使用残差连接、BatchNorm、梯度裁剪、自适应优化器（如 Adam）等。

链式法则

链式法则是反向传播（Backpropagation）的数学基础，实现误差的逐层回传。

核心思想：若 $ y = f(g(x)) $，则
$\frac{dy}{dx} = \frac{df}{dg} \cdot \frac{dg}{dx}$
在神经网络中，每一层输出是前一层的函数，整体损失是最终输出的函数，因此可通过链式法则逐层计算梯度。
实现机制：
- 前向传播：计算输出并记录中间结果。
- 反向传播：从损失出发，沿计算图逆向传播，利用链式法则求出各参数梯度。
应用：适用于所有可微分操作，包括卷积、注意力、全连接层等。
关键价值：使大规模深度网络的参数训练成为可能，是现代深度学习的基石。

概率分布

模型输出并非确定值，而是对各类别或结果的置信度分布。

典型形式：Softmax 输出一个归一化向量，如 $ [0.85, 0.12, 0.03] $，表示“类别 A 有 85% 可能”。
数学基础：输出层通常先生成 logits（未归一化得分），再经 Softmax 转换为概率分布：
$p_i = \frac{e^{z_i}}{\sum_j e^{z_j}}$
意义：
- 表达不确定性，避免盲目自信。
- 支持采样生成（如文本生成中选择概率最高的词）。
- 用于评估模型置信度（如 Calibration 分析）。
应用场景：分类、生成式模型（如 GPT）、异常检测、强化学习策略输出等。

大型语言模型核心参数详解

一、基础处理参数

Token（标记）

定义：模型处理文本的最小语义单元
作用：
- 决定输入/输出的长度限制（上下文窗口）
- 作为计费单位（输入+输出token总数）
- 影响处理效率（罕见token降低性能）
典型值：
- 英文：1 token ≈ 0.75单词
- 中文：1 token ≈ 1-2汉字
- 最大上下文窗口：2K-128K tokens（因模型而异）

Context Window（上下文窗口）

定义：模型单次处理的最大token数量
包含：输入提示 + 生成输出的总长度
典型值：
- GPT-3.5：4,096 tokens
- GPT-4 Turbo：128,000 tokens
- Claude 3：200,000 tokens

二、生成控制参数

Temperature（温度）

定义：控制输出随机性的参数（0.0-2.0）
作用机制：
- 低温度(0.0-0.5)：确定性高，选择最高概率token
- 中温度(0.5-1.0)：平衡创造性与连贯性
- 高温度(>1.0)：高度随机，创造性更强但可能不连贯
应用场景：
- 事实回答：0.1-0.3
- 创意写作：0.7-1.0
- 头脑风暴：>1.0

Top-p（核采样）

定义：从累积概率达p的最小token集合中采样（0.0-1.0）
与温度的区别：
- 动态选择候选集（而非固定top-k）
- 通常与温度配合使用
推荐值：
- 严格限制：0.5-0.8
- 平衡模式：0.9
- 几乎不限制：0.95-1.0

Top-k

定义：仅从概率最高的k个token中采样
作用：
- 限制低概率token的出现
- k=1时等同于贪婪搜索
典型值：
- 保守输出：k=10
- 常规使用：k=50
- 创意生成：k>100

三、长度控制参数

Max Length（最大长度）

定义：生成输出的最大token数
注意事项：
- 需预留输入token空间（总长≤上下文窗口）
- 设置过低会导致回答被截断

Min Length（最小长度）

定义：生成输出的最小token数
用途：
- 避免过早结束（在生成[EOS]前强制继续）
- 确保回答的完整性

Length Penalty（长度惩罚）

定义：调节生成长度的参数（通常-2.0到2.0）
作用：
- 1.0：鼓励更长输出
- <1.0：惩罚长输出
- =1.0：无影响

四、高级控制参数

Frequency Penalty（频率惩罚）

范围：-2.0到2.0
作用：
- 0：降低重复token的概率
- <0：增加重复可能性
- 典型值：0.1-1.0（防止重复）

Presence Penalty（存在惩罚）

范围：-2.0到2.0
作用：
- 0：惩罚已出现的token（促进多样性）
- <0：鼓励重复已出现的token
- 与频率惩罚的区别：不考虑出现次数，只考虑是否出现过

Stop Sequences（停止序列）

定义：遇到指定字符串时停止生成
用途：
- 控制输出格式（如强制换行）
- 避免多余内容（如后续问题）
示例：
- "\n"：单轮回答
- "###"：标记结束

五、参数组合策略

任务类型	推荐参数组合
事实性问答	temp=0.2, top_p=0.5, fp=0.5
创意写作	temp=0.8, top_p=0.9, fp=0.1
代码生成	temp=0.3, top_p=0.7, fp=0.3
头脑风暴	temp=1.2, top_p=0.95, fp=0.0
多轮对话	temp=0.5, top_p=0.8, pp=0.5

主流模型演进

1. CNN（卷积神经网络）

– 图像特征提取的奠基者

核心思想：局部感受野 + 权重共享 + 下采样
- 通过小卷积核在图像上滑动，提取局部纹理、边缘等低级特征。
- 权重共享大幅减少参数量，提升泛化能力。
- 池化层（如最大池化）实现空间降维，增强不变性（平移、旋转）。
典型结构：
- LeNet-5（1998）：首个成功应用的CNN，用于手写数字识别。
- AlexNet（2012）：引入ReLU、Dropout、数据增强，引爆深度学习革命。
- ResNet（2015）：提出残差连接（Residual Connection），解决深层网络梯度消失问题，可训练数百层。
优势：
- 对图像具有高度空间归纳偏置（inductive bias），天然适合像素级建模。
- 支持并行计算，GPU加速高效。
局限：
- 依赖局部感受野，难以建模长距离依赖（如图像中相隔较远的物体关系）。
- 无法处理非网格结构数据（如文本、图）。

✅ 定位：CNN 是计算机视觉的基石，至今仍是图像分类、目标检测、语义分割等任务的核心组件。

2. RNN / LSTM

–时序建模的早期探索者

核心思想：递归结构，引入“记忆”机制
- RNN 通过隐藏状态 $ h_t = f(W_h h_{t-1} + W_x x_t) $ 实现序列建模，历史信息通过状态传递。
- LSTM（Long Short-Term Memory）引入门控机制（输入门、遗忘门、输出门），缓解梯度消失问题。
优势：
- 理论上可处理任意长度序列。
- 在语音识别、机器翻译、文本生成等任务中取得早期成功。
局限：
- 顺序计算：每一步必须等待前一步完成，无法并行，训练慢。
- 长程依赖衰减：尽管 LSTM 改进，但对超长序列（>1000步）仍难有效捕捉远距离依赖。
- 梯度消失/爆炸问题在深层网络中依然存在。

⚠️ 现状：RNN/LSTM 已被 Transformer 取代为主流时序建模方案，但在某些轻量级、低延迟场景仍有应用。

3. Transformer

–自注意力机制的革命性突破

核心思想：自注意力机制（Self-Attention） 取代递归结构，实现全局依赖建模
- 每个位置的输出由序列中所有位置的输入加权融合而成，权重由查询（Query）、键（Key）、值（Value）计算：
  $\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$
- 多头注意力（Multi-Head Attention）并行捕捉多种语义关系。
关键创新：
- 并行化：所有位置可同时计算，极大提升训练效率。
- 长距离依赖建模：任意两个 token 之间可直接建立联系，不受距离限制。
- 位置编码：通过正弦/余弦函数或可学习向量注入位置信息，弥补序列顺序缺失。
典型架构：
- Encoder-Decoder 架构：原用于机器翻译（如 Google 的 Transformer）。
- Decoder-only：如 GPT 系列，自回归生成文本。
- Encoder-only：如 BERT，双向上下文理解。
优势：
- 训练速度快，适合大规模数据预训练。
- 在 NLP、CV、语音等多个领域取得突破性性能。

✅ 定位：Transformer 是当前大模型时代的“通用架构”，几乎所有主流模型（GPT、BERT、T5、Stable Diffusion）均基于其变体。

4. Mamba

状态空间模型（SSM）的崛起

核心思想：用状态空间模型（State Space Model, SSM）替代 RNN 的递归结构，实现长序列高效建模
- SSM 定义为：
  $h_t = A h_{t-1} + B x_t \\ y_t = C h_t + D x_t$
  其中 $ h_t $ 是隐藏状态，$ A, B, C, D $ 是可学习参数。
- 通过选择特定形式（如 S4 模型），SSM 可近似为无限长序列的“记忆系统”。
关键优势：
- 线性复杂度：计算复杂度为 $ O(n) $，远优于 Transformer 的 $ O(n^2) $，适合处理超长序列（如百万 token 的文档、长视频）。
- 并行化潜力：可通过 SSM 的矩阵分解实现部分并行，兼具效率与可扩展性。
- 长程依赖建模：状态 $ h_t $ 持续积累历史信息，不受距离限制。

与 Transformer 对比：

特性	Transformer	Mamba
序列建模	全局依赖	长程记忆
计算复杂度	$ O(n^2) $	$ O(n) $
并行性	高	中等
适合长度	< 2048	> 10k，甚至百万

应用场景：
- 超长文本理解（如法律文书、科研论文）
- 长视频分析、语音处理
- 金融时间序列建模

✅ 定位：Mamba 是 Transformer 的有力补充，尤其在长序列、低延迟、高性价比场景中展现巨大潜力，被视为下一代序列建模的“候选者”。

5. GPT

–自回归生成的代表，文本生成的王者

核心思想：Decoder-only 架构 + 自回归生成
- 模型在生成下一个 token 时，仅依赖前面所有已生成的 token（因果掩码）。
- 通过大规模预训练 + 微调，学习语言的统计规律。
演进路径：
- GPT-1（2018）：首次展示大规模无监督预训练能力。
- GPT-2（2019）：模型规模扩大，展现零样本泛化能力。
- GPT-3（2020）：1750亿参数，实现“提示工程”（Prompt Engineering），无需微调即可完成新任务。
- GPT-4（2023）：多模态、更强推理、更稳定输出，成为通用人工智能的重要探索。
优势：
- 生成连贯、自然、多样化的文本。
- 支持零样本、少样本学习，灵活性高。
- 适合对话、创作、编程、摘要等生成任务。
局限：
- 生成内容可能“一本正经地胡说八道”（幻觉问题）。
- 缺乏对世界的真实理解，依赖统计模式。

✅ 定位：GPT 是生成式 AI 的标杆，推动了 AIGC（人工智能生成内容）的爆发。

6. BERT

双向编码的里程碑，理解语言的深度革命

核心思想：双向 Transformer Encoder + 预训练任务
- 在输入中随机掩码部分 token（如 [MASK]），让模型预测被掩码的词（MLM 任务）。
- 同时学习句子关系（NSP 任务，后被弃用）。
关键突破：
- 双向上下文理解：相比 GPT 的单向建模，BERT 可同时利用前后文信息，显著提升理解能力。
- 通用表示：预训练模型可微调用于分类、命名实体识别、问答等下游任务。
影响：
- 开启“预训练 + 微调”范式，成为 NLP 领域的主流范式。
- 推动 BERT 系列模型（RoBERTa、DeBERTa、ELECTRA）持续优化。
应用场景：
- 情感分析、文本分类、信息抽取、搜索排序、问答系统。

✅ 定位：BERT 是理解型模型的代表，奠定了现代 NLP 的基础架构。

7. T5

–文本到文本统一框架，迈向通用 AI 的关键一步

核心思想：将所有 NLP 任务统一为“文本生成”任务
- 输入输出均为文本，任务通过提示词（Prompt）定义。
  - 分类："Classify this review as positive or negative: [text]"
  - 翻译："Translate English to French: [text]"
  - 摘要："Summarize: [text]"
优势：
- 统一框架，简化模型设计与训练流程。
- 支持多任务联合训练，提升泛化能力。
- 与 GPT 思路兼容，可灵活适配不同任务。
演进：
- T5-11B：首个大规模统一模型，展现强大零样本能力。
- Flan-T5：在 1000+ 任务上微调，显著提升性能。
意义：
- 体现“任务统一化”趋势，是迈向通用人工智能（AGI）的重要尝试。
- 为指令微调（Instruction Tuning）和提示工程提供基础。

✅ 定位：T5 是“通用 NLP 模型”的雏形，推动模型从“专用工具”走向“通用助手”。

二、RAG（检索增强生成）

RAG完整流程图（企业级落地标准流程）：

原始文档 → 文本清洗 → 分块策略 → Embedding生成 → 向量存储 → Query处理 → 多路召回 → 重排序 → RAG生成 → 输出

1. 文本处理

技术	说明	工具
PDF/Word解析	提取文本、表格、图像	`PyPDF2`、`pdfplumber`、`Unstructured`
文本清洗	去除空行、乱码、特殊符号	`re`、`string`、`BeautifulSoup`
句子拆分	按句号、分号、换行切分	`nltk.sent_tokenize`
固定分块	按固定长度切分	截取
语义分块	基于语义相似性切分	`LangChain SemanticChunker`、`LlamaIndex`
递归分块	递归式拆分，先粗后细	`RecursiveCharacterTextSplitter`
专用分块	结合标题、段落、表格结构	`Unstructured`、`LayoutParser`

1. 文档解析

技术	说明	推荐工具	适用场景
PDF 解析	提取文本、表格、图像坐标	`PyPDF2`（基础）、`pdfplumber`（精确）、`Unstructured`（智能）	普通文档、合同、报告
Word / PPT 解析	保留段落、标题、样式	`python-docx`、`pptx`、`Unstructured`	企业内部文档、汇报材料
HTML 解析	保留语义标签（如 `<h1>`, `<p>`）	`BeautifulSoup`、`lxml`	网页内容、知识库爬虫
图像 OCR	识别扫描件、图表中的文字	`Tesseract OCR`、`PaddleOCR`、`Google Vision API`	扫描文档、发票、票据

✅ 关键建议：

优先使用 Unstructured，其支持多种格式 + 自动识别布局（如标题、段落、表格）。

对于含复杂表格的文档，使用 pdfplumber + tabula-py 提取结构化表格数据。

保留原始文档的元信息（如文件名、创建时间、作者）用于溯源。

2. 文本清洗

清洗项	说明	实现方式
去除空行/空白字符	防止分块时出现无效片段	`re.sub(r'\n\s*\n', '\n\n', text)`
去除乱码/不可见字符	如 `U+200B`（零宽空格）	`re.sub(r'[\u200B-\u200D\uFEFF]', '', text)`
标准化标点符号	统一中英文符号	`str.translate(str.maketrans('，。！？；：', ',.!?;:'))`
去除广告/页眉页脚	提取正文区域	基于段落长度、关键词（如“版权”“联系方式”）过滤
修复编码问题	防止乱码	`chardet` 检测编码，`encode('utf-8')` 转换

⚠️ 常见陷阱：

忽略“零宽字符”导致嵌入失败或语义错乱。

过度清洗导致语义断裂（如删除“附录”等关键词影响上下文）。

✅ 推荐方案：使用 langchain.text_splitter 中的 clean_text 工具，内置多种清洗规则。

3. 句子拆分

方法	说明	适用场景
`nltk.sent_tokenize`	基于规则，支持多语言	通用文本
`transformers` 的 `SentencePieceTokenizer`	适用于预训练模型分词	模型输入前处理
`spacy` 的 `sentencizer`	基于依存句法，更准确	长段落、复杂句式

✅ 最佳实践：

优先使用 spacy 或 nltk，避免因句号误判导致语义断裂。

对于中文，使用 jieba + pypinyin 辅助判断句子边界。

4. 分块策略

策略	说明	优缺点	推荐场景
固定长度分块	按字符/token 数切分	✅ 简单高效 ❌ 易切在句子/段落中间	通用、快速原型
语义分块	基于嵌入向量相似性聚类	✅ 保留语义完整 ❌ 计算开销大	高精度场景（如法律、医疗）
递归分块	先按段落切，再按句子切，最后按长度切	✅ 自适应性强 ✅ 避免跨句切分	大型文档（如政策文件）
专用分块	识别标题、表格、代码块等结构	✅ 保留结构语义 ✅ 适合技术文档	技术手册、API 文档
滑动窗口分块	重叠分块，防止关键信息丢失	✅ 提升召回率 ❌ 增加冗余	重要文档（如合同）

✅ 企业级推荐方案：

主流程：RecursiveCharacterTextSplitter + overlap=100（重叠 100 字符）

增强策略：对长文档使用 SemanticChunker（基于 sentence-transformers）进行语义边界检测

结构感知：结合 Unstructured 提取标题/章节，按章节分块

📌 关键指标：

分块大小建议：256~512 token（适合主流嵌入模型）

重叠比例：10%~20%（避免关键信息被切断）

2. 标注（Annotation）

核心目标：为原始文档添加结构化信息，提升检索与生成质量。

标注类型（按用途）

类型	说明	典型示例	适用场景
实体标注	识别并标注文本中具有特定意义的实体	人名：张伟；公司名：阿里巴巴；日期：2025年3月15日；金额：50万元；条款编号：第5.2条	合同审查、财务分析、合规审计
关系标注	标注实体之间的语义关系	甲方-乙方（合同双方）；签约-生效（时间关系）；违约-赔偿（因果关系）；融资-投资方	知识图谱构建、风险识别、流程引擎
意图标注	标注用户提问的真实意图	“查询付款时间”“修改合同条款”“确认违约责任”“申请审批”	智能客服、任务型对话系统
分类标注	标注文档的整体类型	采购合同、劳动合同、财务报告、项目立项书	文档归档、权限控制、工作流触发
语义标签	添加描述性标签，表达状态或属性	“高风险”“需审批”“已签署”“待复核”“已归档”	流程自动化、审批提醒、版本管理

标注方式

1. 人工标注

适用场景：首次构建知识库、高风险领域（如法律、医疗、金融）。
最佳实践：
- 制定标注规范手册（如“如何判断‘付款时间’”）。
- 采用双人交叉标注 + 仲裁机制，保证一致性。
- 使用 Label Studio 或 Prodigy，支持多轮标注、版本管理、质量评估。

✅ 案例：某律所对 100 份合同进行人工标注，标注“违约条款”“赔偿金额”“生效条件”等实体与关系，构建了法律知识图谱，使合同审查效率提升 60%。

2. 半自动标注

实现路径：

from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

prompt = PromptTemplate(
    template="请从以下文本中提取实体：人名、公司名、金额、日期。输出格式：JSON\n\n文本：{text}"
)

chain = LLMChain(llm=llm, prompt=prompt)
results = chain.run(text=chunk)

关键优化：
- 使用 few-shot prompt 提供示例，提升准确性。
- 增加 验证步骤：如“请检查生成结果是否符合以下规则：金额必须为数字，日期格式为YYYY-MM-DD”。
- 使用 自动纠错机制：基于规则或小模型过滤明显错误。

✅ 推荐工具组合：

LangChain + GPT-4 / Qwen / DeepSeek：生成初标。

spaCy NER 模型：做后处理校验。

Label Studio：人工审核与修正。

3. 自动标注

实现方式：

基于规则：使用正则表达式匹配日期、金额等。

import re
dates = re.findall(r'\d{4}年\d{1,2}月\d{1,2}日', text)

基于预训练模型：使用 Hugging Face 上的 NER 模型（如 bert-base-chinese）。

from transformers import pipeline
ner_pipeline = pipeline("ner", model="bert-base-chinese")
entities = ner_pipeline(text)

优势：可处理百万级文档，适合日志、报表等结构化程度高的数据。
局限：难以处理模糊表达（如“上个月”“大约五万”）。

✅ 建议：用于批量预处理，再由半自动或人工进行精细化校验。

4. 自我标注

核心思想：模型在生成回答时，主动识别并标注关键信息，存入向量库，形成闭环。
实现路径：
1. 用户提问：“请分析这份合同的违约责任。”
2. RAG 系统检索相关段落。
3. LLM 在生成答案时，同时输出：
  - “违约方：乙方”
  - “赔偿金额：合同总金额的 20%”
  - “生效条件：双方签字盖章”
4. 这些信息被自动提取并作为新实体与关系存入知识库。
5. 下次提问“乙方违约需赔偿多少？”可直接命中。

✅ 关键技术：

使用 Self-Query Retriever：让模型学会“如何提问自己”。

结合 VectorStore + Metadata：将标注信息作为元数据存储。

引入 审核机制：防止错误标注污染知识库。

3. Embedding模型选择

模型名称	分类	架构	向量维度	主要优势
M3E (Zhipu AI)	文本	BERT + 多任务学习	768	中文语义理解能力极强，支持指令微调，轻量高效
BGE-M3 (THUDM)	文本	BERT + 对抗训练	768	多语言支持广，RAG 任务表现优异，通用性强
e5-v2 (Microsoft)	文本	mT5 + 多任务学习	768	支持任务提示（如 `Retrieve:`），语义可控，泛化能力强
Instructor-XL (BAAI)	文本	BERT + 指令微调	768	跨任务泛化能力突出，适合多目标系统
SBERT (Hugging Face)	文本	BERT + Siamese 架构	768	生态成熟，微调流程完善，适合快速上线
CodeLlama (Meta)	代码	Llama + 代码微调	4096	生成能力强，支持中文，适合 IDE 插件与自动化开发
StarCoder2 (BigCode)	代码	自研大模型	768	支持 80+ 编程语言，开源生态最活跃，部署灵活
DeepSeek-Coder (DeepSeek)	代码	自研大模型	4096	中文代码理解能力突出，国产化首选
CodeBERT (Microsoft)	代码	BERT + AST 结构	768	代码结构感知强，适合静态分析与漏洞检测
GraphCodeBERT (Microsoft)	代码	BERT + 抽象语法树	768	利用 AST 提升代码语义理解，适合复杂逻辑分析
Whisper (OpenAI)	音视频	Transformer	1280	支持 99 种语言，语音识别准确率高，API 易接入
ECAPA-TDNN	音视频	CNN + 支持向量机	192	说话人识别标杆模型，稳定可靠，广泛用于安防
Wav2Vec 2.0 (Facebook)	音视频	CNN + Transformer	768	自监督学习典范，无需标注数据，适合低资源场景
HuBERT (Facebook)	音视频	Transformer	768	语义表示能力强，适合长音频分析与语音情感识别
VideoMAE (Meta)	音视频	ViT + 掩码重建	768	视频自监督学习，结构理解能力强，用于视频检索
CLIP (OpenAI)	多模态	ViT + Transformer	512 / 768	首个实现图文对齐的模型，跨模态检索基石
BLIP-2 (Salesforce)	多模态	ViT + LLM + 适配器	768	冻结视觉编码器，训练成本低，部署友好
LLaVA (UC Berkeley)	多模态	LLaMA + ViT	4096	支持多轮视觉对话，具备推理能力，AI Agent 基础
Qwen-VL (Alibaba)	多模态	Qwen 架构	1024	中文多模态理解强，适合国内业务场景
KOSMOS-2 (Microsoft)	多模态	多模态大模型	1024	支持文本、图像、音频、代码统一建模，迈向通用智能

4. 向量存储与召回

技术	说明	工具
向量数据库	存储Embedding，支持近似最近邻（ANN）查询	`ChromaDB`（轻量）、`FAISS`（高性能）、`Milvus`（分布式）
字面召回（BM25）	基于关键词匹配，使用`Elasticsearch`或`Whoosh`	`Elasticsearch`、`BM25`算法
多路召回	同时使用BM25 + 向量 + 图结构 + 自我生成等多源召回	`MultiVectorRetriever`、`LangChain`
Query改写与扩展	LLM对用户问题进行语义扩展（如“违约金” → “违约赔偿条款”）	`LangChain`、`RAGChain`
递归RAG	多轮检索+生成+反馈循环，实现动态知识更新	`LangGraph` + `Retrieval + Generation`循环

一. 向量数据库深度对比

模型	优势	劣势	推荐指数
ChromaDB	✅ 轻量、易部署、API 简洁 ✅ 适合原型验证与小规模系统	❌ 不支持分布式 ❌ 无持久化备份	⭐⭐⭐⭐☆
FAISS	✅ 极致性能，支持 GPU 加速 ✅ 支持多种索引（HNSW、IVF、SQ）	❌ 无持久化、无查询接口 ❌ 需自行封装	⭐⭐⭐⭐⭐
Milvus	✅ 分布式、高可用、支持动态更新 ✅ 支持过滤器、分片、副本	❌ 部署复杂，学习成本高	⭐⭐⭐⭐⭐
Pinecone	✅ 云服务，开箱即用 ✅ 支持自动缩放、监控	❌ 成本高（尤其大规模）	⭐⭐⭐⭐☆
Qdrant	✅ 性能优异，支持过滤、重排序 ✅ 支持 REST API + gRPC	❌ 社区较小	⭐⭐⭐⭐☆

✅ 企业级推荐方案：

中小型企业：Qdrant 或 Milvus（本地部署）

初创/原型：ChromaDB + LangChain 快速验证

高性能场景：FAISS + 自研服务（如 Python + FastAPI）

云上部署：Pinecone 或 Weaviate（若预算充足）

📌 关键配置建议：

使用 HNSW 索引（Hierarchical Navigable Small World），提升召回速度。

设置 ef_search=100、ef_construction=200，平衡精度与延迟。

启用 过滤器（Filter），支持按文档类型、时间、标签筛选。

二、召回策略

核心结论：
单一召回方式（如仅向量）极易漏检或误检。
“多路召回”是提升 RAG 召回率与鲁棒性的唯一正确路径。

召回方式	说明	优势	局限	实现工具
向量召回	基于语义相似度匹配	✅ 能理解“意思相近” ✅ 支持模糊查询	❌ 无法处理关键词精准匹配	`ChromaDB`、`Milvus`
字面召回（BM25）	基于 TF-IDF 或 BM25 算法	✅ 精准匹配关键词 ✅ 对拼写错误容忍度高	❌ 无法理解语义	`Elasticsearch`、`Whoosh`
图结构召回	基于知识图谱路径搜索	✅ 支持关系推理 ✅ 可处理复杂逻辑	❌ 需构建图谱，成本高	`Neo4j`、`JanusGraph`
自我生成召回	LLM 生成“检索式问题”再召回	✅ 提升语义覆盖 ✅ 可处理隐含意图	❌ 存在幻觉风险	`LangChain` + LLM
多模型召回	使用不同 Embedding 模型并行召回	✅ 提升鲁棒性 ✅ 避免模型偏见	❌ 计算开销大	`MultiRetriever`

构建 “多路召回 + 重排序” 架构，实现性能上限突破。

三、多路召回架构设计

用户问题
    ↓
[Query 改写与扩展] → 生成多个检索关键词 / 语义表达
    ↓
【并行召回】
├─ 向量召回（Embedding） → Top-10
├─ 关键词召回（BM25） → Top-10
├─ 图结构召回（知识图谱） → Top-5
├─ 自我生成召回（LLM） → Top-5
    ↓
【融合与去重】 → 合并所有结果，去除重复
    ↓
[重排序（Rerank）] → 使用 Cross-Encoder 重新打分
    ↓
[最终输出] → 返回 Top-5 高相关文档

✅ 实现工具：

使用 LangChain 的 MultiRetriever 合并多个检索器。

使用 bge-reranker-large 或 Cohere rerank 做重排序。

通过 langchain.retrievers.ContextualCompressionRetriever 实现上下文压缩。

📌 关键技巧：

设置权重：如 0.5 向量 + 0.3 BM25 + 0.2 图结构。

对“事实型”问题，提高关键词召回权重。

对“推理型”问题，以向量召回为主。

四、Query 改写与扩展

1. 同义扩展（Query Expansion）
技术实现：

基于知识图谱（如WordNet）或领域术语表扩展
使用词向量（Word2Vec/GloVe）或上下文嵌入（BERT）寻找语义相近词
商业应用：Elasticsearch的synonym filter

进阶变体：

动态扩展：根据检索结果动态调整扩展词（如RM3算法）
概率扩展：为扩展词分配权重（如"手机发热:1.0, 发烫:0.8, 过热:0.7"）

2. 语义重写（Semantic Rewriting）
典型场景：

口语转专业术语：“这车费油不？” → “该车型燃油效率如何？”
模糊转精确：“最近的热门” → “2026年1月热门科技新闻”

技术方案：

基于模板的规则系统（适合垂直领域）
微调T5/BART等seq2seq模型
最新趋势：使用GPT-4等LLM进行zero-shot改写

3. 对话历史融合（Context Integration）
实现策略：

方法	示例	适用场景
窗口拼接	保留最近3轮对话	简单对话
指代消解	"它"→具体型号	含代词场景
意图继承	延续上轮筛选条件	多轮筛选

技术难点：

长上下文建模（可使用Longformer等模型）
无关历史过滤（通过注意力机制实现）

4. 问题分解（Multi-hop Decomposition）
操作流程：

识别子问题（使用LLM或规则）
并行检索子问题
结果聚合（可用MaxSim或投票机制）

典型模式：

# 伪代码示例
sub_questions = llm.generate(
    "将'比较iPhone15和Pixel8的摄像头'分解为：\n"
    "1. iPhone15摄像头参数\n"
    "2. Pixel8摄像头参数\n"
    "3. 两者的DxOMARK评分对比"
)

5. HyDE（Hypothetical Document Embedding）
技术原理：

关键优势：

解决"词汇不匹配"问题（如专业术语表述差异）
适合概念性查询（如"解释量子纠缠"）

实施建议：

生成3-5个不同风格的假设回答
对生成内容做事实性校验（避免错误知识污染检索）

6. 标签提取与结构化查询
处理流程：

命名实体识别（NER）
属性-值对提取（如"预算1万以内"→"price<=10000"）
构建布尔查询表达式

工具推荐：

spaCy/Stanza用于基础NER
微调BERT-CRF处理领域特定实体
使用Semgrex处理复杂语义关系

7. 查询重表述（Paraphrasing）
技术对比：

方法	优点	缺点
基于规则	可控性强	覆盖率低
统计机器翻译	泛化性好	需要平行语料
LLM生成	质量高	计算成本大

质量评估矩阵：

语义一致性（BERTScore）
检索效果提升（Recall@10）
语言流畅度（Perplexity）

方法选型建议
根据场景选择组合策略：

电商客服：标签提取 + 对话融合
学术搜索：HyDE + 同义扩展
复杂QA：问题分解 + 语义重写

五、递归 RAG（Recursive RAG）

核心思想：
让 RAG 系统具备“自我反思、自我优化”的能力，形成生成 → 检索 → 反馈 → 更新的闭环。

架构流程：

用户提问
    ↓
[生成答案] → 模型输出回答
    ↓
[反思与验证] → 检查答案是否依赖外部知识
    ↓
[若需补充] → 生成新问题 → 再次检索 → 更新上下文
    ↓
[输出最终答案] → 返回完整、可信结果

✅ 实现方式：

使用 LangGraph 构建有状态的 RAG 流程。

设置最大递归层数（如 3 层），防止无限循环。

加入“置信度判断”机制：若模型信心低于阈值，触发再检索。

📌 应用场景：

复杂法律条款分析

金融风险评估

多轮对话中的知识补充

✅ 优势：

解决“知识盲区”问题

提升答案完整性与可信度

支持“边用边学”的知识演化

六、企业级 RAG 回召评估指标

指标	说明	目标值
Recall@K	前 K 个结果中命中正确答案的比例	≥ 85%
MRR（Mean Reciprocal Rank）	正确答案平均倒数排名	≥ 0.7
Precision@K	召回结果中正确比例	≥ 70%
响应延迟	从提问到输出时间	< 2s
幻觉率	生成虚构内容比例	< 10%

✅ 工具支持：

使用 evaluate 库或 scikit-learn 计算指标。

构建 A/B 测试流程，对比不同召回策略。

“多路召回 + Rerank”是RAG性能上限的关键。

5. 重排序（Rerank）

工具名称	类型	架构	支持模态	主要优势	适用场景
BGE-Reranker (THUDM)	文本重排序	BERT + 对比学习	文本	中文语义理解强，精度高，支持指令微调	RAG、问答系统、知识库检索
Cohere Rerank	API 服务	自研模型	文本	闭源但性能卓越，易集成，支持多语言	企业级应用、快速上线
CrossEncoder (Hugging Face)	开源模型	Transformer	文本	支持任意长度输入，精度高，可自定义训练	研究、定制化系统
BAAI-rerank (BAAI)	重排序模型	BERT + 对比学习	文本	多语言支持好，轻量高效，适合部署	多语言系统、边缘设备
T5-Rerank (Google)	重排序模型	T5 + 编码-解码	文本	支持生成式重排序，可输出解释性结果	高阶推理、可解释性需求

一、重排序的核心目标与价值

目标	说明
提升相关性	将最相关文档排在最前面
消除噪声	过滤掉语义相近但内容无关的结果
支持复杂推理	比较 query 与 doc 的深层语义关系
增强可解释性	提供置信度评分，便于人工审核
降低幻觉风险	仅基于高相关文档生成答案

🌟 一句话升华：
重排序，是 RAG 从“能用”走向“好用”、从“通用”迈向“专业”的分水岭。

二、主流重排序工具深度对比

工具名称	类型	架构	支持模态	主要优势	适用场景
BGE-Reranker (THUDM)	开源模型	BERT + 对比学习	文本	✅ 中文语义理解极强 ✅ 精度高，支持指令微调 ✅ 轻量高效，支持本地部署	RAG、问答系统、知识库检索
Cohere Rerank	API 服务	自研模型	文本	✅ 闭源但性能卓越 ✅ 易集成，支持多语言 ✅ 提供 API 管理面板	企业级应用、快速上线
CrossEncoder (Hugging Face)	开源模型	Transformer	文本	✅ 支持任意长度输入 ✅ 可自定义训练 ✅ 精度极高	研究、定制化系统
BAAI-rerank (BAAI)	开源模型	BERT + 对比学习	文本	✅ 多语言支持好 ✅ 轻量高效，适合边缘部署 ✅ 与 BGE 系列兼容	多语言系统、边缘设备
T5-Rerank (Google)	重排序模型	T5 + 编码-解码	文本	✅ 支持生成式重排序 ✅ 可输出解释性理由 ✅ 适合高阶推理场景	可解释性需求、智能决策

三、各模型详解与选型建议

1. BGE-Reranker

架构：BERT + 对比学习（Contrastive Learning）
向量维度：768
支持指令微调：是（如 retrieval: ...）
性能表现：
- 在中文 RAG 任务中，优于 Cohere 与 CrossEncoder
- 在中文法律、合同、财务等领域，F1 分数领先 5%~8%

✅ 推荐场景：

企业知识库问答

合同审查系统

政务/金融/医疗等中文密集型领域

✅ 部署建议：
使用 sentence-transformers 加载模型：
from sentence_transformers import CrossEncoder
model = CrossEncoder('BAAI/bge-reranker-large')
推荐使用 bge-reranker-large 或 bge-reranker-base（根据资源选择）

2. Cohere Rerank

类型：云服务 API
优势：
- ✅ 无需部署，API 接入简单
- ✅ 支持多语言（含中文）
- ✅ 提供可视化控制台，支持 A/B 测试
- ✅ 服务稳定，SLA 高

✅ 推荐场景：

快速上线 RAG 系统

企业级 SaaS 产品

不愿承担模型运维成本的团队

⚠️ 注意：

成本较高（按调用次数计费）

数据需上传至 Cohere 服务器，不适合敏感数据场景

✅ 使用示例：

import cohere
client = cohere.Client("your-api-key")
response = client.rerank(
    query="如何修改合同条款？",
    documents=["合同第5.2条...", "付款时间说明...", "..."],
    top_n=5
)

3. CrossEncoder（Hugging Face）

架构：Transformer 编码器，逐对比较 query 与 doc
优势：
- ✅ 精度极高，是目前最准确的重排序模型
- ✅ 支持任意长度输入（如超长合同段落）
- ✅ 可自定义训练，适配特定领域
- ✅ 开源、可修改、可部署

✅ 推荐场景：

学术研究、论文实验

需要高度定制化的系统

对精度要求极致的场景（如法律判决辅助）

⚠️ 局限：

计算资源消耗大（尤其长文本）

需要 GPU 支持

部署复杂，需封装为服务

✅ 优化建议：

使用 fp16 降低显存占用。

对长文档先分块，再重排序。

使用 FastAPI 封装为 REST 接口。

4. BAAI-rerank（BAAI）

架构：BERT + 对比学习
支持语言：中英文、日文、法语等 10+ 种语言
性能：
- 在多语言任务中表现优异
- 推理速度比 BGE-Reranker 快 20%~30%

✅ 推荐场景：

国际化企业知识库

边缘设备部署（如移动端、嵌入式系统）

资源受限环境

✅ 部署方式：

支持 ONNX、TensorRT 加速

可通过 Hugging Face 直接加载

📌 模型列表：

BAAI/bge-reranker-base

BAAI/bge-reranker-large

5. T5-Rerank（Google）

架构：T5 + 编码-解码
核心能力：
- 不仅输出“相关性得分”，还能生成“理由”
例如：“该条款与用户问题高度相关，因其明确约定了‘合同修改’的流程。”
- 支持可解释性需求
- 可用于智能决策支持系统

推荐场景：

法律判决辅助

金融风控决策

需要“解释为什么选这个答案”的系统

局限：

速度慢，推理成本高

仅支持文本，暂无多模态支持

使用示例：

from transformers import pipeline
rerank_pipe = pipeline("text2text-generation", model="google/t5-reranker")
result = rerank_pipe(f"relevance: {query} {doc}")

四、常见问题与解决方案

问题	原因	解决方案
重排序太慢	模型过大、未启用量化	使用 `fp16`、`ONNX`、`TensorRT` 优化
重排序结果不稳定	输入长度不一致	统一最大长度（如 512 token）
无法部署本地	缺少 GPU	使用轻量模型（如 `bge-reranker-base`）
输出无解释	使用纯对比学习模型	改用 T5-Rerank 或自定义输出格式

6. RAG增强形态

类型	说明	技术实现
自我RAG	模型自我生成知识片段并存入知识库	`LangChain Self-Query` + `VectorStore`
图RAG	基于知识图谱的语义关联召回	`Neo4j` + `GraphRAG` + `LLM推理`
多模态RAG	支持文本、图像、PDF、表格等混合信息	`CLIP` + `LayoutParser` + `OCR` + `VectorDB`
动态RAG	根据用户反馈自动更新知识库	`LangGraph` + `Feedback Loop`

一、自我 RAG（Self-RAG）

核心思想：
模型在生成答案时，主动识别并标注关键信息，将其作为新知识存入知识库，形成“生成 → 检索 → 更新”闭环。
技术实现路径

用户提问
    ↓
[生成答案] → 模型输出回答
    ↓
[自我发现] → 识别新实体、关系、条款等
    ↓
[自动生成结构化条目] → 如“乙方违约需支付合同金额 20% 赔偿金”
    ↓
[存入 VectorStore] → 以新文档形式加入知识库
    ↓
[下次提问时可召回] → 实现知识自演化

核心技术组件

技术	说明
Self-Query Retriever	让 LLM 学会“如何提问自己”来检索信息
VectorStore + Metadata	存储结构化内容，支持按标签、类型、时间等过滤
Prompt 工程	设计引导模型“发现知识”的提示词
审核机制	防止错误或虚构信息污染知识库

实现示例（LangChain）

from langchain.retrievers.self_query import SelfQueryRetriever
from langchain.vectorstores import Chroma
from langchain.embeddings import HuggingFaceEmbeddings

# 初始化向量库
vectorstore = Chroma(embedding_function=HuggingFaceEmbeddings(model_name="BAAI/bge-small-zh"))

# 构建 Self-Query Retriever
retriever = SelfQueryRetriever.from_llm(
    llm=llm,
    vectorstore=vectorstore,
    document_contents="摘要",
    metadata_field_info=[
        {"name": "entity", "description": "实体名称（如人名、公司名）", "type": "string"},
        {"name": "relation", "description": "关系类型（如甲方-乙方）", "type": "string"},
        {"name": "category", "description": "文档类别（如合同、报告）", "type": "string"}
    ],
    verbose=True
)

适用场景

场景	说明
法律合同系统	自动提取“违约条款”“生效条件”等并入库
金融风控平台	识别“高风险客户”“异常交易行为”并更新规则
研发知识库	自动记录“代码缺陷”“解决方案”形成经验库
客服系统	将用户高频问题转化为知识条目，持续优化问答质量

二、图 RAG（Graph RAG）

核心思想：
不再仅依赖“文本相似度”，而是基于知识图谱的语义关系进行智能召回与推理。

技术实现路径

原始文档
    ↓
[实体与关系抽取] → 使用 NER + 关系分类模型
    ↓
[构建知识图谱] → 存入 Neo4j / JanusGraph
    ↓
[用户提问] → 如“乙方违约后谁负责赔偿？”
    ↓
[图查询] → Cypher 查询：MATCH (a:Party)-[:HAS_CONTRACT]->(c:Contract)-[:HAS_CLAUSE]->(b:Clause) WHERE b.type = 'penalty' RETURN b
    ↓
[结果返回] → 返回具体条款与责任人

核心技术组件

技术	说明
实体识别（NER）	识别人名、公司、条款编号等
关系抽取（RE）	识别“甲方-乙方”“签约-生效”等关系
知识图谱存储	`Neo4j`（主流）、`JanusGraph`（分布式）
图查询语言	`Cypher`（Neo4j）、`Gremlin`（JanusGraph）
LLM 推理	将自然语言问题转为图查询语句

实现示例（LangChain + Neo4j）

from langchain.graphs import Neo4jGraph
from langchain.chains import GraphQAChain

# 连接 Neo4j
graph = Neo4jGraph(url="bolt://localhost:7687", username="neo4j", password="password")

# 构建图问答链
chain = GraphQAChain.from_llm(llm=llm, graph=graph, verbose=True)

# 用户提问
result = chain.run("乙方违约后需要支付多少赔偿金？")

适用场景

场景	优势
法律条款分析	支持复杂逻辑推理（如“若A违约，则B需赔偿C”）
供应链管理	查询“某供应商是否涉及多个项目”
金融风控	分析“关联企业”“担保关系”
智能客服	回答“我之前投诉过的问题现在怎么解决？”

三、多模态 RAG

核心思想：
支持文本、图像、PDF、表格、代码等多种模态的混合输入与检索，实现跨模态理解。

🔍 技术实现路径

用户上传 PDF / 图片 / 表格
    ↓
[文档解析] → 使用 LayoutParser 提取结构
    ↓
[OCR 识别] → 使用 PaddleOCR / Tesseract 识别文字
    ↓
[向量化] → 使用 CLIP / Qwen-VL 生成多模态嵌入
    ↓
[存入 VectorDB] → 支持跨模态检索
    ↓
[用户提问] → 如“这张图里哪个是合同签署页？”
    ↓
[跨模态检索] → 返回相关图像与文本

核心技术组件

技术	说明
LayoutParser	识别 PDF/图像中的文本块、表格、标题等布局
OCR 引擎	`PaddleOCR`（中文强）、`Tesseract`（开源）
多模态 Embedding	`CLIP`（图文对齐）、`Qwen-VL`（中文多模态强）
VectorDB	支持多模态向量存储（如 Qdrant、Milvus）
Prompt 工程	引导模型理解“图像+文本”上下文

实现示例（PaddleOCR + Qwen-VL）

from paddleocr import PaddleOCR
from qwen_vl import QwenVLProcessor, QwenVLForConditionalGeneration

# OCR 识别
ocr = PaddleOCR(use_angle_cls=True, lang="ch")
result = ocr.ocr("contract.png", cls=True)

# 多模态嵌入
processor = QwenVLProcessor.from_pretrained("Qwen/Qwen-VL-Chat")
model = QwenVLForConditionalGeneration.from_pretrained("Qwen/Qwen-VL-Chat")

# 输入图像与文本
inputs = processor(text="这张图里有哪些合同条款？", images=["contract.png"], return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=100)
print(processor.decode(outputs, skip_special_tokens=True))

适用场景

场景	优势
合同扫描件识别	自动提取签字页、金额、日期
发票/票据处理	识别金额、开票方、税号
技术文档分析	解析带图的说明书、流程图
财务报表理解	分析表格中的趋势、异常值

四、动态 RAG（Dynamic RAG）

核心思想：
系统能感知用户反馈（如“答案不准确”“信息缺失”），自动触发知识库更新或召回策略调整。

技术实现路径

用户提问 → 模型生成答案
    ↓
[用户反馈] → 点击“不准确”或“需要补充”
    ↓
[反馈收集] → 记录问题与反馈类型
    ↓
[触发更新] → 生成新问题 → 再次检索 → 更新知识库
    ↓
[系统优化] → 调整召回权重、重排序模型

核心技术组件

技术	说明
LangGraph	构建有状态的 RAG 流程，支持循环与条件判断
Feedback Loop	识别用户行为（点击、评分、停留时间）
动态权重调整	根据反馈自动优化召回策略
自动重训练	定期基于反馈数据微调模型

实现示例（LangGraph + Feedback）

from langgraph.graph import StateGraph, END

# 定义状态
class RAGState(TypedDict):
    question: str
    answer: str
    feedback: str
    iterations: int

# 构建图
builder = StateGraph(RAGState)

def generate_answer(state: RAGState):
    # 生成答案
    answer = llm.invoke(f"请回答：{state['question']}")
    return {"answer": answer, "iterations": state["iterations"] + 1}

def check_feedback(state: RAGState):
    if state["feedback"] == "accurate":
        return END
    else:
        # 生成新问题
        new_question = llm.invoke(f"根据反馈‘{state['feedback']}’，请生成一个新问题以获取更多信息：{state['question']}")
        return {"question": new_question, "feedback": ""}

builder.add_node("generate", generate_answer)
builder.add_node("check_feedback", check_feedback)

builder.add_edge("generate", "check_feedback")
builder.add_conditional_edges("check_feedback", lambda x: "END" if x["feedback"] == "accurate" else "generate")

graph = builder.compile()

适用场景

场景	优势
智能客服	自动识别“答非所问”并优化
知识库维护	用户反馈驱动知识更新
金融风控	实时识别“规则未覆盖”情况
研发支持	用户指出“文档缺失”后自动补全

7.promote工程

一、Prompt 工程六大核心维度

维度	说明	关键技巧
1. 明确角色（Role）	让 AI “扮演”特定身份	“你是一位资深法律专家”
2. 定义任务（Task）	明确要完成的具体动作	“请分析合同中的违约金条款”
3. 提供上下文（Context）	提供背景信息或输入数据	“根据2024年Q3销售数据…”
4. 指定格式（Format）	控制输出结构与风格	“以 JSON 格式输出”
5. 限制条件（Constraints）	设定边界与约束	“不超过200字”、“避免使用专业术语”
6. 示例引导（Few-Shot）	提供输入-输出示例	“示例：输入‘合同违约’ → 输出‘赔偿金额为总金额的10%’”

二、Prompt 设计黄金法则（含代码示例）

1. 角色 + 任务 + 上下文：构建“完整指令”

# 示例：法律合同分析
prompt = """
你是一位资深企业法律顾问。
请根据以下合同条款，分析其中的违约金条款：

合同原文：
“若乙方未按期交付货物，应按未交付部分金额的15%支付违约金。”

请回答：
1. 违约金比例是多少？
2. 是否有上限限制？
3. 是否需要通知义务？

请用中文回答，不超过100字。
"""

# 执行
response = llm.invoke(prompt)
print(response)

输出：
违约金比例为15%。无明确上限。未提及通知义务，建议补充。

2. 格式化输出控制

# 要求输出 JSON
prompt = """
请将以下信息转换为 JSON 格式：
- 产品名称：智能合约系统
- 版本号：v2.3.1
- 发布日期：2025年1月15日
- 功能亮点：支持多链部署、自动合规检查、AI 审计

输出格式：
{
  "product": "智能合约系统",
  "version": "v2.3.1",
  "release_date": "2025-01-15",
  "features": [
    "支持多链部署",
    "自动合规检查",
    "AI 审计"
  ]
}
"""

response = llm.invoke(prompt)
print(response)

优势：便于程序解析，避免格式混乱。

3. Few-Shot 示例引导

# 提供示例，引导 AI 理解任务
prompt = """
请根据以下示例，分析新的合同条款。

示例1：
输入：“若延迟交付，按日支付0.1%违约金。”
输出：“违约金为每日0.1%，无上限。”

示例2：
输入：“违约金最高不超过合同总额的10%。”
输出：“违约金上限为合同总额的10%。”

现在请分析：
输入：“若未按时付款，应支付逾期利息，利率为LPR的1.5倍。”
输出：
"""

response = llm.invoke(prompt)
print(response)

效果：AI 学会“模式识别”，输出更一致。

4. 约束与边界控制

# 限制长度与用词
prompt = """
你是一位金融合规顾问。
请用通俗语言解释“流动性风险”：
- 请使用生活化比喻（如“资金链断裂”）
- 不使用“杠杆”“对冲”等术语
- 回答不超过150字
- 以“比如…”开头
"""

response = llm.invoke(prompt)
print(response)

输出：
比如，就像你家的水龙头漏水，如果没人及时关，很快水就会用光。企业如果现金流断了，就可能没法付工资、买原料，这就是流动性风险。

5. 思维链（Chain-of-Thought, CoT）

# 要求 AI 展示推理过程
prompt = """
请分析以下合同条款的法律风险，并分步说明：

条款：“乙方需在收到通知后3个工作日内完成整改，否则视为违约。”

步骤1：解释“通知”的定义  
步骤2：分析“3个工作日”是否合理  
步骤3：评估违约后果是否过重  
步骤4：综合判断风险等级（低/中/高）

请用中文回答，每步不超过50字。
"""

response = llm.invoke(prompt)
print(response)

优势：提升可信度，便于人工审核。

6. 多轮对话上下文管理

# 使用历史记录实现上下文延续
from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()

def ask_question(question: str):
    # 构建带上下文的 Prompt
    prompt = f"""
你是一位AI助手，正在与用户进行对话。
请根据以下历史对话和当前问题，回答：

历史对话：
{memory.load_memory_variables({})['history']}

当前问题：{question}

请用简洁中文回答，不超过100字。
"""
    response = llm.invoke(prompt)
    memory.save_context({"input": question}, {"output": response})
    return response

# 使用示例
print(ask_question("请解释‘违约金’是什么？"))
print(ask_question("那怎么计算？"))

效果：实现“有记忆”的智能对话。

三、专业提示词结构框架

1. CRISE框架

Context (上下文)：设定场景
Role (角色)：指定AI角色
Instruction (指令)：明确任务
Steps (步骤)：分解过程
Examples (示例)：提供样例

2. BROKE框架

Background (背景)：情境描述
Request (请求)：核心要求
Output (输出)：期望结果
Knowledge (知识)：相关领域
Examples (示例)：参考案例

3. ICIO框架

Input (输入)：提供的信息
Context (上下文)：环境设定
Instruction (指令)：具体任务
Output (输出)：格式要求

四、企业级Prompt模板库

1. 合同审查与法律分析（CRISE框架）

【Context】作为公司法务团队，需快速审查合同条款风险  
【Role】你是一位资深企业法律顾问，擅长识别隐蔽风险  
【Instruction】分析以下合同条款，指出潜在问题并提供修改建议：  
"若甲方延迟付款超过30天，乙方有权终止合同且无需退还预付款。"  
【Steps】  
1. 识别关键权利义务条款  
2. 评估条款公平性（是否符合行业惯例）  
3. 检查法律合规性（如《民法典》第585条）  
4. 提出具体修改建议  
【Example】  
输入："违约方需赔偿守约方全部损失" → 输出："建议改为'直接损失'，避免无限责任"

输出示例：

风险点：未明确"预付款"性质（定金or预付款？）

公平性：行业惯例通常设置15-60天宽限期

合规性：建议增加"书面催告程序"以符合《民法典》

修改建议：“…乙方应书面催告，甲方在15个工作日内仍未付款的，乙方可终止合同，预付款按实际服务比例退还”

2. 财务报告分析（BROKE框架）

【Background】2024年Q3财报显示营收增长但利润率下降  
【Request】请分析根本原因并提出改进方案  
【Output】需包含：  
- 关键数据对比（表格）  
- 成本驱动因素TOP3  
- 短期/长期优化建议  
【Knowledge】制造业成本结构、盈亏平衡点计算  
【Examples】  
输入案例：  
"营销费用同比增40%，但新客户贡献率仅5%"  
→ 输出建议：  
"优化获客渠道，优先投放ROI>2的渠道"

输出示例：

指标	2024Q2	2024Q3	变化
营收（亿元）	15.2	16.8	+10%
毛利率	32%	28%	-4pp
根本原因：

原材料成本上涨（占成本比从45%→52%）
新生产线调试废品率高达18%
建议：

短期：与供应商签订价格锁定协议
长期：引入AI质检系统（预计降低废品率至5%）

3. 上市公司财报分析

[角色] 买方机构基金经理（专注消费行业）  
[任务] 提取东财2024Q3白酒行业关键信号  
[上下文] 行业整体营收增速放缓至5%，茅台逆势增长12%  
[格式] 三栏对比：指标/行业均值/龙头表现  
[约束] 避免直接引用原文，需二次加工  
[示例]  
输入：预收款同比下降20%  
输出：  
```markdown
| 指标         | 行业均值 | 茅台    | 信号解读          |  
|--------------|----------|---------|-------------------|  
| 预收款变动   | -20%     | +8%     | 龙头渠道控制力增强 |  
| 销售费用率   | 18%      | 9%      | 品牌溢价效应显现  |

4. 业务办理引导

[角色] 数字银行AI助手（支持语音/图文）  
[任务] 指导用户在线开通科创板权限  
[格式] 分步骤指令（含截图位置描述）  
[约束] 每步不超过15字，支持语音播报  
[示例]  
输入：用户问"如何开通科创板？"  
输出：  
```markdown
1. 打开APP→底部"交易"  
2. 点击"权限管理"（蓝白色图标）  
3. 选择"科创板"→风险测评  
4. 签署协议→刷脸验证

三、Agent与智能体层

核心目标：实现从“回答问题”到“完成任务”的跃迁

组件	说明	框架
规划（Plan）	决定任务执行步骤（如“先查合同 → 再发邮件”）	`LangChain Agents`、`AutoGen`
工具（Tools）	可被调用的功能（查数据库、发邮件、读文件）	`Python REPL`、`API Tool`、`File Tool`
LLM核心	作为决策大脑，生成动作指令	`GPT-4`、`Qwen`、`Llama3`
记忆（Memory）	保持上下文状态：

短期：上下文窗口（context length）
长期：向量库或数据库存储历史 | ConversationBufferMemory、VectorDB |

一、规划（Plan）

核心思想：
Agent 不应直接执行，而应先分解任务、制定步骤、决定顺序，如同人类员工接到任务后的“头脑风暴”。

任务规划的三种范式

范式	说明	代表框架
链式规划（Chain-of-Planning）	LLM 生成一系列动作序列，逐步执行	`LangChain Agents`
分层规划（Hierarchical Planning）	将复杂任务分解为子任务，逐层细化	`AutoGen`、`ReAct`
基于图的规划（Graph-Based Planning）	构建任务依赖图，动态调整路径	`LangGraph`

实现路径（以 LangChain 为例）

from langchain.agents import Tool, AgentExecutor, create_react_agent
from langchain_community.tools import DuckDuckGoSearchRun
from langchain_community.tools import ShellTool
from langchain_community.tools import FileReadTool

# 定义工具
search_tool = Tool(
    name="Search",
    description="用于搜索互联网信息",
    func=DuckDuckGoSearchRun().run,
)

file_read_tool = FileReadTool(root_dir="./docs")

# 创建 Agent
agent = create_react_agent(
    llm=llm,
    tools=[search_tool, file_read_tool],
    prompt=react_prompt
)

# 执行任务
agent_executor = AgentExecutor(agent=agent, tools=[search_tool, file_read_tool], verbose=True)
result = agent_executor.invoke({"input": "请查找‘数据安全合规’最新政策，并读取本地政策文件中的第3条。"})

适用场景

场景	规划能力要求
多步骤任务	如“分析合同 → 提取风险点 → 生成报告”
跨系统操作	如“查数据库 → 生成图表 → 发邮件”
复杂决策	如“选择最优供应商 → 生成比价表 → 发起审批”

二、工具（Tools）

核心思想：
LLM 只能“想”，不能“做”。工具是 Agent 的“肢体”，使其能真正与外部世界交互。

工具类型与实现方式

工具类型	说明	实现方式
API 工具	调用外部服务（如 ERP、CRM、钉钉）	`HTTP Request` + `Pydantic` 模型
文件工具	读取/写入本地文件	`FileReadTool`、`FileWriteTool`
数据库工具	查询/更新数据库	`SQLDatabaseToolkit`
Shell 工具	执行命令行指令	`ShellTool`
浏览器工具	自动化网页操作	`Selenium` + `Playwright`
LLM 工具	调用另一个 LLM 进行推理	`LLMChain` 嵌套

实现示例（自定义 API 工具）

from langchain.tools import BaseTool
from pydantic import BaseModel, Field
import requests

class GetEmployeeInfo(BaseTool):
    name = "GetEmployeeInfo"
    description = "根据员工 ID 查询员工信息"
    
    class InputSchema(BaseModel):
        employee_id: str = Field(..., description="员工 ID")

    def _run(self, employee_id: str):
        url = f"https://api.company.com/employees/{employee_id}"
        response = requests.get(url)
        return response.json()

    def _arun(self, employee_id: str):
        raise NotImplementedError

适用场景

场景	工具需求
数据查询	数据库工具、API 工具
文件处理	文件读写工具
自动化操作	Shell 工具、浏览器工具
跨系统集成	API 工具、Webhook 工具

三、LLM 核心

核心思想：
LLM 不仅是“回答者”，更是任务理解、规划生成、动作选择、反馈判断的决策主体。

LLM 作为 Agent 的四大角色

角色	说明
任务理解器	解析用户意图，识别任务类型
规划生成器	生成执行步骤序列
动作选择器	决定调用哪个工具、传入什么参数
反思判断器	判断执行结果是否成功，是否需要重试

模型选型建议

场景	推荐模型
中文任务	`Qwen`、`DeepSeek`、`Baichuan`
多语言任务	`GPT-4`、`Llama3`
复杂推理	`GPT-4-turbo`、`Claude 3`
成本敏感	`Qwen-Max`、`Llama3-8B`

提示工程关键：

显式定义角色：你是一个专业的合同审查助手

提供示例：示例：输入“检查违约条款” → 输出：[查合同第5.2条，提取赔偿金额]

加入反思机制：如果执行失败，请分析原因并尝试新方案

四、记忆（Memory）

核心思想：
没有记忆的 Agent，就像“健忘的人”——今天问的问题，明天就忘了。
记忆是实现“上下文连贯”与“长期学习”的基础。

记忆类型与实现方式

类型	说明	实现工具
短期记忆	仅保留在当前对话窗口中	`ConversationBufferMemory`
长期记忆	持久存储，支持跨会话访问	`VectorDB`、`SQL Database`
状态记忆	记录任务执行状态（如“已查合同”）	`LangGraph State`
目标记忆	记录用户目标与进度	`Persistent Memory`

实现示例（LangChain + VectorDB）

from langchain.memory import VectorStoreRetrieverMemory
from langchain.vectorstores import Chroma
from langchain.embeddings import HuggingFaceEmbeddings

# 初始化向量库
vectorstore = Chroma(embedding_function=HuggingFaceEmbeddings(model_name="BAAI/bge-small-zh"))

# 创建长期记忆
memory = VectorStoreRetrieverMemory(
    retriever=vectorstore.as_retriever(),
    memory_key="chat_history",
    return_messages=True
)

适用场景

场景	记忆需求
多轮对话	保持上下文一致性
任务追踪	记录任务进度（如“已完成合同审查”）
个性化服务	记录用户偏好与历史行为
知识沉淀	将成功经验存入知识库

五、Agent 架构全景图

用户提问
    ↓
[LLM 核心] → 理解意图，生成规划
    ↓
[规划引擎] → 分解任务，生成步骤
    ↓
[工具调用] → 调用 API / 文件 / 数据库等
    ↓
[记忆系统] → 读取历史，更新状态
    ↓
[反馈循环] → 判断是否成功，是否需要重试
    ↓
[输出结果] → 返回自然语言答案

关键架构组件：

LangChain：快速搭建 Agent 流程

LangGraph：支持状态管理与循环

VectorDB：长期记忆与知识沉淀

API 网关：统一工具调用入口

审计日志：记录所有操作，便于追溯

六、企业级 Agent 落地建议

场景	推荐方案
客服系统	使用 `LangChain` + `API 工具` + `短期记忆`
合同审查	使用 `AutoGen` + `Self-RAG` + `长期记忆`
智能审批	使用 `LangGraph` + `工具链` + `状态记忆`
知识管理	使用 `Self-RAG` + `图 RAG` + `长期记忆`

安全与合规：

所有工具调用必须经过审批

敏感操作需人工确认

所有行为留痕，支持审计

七、Agent类型对比

类型	特点	适用场景
Single Agent	单一角色，处理简单任务	客服问答
Multi-Agent	多角色协作，复杂流程	审批流程、跨系统自动化
Function Call	LLM与外部工具或API交互	结构化地请求
MCP（Model Context Protocol）	通信和数据交换的协议标准	模型间的知识迁移与联合推理
Agent Skills	标准化的程序性知识封装格式	教导智能体如何正确使用工具
A2A（Agent-to-Agent）	智能体间直接通信	协同决策、信息共享

1.Single Agent

核心思想：
一个 Agent 承担所有角色——理解意图、规划路径、调用工具、维护记忆。
类似“全能型员工”，适合简单任务。

🔍 特点分析

特性	说明
架构	单一 LLM + 单一工具链 + 单一记忆
执行流程	输入 → LLM 决策 → 工具调用 → 输出
优势	✅ 开发简单 ✅ 部署成本低 ✅ 适合快速上线
劣势	❌ 任务复杂时易出错 ❌ 无法并行处理 ❌ 缺乏容错与监控机制

适用场景

场景	说明
客服问答	如“合同条款是什么？”
知识库检索	如“查找2024年财务报告”
简单信息查询	如“北京今天天气如何？”

使用建议

仅适用于单步、低风险、高频次任务。
建议搭配工具调用限制与执行日志审计，防止误操作。

代表框架：LangChain、LangFlow（低代码）

2.Multi-Agent

核心思想：
将任务拆分为多个 Agent，各自扮演特定角色（如“分析员”“审核员”“执行员”），通过消息通信协同完成复杂流程。

特点分析

特性	说明
架构	多个 Agent 并行运行，通过消息传递协作
通信机制	基于文本或结构化消息（JSON）
优势	✅ 任务可拆解 ✅ 支持并行处理 ✅ 可实现多角色审核与验证 ✅ 易于扩展
劣势	❌ 架构复杂，开发成本高 ❌ 消息冲突风险高 ❌ 需要统一协调机制

适用场景

场景	说明
审批流程	如“申请报销” → 分析 → 审核 → 批准
跨系统自动化	如“查数据库 → 生成报表 → 发邮件”
多维度分析	如“市场趋势分析” → 数据分析 → 风险评估 → 报告生成

实现方式（以 AutoGen 为例）

from autogen import Agent, GroupChat, GroupChatManager

# 定义角色
analyst = Agent(name="Analyst", system_message="负责数据分析")
reviewer = Agent(name="Reviewer", system_message="负责审核结果")
executor = Agent(name="Executor", system_message="负责执行操作")

# 创建群组
group_chat = GroupChat(agents=[analyst, reviewer, executor], messages=[], max_round=10)
manager = GroupChatManager(groupchat=group_chat)

# 启动协作
manager.initiate_chat(
    message="请分析2024年Q3销售数据，并生成报告。",
    clear_history=True
)

关键挑战与应对

挑战	应对策略
角色冲突	明确职责边界，设置优先级
消息丢失	使用消息队列（如 Kafka）
协调混乱	引入“协调者”（Coordinator）角色

代表框架：AutoGen、LangGraph（支持多 Agent）

3.Function Call(函数调用)

一、Function Call概述

Function Call(函数调用)是大语言模型(LLM)与外部工具或API交互的核心机制，它允许模型在生成文本时识别需要外部计算或数据检索的场景，并结构化地请求这些服务。

1.1 基本概念

Function Call使LLM能够：

动态决定何时需要调用外部工具
以结构化格式生成请求参数
解析工具返回结果并整合到后续响应中

1.2 典型应用场景

实时数据获取：股票价格、天气信息等
复杂计算：数学运算、代码执行等
专业领域查询：法律、医疗等专业数据库
系统操作：发送邮件、控制智能设备等

二、技术原理深度解析

2.1 架构设计

Function Call的实现通常包含以下组件：

[用户输入] → [LLM文本生成] → [Function检测模块] → [参数提取模块] 
→ [外部API调用] → [结果解析] → [响应整合] → [最终输出]

2.2 工作流程详解

意图识别阶段：
- 模型分析用户query判断是否需要外部工具
- 基于预定义的function描述进行模式匹配
参数生成阶段：
- 模型生成符合API要求的结构化参数
- 参数通常以JSON格式呈现
执行与整合阶段：
- 系统调用实际function并获取结果
- 模型将结果自然融入后续响应

2.3 关键技术点

2.3.1 函数描述规范

OpenAI等平台使用类似以下的描述格式：

{
  "name": "get_current_weather",
  "description": "获取指定位置的当前天气",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
        "description": "城市和地区，例如'San Francisco, CA'"
      },
      "unit": {
        "type": "string",
        "enum": ["celsius", "fahrenheit"]
      }
    },
    "required": ["location"]
  }
}

2.3.2 多轮对话处理

复杂场景下的function call可能涉及：

参数澄清对话
多工具协同调用
结果验证与重新调用

三、主流实现方案

3.1 OpenAI Function Calling

OpenAI API提供了原生function call支持：

import openai

response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "旧金山现在的天气怎么样？"}],
    functions=[
        {
            "name": "get_current_weather",
            "description": "获取当前天气",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "城市和地区"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    ],
    function_call="auto"
)

3.2 LangChain实现方案

LangChain提供了更灵活的工具集成方式：

from langchain.agents import initialize_agent, Tool
from langchain.llms import OpenAI

def get_weather(location):
    # 实际天气API调用
    return f"{location}天气晴朗，25°C"

tools = [
    Tool(
        name="Weather",
        func=get_weather,
        description="用于查询城市天气"
    )
]

agent = initialize_agent(tools, OpenAI(temperature=0), agent="zero-shot-react-description")
agent.run("上海现在的天气如何？")

3.3 开源模型方案

使用LlamaIndex等工具为开源模型添加function call能力：

from llama_index import LLMPredictor, ServiceContext
from llama_index.tools import FunctionTool

def multiply(a: float, b: float) -> float:
    return a * b

multiply_tool = FunctionTool.from_defaults(fn=multiply)

service_context = ServiceContext.from_defaults(llm_predictor=LLMPredictor(llm=OpenAI()))
agent = ReActAgent.from_tools([multiply_tool], service_context=service_context)
response = agent.chat("计算3.14乘以2.71")

4.MCP

一、什么是MCP？

MCP (Model Context Protocol) 是一种专为AI模型间协作设计的标准化通信协议，它解决了复杂AI系统中三个核心问题：

模型孤岛问题：打破不同架构、不同框架开发的模型之间的壁垒
上下文丢失问题：在多模型协作过程中保持对话/任务上下文的一致性
动态路由问题：根据实时需求自动选择最优模型组合

典型应用场景示例：

医疗诊断系统：医学影像识别模型→临床知识库模型→治疗方案生成模型
金融分析：财报解析模型→风险预测模型→可视化生成模型
智能客服：意图识别模型→知识检索模型→多语言生成模型

二、为什么需要使用MCP？

传统AI系统痛点

问题类型	传统方案缺陷	MCP解决方案
模型协作	定制化点对点集成，N²复杂度	标准化接口，线性扩展
上下文传递	手工拼接提示词，信息丢失	结构化上下文链，自动传播
工具选择	静态配置，无法适应动态需求	基于QoS的实时路由
系统监控	各模型独立指标，难以端到端分析	统一traceID贯穿全链路

关键优势数据

开发效率：模型集成时间从平均3周缩短至2天
性能提升：通过智能路由降低30%的端到端延迟
成本节约：减少40%的冗余模型调用
准确性提升：完整上下文保持使任务准确率提高15-25%

三、协议架构深度解析

整体架构图

┌──────────────────────────────────────────────────┐
│                   Client Application             │
└───────────────┬──────────────────┬───────────────┘
                │                  │
┌───────────────▼─┐    ┌──────────▼──────────────┐
│   MCP Client    │    │       Context Cache     │
│   ┌──────────┐  │    │ ┌─────────────────────┐│
│   │  SDK     │  │    │ │  Context Storage    ││
│   └──────────┘  │    │ └─────────────────────┘│
│   ┌──────────┐  │    └────────────────────────┘
│   │  Adapter │  │                
│   └──────────┘  │    ┌────────────────────────┐
└───────────────┬─┘    │   Model Registry       │
                │      │ ┌─────────────────────┐│
┌───────────────▼───────►│ Model Metadata      ││
│   MCP Router          │ └─────────────────────┘│
│   ┌────────────────┐  │ ┌─────────────────────┐│
│   │ Routing Engine ├───►│ Capability Index    ││
│   └────────────────┘  │ └─────────────────────┘│
│   ┌────────────────┐  └──────────┬────────────┘
│   │ QoS Monitor    │             │
│   └────────────────┘             ▼
└───────────────┬─────────┌─────────────────────┐
                │         │   Model Endpoints    │
                └─────────►  ┌─────────────────┐ │
                            │  Model A         │ │
                            └─────────────────┘ │
                            ┌─────────────────┐ │
                            │  Model B         │ │
                            └─────────────────┘ │
                            ┌─────────────────┐ │
                            │  Model C         │ │
                            └─────────────────┘ │
                            └─────────────────────┘

核心组件说明

Context Cache：

采用分层存储设计（内存→SSD→对象存储）
支持基于时间/空间的淘汰策略
实现上下文差分编码（Delta Encoding）

Routing Engine：

def route(request):
    # 第一阶段：能力匹配
    candidates = filter(
        lambda m: set(request['required_caps']).issubset(m['capabilities']),
        registry.models
    )
    
    # 第二阶段：QoS筛选
    viable = [
        m for m in candidates 
        if m['latency'] < request['max_latency'] 
        and m['accuracy'] > request['min_accuracy']
    ]
    
    # 第三阶段：成本优化
    return min(viable, key=lambda x: x['cost_per_call'])

QoS Monitor：

实时采集指标：延迟、成功率、吞吐量

动态权重调整算法：

new_weight = α*old_weight + (1-α)*current_metric
(α=0.9，指数平滑)

异常检测：基于3σ原则的自动降级

四、模型工具选择机制

动态路由决策流程
需求解析阶段：
- 提取显式需求（用户指定的capability tags）
- 推断隐式需求（分析上下文历史）

候选模型筛选：

SELECT * FROM model_registry 
WHERE capabilities @> ARRAY['text-generation'] 
AND latency < 500 
ORDER BY accuracy DESC 
LIMIT 5;

最终决策矩阵：

模型	能力匹配度	延迟(ms)	准确率	成本	综合得分
GPT-4	100%	320	95%	高	88
Claude	100%	210	92%	中	92
Llama3	100%	1800	89%	低	65

负载均衡：采用改良型Power of Two Choices算法

def select_from_top2(top_models):
    m1, m2 = random.sample(top_models, 2)
    return m1 if m1['load'] < m2['load'] else m2

上下文感知路由示例
当检测到对话中涉及医疗术语时，自动添加：

{
  "required_caps": ["medical-knowledge"],
  "qos_constraints": {
    "min_accuracy": 0.98,
    "max_latency": 1500
  }
}

五、如何使用/开发MCP

终端用户使用方式
命令行工具：

# 安装MCP CLI
pip install mcp-cli

# 基本查询
mcp query "比较iPhone15和Pixel7的摄像头规格" \
  --context @previous_chat.json \
  --preference "response_format=markdown"

# 流式输出
mcp stream "实时股票分析：AAPL" \
  --caps ["financial-analysis", "real-time"]

Python SDK示例：

from mcp import Client

client = Client(api_key="your_key")

# 创建持续对话
session = client.create_session(
    system_prompt="你是一位资深技术架构师",
    qos_profile={"max_latency": 2000}
)

# 带附件的查询
response = session.query(
    "分析这份架构图的问题",
    attachments=["arch.pdf"],
    required_caps=["technical-review", "diagram-analysis"]
)

# 查看上下文
print(session.context_chain)

模型开发者集成指南
步骤1：实现MCP适配器

from mcp_sdk import ModelAdapter

class MyLLMAdapter(ModelAdapter):
    def __init__(self):
        super().__init__(
            model_id="my-llm-v2",
            capabilities=["text-generation", "translation"],
            qos_metrics={
                "avg_latency": 350,
                "accuracy": 0.92
            }
        )
        
    def predict(self, context_chain, current_input):
        # 合并上下文
        prompt = self._build_prompt(context_chain, current_input)
        
        # 调用实际模型
        output = self.model.generate(prompt)
        
        return {
            "output": output,
            "confidence": self._calc_confidence(output),
            "metadata": {
                "tokens_used": len(output)
            }
        }

步骤2：注册到MCP网络

adapter = MyLLMAdapter()
adapter.start(
    host="0.0.0.0",
    port=8080,
    registry_url="https://mcp-registry.example.com"
)

步骤3：性能调优配置

# mcp_config.yaml
resource_limits:
  max_concurrent_requests: 100
  cpu_allocation: 2.5
  memory_mb: 8192

context_handling:
  max_history_length: 10
  compression: "gzip"

monitoring:
  metrics_endpoint: "/internal/metrics"
  sample_rate: 0.8

5.Agent Skills

一、核心设计理念

1.1 Agent Skills的本质定义
Agent Skills是智能代理(Agent)可调用的模块化能力单元，它封装了：

特定领域知识：如金融分析、医疗诊断等专业知识
操作能力：如API调用、数据处理等实际操作
决策逻辑：基于输入做出判断和响应的规则体系

1.2 设计哲学

模块化：每个Skill解决一个明确问题，遵循单一职责原则
可组合性：Skills可像乐高积木一样自由组合创造复杂行为
可进化性：支持动态更新和版本迭代
透明性：输入输出和决策过程可解释、可审计

1.3 技术架构原则

二、破解上下文困境的五大策略

2.1 分层上下文管理

会话层：维护跨对话的长期记忆
任务层：当前任务的执行上下文
技能层：技能专属的临时上下文
用户层：用户画像和偏好设置

2.2 动态上下文修剪
实现基于重要性的自动遗忘机制：

def prune_context(context, max_tokens=4000):
    # 基于语义重要性评分
    sorted_segments = sorted(context, key=lambda x: x['importance'], reverse=True)
    pruned = []
    token_count = 0
    for seg in sorted_segments:
        if token_count + seg['tokens'] <= max_tokens:
            pruned.append(seg)
            token_count += seg['tokens']
    return pruned

2.3 上下文压缩技术

关键信息提取：使用NER模型识别实体
摘要生成：对长文本生成动态摘要
向量化表示：将文本转换为语义向量保存

2.4 多模态上下文融合

2.5 上下文感知路由
根据上下文动态选择最相关Skills：

def skill_router(query, context):
    embeddings = get_embeddings(query + json.dumps(context))
    skill_scores = {}
    for skill in registered_skills:
        similarity = cosine_sim(embeddings, skill['embedding'])
        skill_scores[skill['name']] = similarity * skill['relevance_weight']
    return max(skill_scores.items(), key=lambda x: x)

三、Agent Skills vs MCP

本质定义对比

维度	Agent Skills	MCP (Model Context Protocol)
核心目标	实现模块化、动态化的能力组合	标准化模型间的上下文传递与协作
设计焦点	技能（功能）的封装与复用	上下文（状态）的维护与共享
技术范畴	能力单元（What to do）	通信协议（How to share）
上下文管理	技能自主管理局部上下文	全局统一上下文树（JSON Schema约束）
通信效率	高（直接功能调用）	中（需协议解析开销）
扩展性	⭐⭐⭐⭐（动态加载）	⭐⭐（需协议升级）
调试难度	低（独立测试Skills）	高（需追踪跨模型状态流）
典型实现	LangChain Tools, OpenAI Functions	DSPy, Model Coordination Frameworks

应用场景选择指南
优先选择Agent Skills当：

需求快速迭代：
- 例如：客户服务Bot需每周新增业务技能
异构能力整合：
- 例如：结合CV模型（图像识别）+ NLP模型（报告生成）
开放域问题：
- 例如：研究助手需动态调用论文检索、公式计算等工具

优先选择MCP当：

复杂状态维护：
- 例如：医疗诊断需保持患者病史、检查结果等多模型共享状态
严格流程控制：
- 例如：金融合规审核需要顺序调用KYC、风控、法务模型
跨组织协作：
- 例如：供应链中多家企业的模型需安全共享订单状态

四、Skill创建与使用实战

4.1 创建流程（以LangChain为例）

from langchain.agents import Tool
from langchain.utilities import GoogleSearchAPIWrapper

# 1. 定义技能函数
def market_research(company: str) -> str:
    search = GoogleSearchAPIWrapper()
    return search.run(f"{company} 最新市场动态 2023 site:news.baidu.com")

# 2. 封装为Skill
market_skill = Tool(
    name="MarketResearch",
    func=market_research,
    description="用于获取公司最新市场动态"
)

# 3. 注册到Agent
from langchain.agents import initialize_agent
agent = initialize_agent([market_skill], llm, agent="zero-shot-react-description")

4.2 高级调试技巧
技能性能分析器：

def skill_profiler(skill_func):
    @functools.wraps(skill_func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = skill_func(*args, **kwargs)
        elapsed = (time.perf_counter() - start) * 1000
        logger.info(f"Skill {skill_func.__name__} executed in {elapsed:.2f}ms")
        return result
    return wrapper

4.3 技能商店实现

class SkillStore:
    def __init__(self):
        self.skills = {}
        self.skill_embeddings = {}
    
    def add_skill(self, skill: dict):
        self.skills[skill['name']] = skill
        self.skill_embeddings[skill['name']] = get_embeddings(skill['description'])
    
    def search_skills(self, query: str, top_n=3):
        query_embedding = get_embeddings(query)
        similarities = {
            name: cosine_sim(query_embedding, emb)
            for name, emb in self.skill_embeddings.items()
        }
        return sorted(similarities.items(), key=lambda x: x, reverse=True)[:top_n]

6.A2A（Agent-to-Agent）

核心思想：
Agent 之间不通过“控制器”中转，而是直接发送消息、请求、反馈，实现“点对点”协作。

特点分析

特性	说明
通信方式	直接消息传递（如 HTTP、WebSocket）
协作模式	无需中心协调，支持去中心化
优势	✅ 响应快 ✅ 适合实时协作 ✅ 支持跨组织协作
劣势	❌ 协调困难 ❌ 易产生冲突 ❌ 安全风险高

适用场景

场景	说明
协同决策	如“多个部门共同制定预算”
信息共享	如“市场部与技术部实时共享用户反馈”
跨系统对账	如“财务系统与税务系统自动核对数据”

实现方式

使用 REST API 或 WebSocket 实现 Agent 间通信
使用 JSON Schema 定义消息结构
加入 身份认证 与 权限控制

代表框架：FastAPI + WebSocket、gRPC、NATS

八、主流框架对比

框架	优势	适用场景
LangChain	生态丰富，工具多，支持RAG	通用AI系统
LlamaIndex	专攻知识库构建，支持复杂查询	RAG核心
AutoGen	支持多Agent协作，可视化强	复杂流程自动化
CrewAI	任务编排清晰，适合团队协作	项目制AI应用
Semantic Kernel	微软出品，与.NET生态融合	企业级应用
Dify	低代码平台，适合快速构建	快速验证与Demo
LangGraph	基于LangChain扩展，专为构建有状态、可循环、可回溯的图状AI工作流设计，支持复杂控制流	需要状态管理、条件分支、循环执行的复杂AI流程（如审批流、动态规划、错误恢复）
Flowise	可视化AI工作流构建平台，支持拖拽式编排，集成多种LLM与工具	快速原型开发、教育场景、非程序员参与AI系统设计
AgentScope	面向Agent系统的轻量级框架，支持多Agent通信、角色定义与任务调度，强调可扩展性	多Agent协作研究、智能体系统实验、分布式AI任务调度
Haystack	由Deepset开发，专注于信息检索与问答系统，支持高性能向量数据库与多语言处理	企业级搜索系统、智能客服、知识库问答平台
Spring AI	Java生态整合，适合企业系统	与Spring集成
JBoltAI	国产框架，支持中文场景	国内企业落地
Spring AI Alibaba	阿里巴巴出品，深度集成阿里云AI服务与生态，支持Spring生态无缝接入，具备国产化与信创适配能力	企业级AI系统，尤其适用于使用阿里云技术栈的组织
Apache RocketMQ AI	基于消息中间件的AI流水线架构，支持异步、解耦、高吞吐的AI任务调度，具备容错与重试机制，适用于大规模AI工作流编排	需要高并发、高可靠、分布式AI任务处理的场景，如日志分析、实时推荐、批量生成

1. LangChain

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnablePassthrough

# 初始化 LLM
llm = ChatOpenAI(model="gpt-4-turbo", temperature=0.7)

# 构建提示模板
prompt = ChatPromptTemplate.from_template(
    "请根据以下信息回答问题：{context}\n\n问题：{question}"
)

# 构建 RAG 链
rag_chain = (
    {"context": RunnablePassthrough(), "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

# 执行
result = rag_chain.invoke("请解释‘违约金’条款。")
print(result)

适用场景：通用问答、知识库检索、工具调用
推荐指数：⭐⭐⭐⭐☆

2. LlamaIndex

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.core.node_parser import SentenceSplitter

# 读取文档
documents = SimpleDirectoryReader("./docs").load_data()

# 分块
parser = SentenceSplitter(chunk_size=512)
nodes = parser.get_nodes_from_documents(documents)

# 构建索引
index = VectorStoreIndex(nodes)

# 查询
query_engine = index.as_query_engine()
response = query_engine.query("合同中关于违约金的条款是什么？")
print(response)

优势：支持复杂查询、多层索引、结构化检索
推荐指数：⭐⭐⭐⭐⭐

3. AutoGen

from autogen import Agent, GroupChat, GroupChatManager

# 定义角色
analyst = Agent(
    name="Analyst",
    system_message="负责分析数据，输出结论。",
    llm_config={"config": {"model": "gpt-4-turbo"}}
)

reviewer = Agent(
    name="Reviewer",
    system_message="负责审核分析结果，提出修改意见。",
    llm_config={"config": {"model": "gpt-4-turbo"}}
)

executor = Agent(
    name="Executor",
    system_message="负责执行操作，如写文件。",
    llm_config={"config": {"model": "gpt-4-turbo"}}
)

# 创建群组
group_chat = GroupChat(agents=[analyst, reviewer, executor], messages=[], max_round=10)
manager = GroupChatManager(groupchat=group_chat)

# 启动协作
manager.initiate_chat(
    message="请分析2024年Q3销售数据，并生成报告。",
    clear_history=True
)

适用场景：审批流程、跨系统自动化
推荐指数：⭐⭐⭐⭐☆

4. CrewAI

from crewai import Agent, Task, Crew

# 定义角色
researcher = Agent(
    role="市场分析师",
    goal="分析目标市场趋势",
    backstory="你是一位资深市场分析师，擅长数据挖掘。",
    verbose=True
)

writer = Agent(
    role="报告撰写人",
    goal="撰写市场分析报告",
    backstory="你擅长将复杂数据转化为清晰报告。",
    verbose=True
)

# 定义任务
task1 = Task(
    description="研究中国新能源汽车市场趋势。",
    expected_output="一份包含市场规模、增长率、主要玩家的分析。",
    agent=researcher
)

task2 = Task(
    description="根据研究结果撰写报告。",
    expected_output="一份结构清晰、语言流畅的市场分析报告。",
    agent=writer
)

# 创建 Crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[task1, task2],
    verbose=2
)

# 执行
result = crew.kickoff()
print(result)

适用场景：项目制 AI 应用、团队协作
推荐指数：⭐⭐⭐⭐

5. LangGraph

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated, List
import operator

# 定义状态
class AgentState(TypedDict):
    task: str
    plan: List[str]
    current_step: int
    status: str  # success / failed / pending
    result: str

# 节点函数
def model_node(state: AgentState):
    plan = [
        "查询合同第5.2条",
        "提取违约金金额",
        "生成回答"
    ]
    return {"plan": plan, "current_step": 0, "status": "pending"}

def controller_node(state: AgentState):
    if state["current_step"] >= len(state["plan"]):
        return {"status": "success", "result": "已完成"}
    else:
        return {"status": "executing", "current_step": state["current_step"] + 1}

def performer_node(state: AgentState):
    step = state["plan"][state["current_step"] - 1]
    # 模拟执行
    result = f"执行了：{step}"
    return {"result": result}

# 构建图
builder = StateGraph(AgentState)
builder.add_node("model", model_node)
builder.add_node("controller", controller_node)
builder.add_node("performer", performer_node)

builder.add_edge("model", "controller")
builder.add_edge("controller", "performer")
builder.add_conditional_edges("performer", lambda x: "END" if x["status"] == "success" else "controller")

graph = builder.compile()

# 执行
result = graph.invoke({"task": "查找违约金条款"})
print(result)

适用场景：审批流、动态规划、错误恢复
推荐指数：⭐⭐⭐⭐⭐

6. Spring AI Alibaba

// Spring Boot 配置
@ConditionalOnMissingBean
public SpringAIProperties springAIProperties() {
    SpringAIProperties props = new SpringAIProperties();
    props.setProvider("aliyun");
    props.setApiKey("your-aliyun-api-key");
    props.setModel("qwen-max");
    return props;
}

// 使用 AI
@Service
public class ContractService {
    @Autowired
    private AiService aiService;

    public String analyzeClause(String clause) {
        return aiService.call("请分析以下合同条款的风险点：" + clause);
    }
}

适用场景：政府、金融、国企等信创项目
推荐指数：⭐⭐⭐⭐⭐

7. Apache RocketMQ AI

from rocketmq import Producer, Message

# 创建生产者
producer = Producer("AI-Task-Group")
producer.set_namesrv_addr("127.0.0.1:9876")
producer.start()

# 发送任务
msg = Message("AI-Task-Topic")
msg.set_body(b'{"task": "generate_report", "params": {"year": 2024}}')
send_result = producer.send_sync(msg)

print(f"任务已发送：{send_result}")

适用场景：批量生成、日志分析、实时推荐
推荐指数：⭐⭐⭐⭐

九、企业级选型建议

场景	推荐组合	理由
通用 AI 系统	`LangChain + LangGraph`	基础框架 + 状态管理
RAG 核心系统	`LlamaIndex + LangChain`	知识库构建 + 任务执行
复杂流程自动化	`AutoGen` 或 `LangGraph`	支持状态、循环、条件
项目制 AI 应用	`CrewAI`	任务编排清晰
企业级系统（.NET）	`Semantic Kernel`	与 .NET 深度集成
低代码快速验证	`Dify` 或 `Flowise`	无需代码，快速上线
大规模 AI 工作流	`Apache RocketMQ AI`	异步、高吞吐、容错
信创项目	`Spring AI Alibaba`	阿里云原生，国产化适配
国内企业落地	`JBoltAI`	中文优化，国产化

四、系统集成与工程化层

核心目标：实现可运维、可监控、可扩展的AI系统

技术	说明	工具
Streamlit	快速构建AI应用可视化界面	`Streamlit` + `LangChain` + `RAG`
推理优化	`ONNX`、`TensorRT`、`FP16/INT8量化`	`ONNX Runtime`
可观测性	Prometheus + Grafana监控，OpenTelemetry追踪	`Prometheus`、`Grafana`、`OpenTelemetry`
分布式训练	多GPU/多节点训练，`DeepSpeed`、`FSDP`	`DeepSpeed`、`PyTorch FSDP`

1.可视化界面

核心思想：
AI 不应是“工程师的玩具”，而应是“全员可用的生产力工具”。
Streamlit 以其极简语法，成为构建 AI 应用前端的“首选武器”。

技术实现路径

# app.py
import streamlit as st
from langchain.chains import RetrievalQA
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_openai import ChatOpenAI

# 页面标题
st.title("🚀 智能合同问答系统")

# 初始化模型与向量库
@st.cache_resource
def load_chain():
    embeddings = HuggingFaceEmbeddings(model_name="BAAI/bge-small-zh")
    db = Chroma(persist_directory="./chroma_db", embedding_function=embeddings)
    retriever = db.as_retriever(search_kwargs={"k": 3})
    llm = ChatOpenAI(model="gpt-4-turbo", temperature=0.3)
    return RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever)

# 加载 QA 链
qa_chain = load_chain()

# 输入框
question = st.text_input("请输入您的问题：")

# 执行问答
if question:
    with st.spinner("正在检索答案..."):
        response = qa_chain.invoke({"query": question})
        st.write("💡 **回答**：")
        st.markdown(response["result"])

部署方式

# 启动 Streamlit 应用
streamlit run app.py --server.port=8501

优势：

5 行代码起步，无需前端知识

支持文本、图表、文件上传

可直接部署为 Web 服务

企业级建议：

集成 身份认证（如 OAuth2）

添加 操作日志 与 使用统计

与 企业微信/钉钉 对接

2.推理优化

核心思想：
大模型推理成本高，必须通过量化、剪枝、加速库等手段，实现“性能提升、资源节省、延迟降低”。

优化技术对比

技术	说明	工具
FP16/INT8 量化	降低精度，减少显存占用	`ONNX Runtime`、`TensorRT`
模型剪枝	移除冗余参数	`HuggingFace Transformers`
知识蒸馏	用大模型教小模型	`DistilBERT`、`TinyBERT`
推理引擎加速	专用加速库	`TensorRT`、`OpenVINO`

实现示例（ONNX Runtime + FP16）

import onnxruntime as ort
import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification

# 1. 加载模型与分词器
model_name = "bert-base-chinese"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# 2. 转换为 ONNX
dummy_input = tokenizer("测试文本", return_tensors="pt")
torch.onnx.export(
    model,
    dummy_input["input_ids"],
    "bert_chinese.onnx",
    input_names=["input_ids"],
    output_names=["logits"],
    dynamic_axes={"input_ids": {0: "batch", 1: "sequence"}},
    opset_version=13,
    do_constant_folding=True,
    use_external_data_format=False,
)

# 3. 使用 ONNX Runtime 推理
session = ort.InferenceSession("bert_chinese.onnx", providers=["CUDAExecutionProvider"])
inputs = tokenizer("这是一条负面评论", return_tensors="pt").to("cuda")
outputs = session.run(None, {
    "input_ids": inputs["input_ids"].cpu().numpy()
})
print("推理结果：", outputs)

企业级建议：

对核心模型进行量化部署

使用 模型版本管理（如 MLflow）

建立 A/B 测试机制

3.可观测性

核心思想：
生产系统必须“可监控、可追踪、可告警”，否则“黑盒运行”极易导致故障。

三件套：Prometheus + Grafana + OpenTelemetry

Prometheus：指标采集

# prometheus.yml
scrape_configs:
  - job_name: 'ai-service'
    static_configs:
      - targets: ['ai-qa-service:8000']

Grafana：可视化面板

添加 Prometheus 数据源
创建仪表盘：
- 请求成功率
- 平均响应时间
- 每日调用量
- 错误码分布

OpenTelemetry：链路追踪

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter

# 初始化追踪
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)

# 开始追踪
with tracer.start_as_current_span("ask_question") as span:
    span.set_attribute("question", "违约金怎么算？")
    response = qa_chain.invoke({"query": "违约金怎么算？"})
    span.set_attribute("answer", response["result"])
    span.set_status(1)  # 1 = OK

4.分布式训练

核心思想：
单卡无法训练大模型，必须使用多 GPU / 多节点分布式训练，而 DeepSpeed 与 FSDP 是当前主流方案。

技术对比

方案	说明	适用场景
DeepSpeed	微软出品，支持 ZeRO、FSDP、混合精度	大规模模型训练
FSDP	PyTorch 原生，轻量级，易集成	中等规模训练
Data Parallelism	多卡并行，简单但显存占用高	小模型

实现示例（DeepSpeed + ZeRO-3）

# deepspeed_config.json
{
  "train_batch_size": 16,
  "gradient_accumulation_steps": 4,
  "zero_optimization": {
    "stage": 3,
    "offload_optimizer": {
      "device": "cpu"
    },
    "offload_param": {
      "device": "cpu"
    }
  },
  "fp16": {
    "enabled": true
  },
  "bf16": {
    "enabled": false
  }
}

# train.py
import torch
from deepspeed import init_inference, get_inference_config
from transformers import AutoModelForSequenceClassification

# 加载模型
model = AutoModelForSequenceClassification.from_pretrained("bert-base-chinese", num_labels=2)

# 初始化 DeepSpeed
model = init_inference(model, config_path="deepspeed_config.json")

# 推理
with torch.no_grad():
    inputs = tokenizer("测试文本", return_tensors="pt").to("cuda")
    outputs = model(**inputs)
    print(outputs.logits)

2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

Langchain4j框架入门

2048 AI社区

每日 AI 研究简报 · 2026-05-16

Cerebras 上市首日市值突破千亿美元，AI 芯片格局再添变数；Intercom 更名 Fin 推出「管理 Agent 的 Agent」；Anthropic 将战场从模型转向 Agent 控制平面——2026 年的 AI 竞争正在从「谁的模型更强」转向「谁的 Agent 生态更完整」。

2048 AI社区

以后工程师的价值看会不会省token？用文言文更省token？文科生的AI暴论给我看笑了

2048 AI社区

所有评论(0)

查看更多评论

fids

@weixin_45130169

已为社区贡献1条内容

大模型系统开发能力体系

fids

大模型系统开发能力体系

一、底层认知层：数理、编程与AI演进逻辑

机器学习基础知识

张量

梯度

链式法则

概率分布

大型语言模型核心参数详解

一、基础处理参数

二、生成控制参数

三、长度控制参数

四、高级控制参数

五、参数组合策略

主流模型演进

1. CNN（卷积神经网络）

2. RNN / LSTM

**3. Transformer **

4. Mamba

5. GPT

6. BERT

**7. T5 **

二、RAG（检索增强生成）

RAG完整流程图（企业级落地标准流程）：

1. 文本处理

1. 文档解析

2. 文本清洗

3. 句子拆分

4. 分块策略

2. 标注（Annotation）

1. 人工标注

2. 半自动标注

3. 自动标注

4. 自我标注

3. Embedding模型选择

4. 向量存储与召回

一. 向量数据库深度对比

二、召回策略

三、多路召回架构设计

四、Query 改写与扩展

五、递归 RAG（Recursive RAG）

六、企业级 RAG 回召评估指标

5. 重排序（Rerank）

一、重排序的核心目标与价值

二、主流重排序工具深度对比

三、各模型详解与选型建议

1. BGE-Reranker

2. Cohere Rerank

3. CrossEncoder（Hugging Face）

4. BAAI-rerank（BAAI）

5. T5-Rerank（Google）

四、常见问题与解决方案

6. RAG增强形态

一、自我 RAG（Self-RAG）

二、图 RAG（Graph RAG）

三、多模态 RAG

四、动态 RAG（Dynamic RAG）

7.promote工程

一、Prompt 工程六大核心维度

二、Prompt 设计黄金法则（含代码示例）

1. 角色 + 任务 + 上下文：构建“完整指令”

2. 格式化输出控制

3. Few-Shot 示例引导

4. 约束与边界控制

5. 思维链（Chain-of-Thought, CoT）

6. 多轮对话上下文管理

三、专业提示词结构框架

1. CRISE框架

2. BROKE框架

3. ICIO框架

四、企业级Prompt模板库

1. 合同审查与法律分析（CRISE框架）

2. 财务报告分析（BROKE框架）

3. 上市公司财报分析

4. 业务办理引导

三、Agent与智能体层

一、规划（Plan）

二、工具（Tools）

三、LLM 核心

3. Transformer

7. T5