RAG 高级技术与调优实战手册

RAG实战调优指南:从文档切分到Agentic RAG的全链路避坑手册 RAG(检索增强生成)是一种将外部知识库与大语言模型结合的关键技术,其核心在于通过精准检索约束生成过程,避免幻觉并提升事实准确性。然而,实际落地中90%的问题并非源于大模型本身,而是检索环节的语义断裂、领域适配不足与业务规则缺失。本文围绕文档预处理、多路检索增强、重排序优化、生成可控性及真实业务评估五大维度,系统拆解法律、医疗、工业等场景下的典型失败模式与可复用解决方案。重点涵盖语义块切分、HyDE锚点检索、领域专用reranker训练、证据链验证机制及四维业务评估矩阵,强调RAG不是‘加个向量库就完事’, 阅读详情

今天不聊概念定义,直接聊怎么在落地场景里把这套系统调好:知识库处理、高级召回、排序优化,再加一嘴 GraphRAG。

坚实地基——知识库处理

RAG 的上限,不取决于你用什么大模型,而取决于你的知识库管理得怎么样。下面四个场景,建议按序号一个一个过。

场景 1:知识库问题生成与检索优化

先看一个典型问题。

你有一个知识库里存了关于上海迪士尼的各种信息,其中一篇写到"上海迪士尼乐园位于上海市浦东新区,2016年6月16日开园,乐园占地面积390公顷,包含七大主题园区"。

用户问了一个问题:“如果我想体验最刺激的过山车,应该去哪个区域?”

你的知识库里相关的片段写的是"探险岛有XX过山车项目",但"过山车"和"最刺激"这两个词,在向量空间里其实隔了十万八千里——纯语义匹配的话,根本对不上。

这就是 RAG 召回最头疼的问题:用户表达方式和知识表述方式之间的鸿沟。

怎么解决?我一般从两个方向入手,我管它叫双向奔赴。

正向:Doc-to-Query——给每个知识切片生成可能的问题

思路很简单:你的知识库里有一段文本,它的特征是一堆向量。用户问问题时,也是把问题变成一堆向量。两边向量长得像,就觉得"这个相关"。

但问题是——你的知识切片可能写的是"上海迪士尼乐园位于上海市浦东新区,是中国大陆首座迪士尼主题乐园,于2016年6月16日开园",用户的提问可能是"中国大陆的第一座迪士尼在哪?"这两句话在语义上有重叠,但关键词的重叠度非常低。

所以一种很直接的优化思路是:提前为每个知识切片生成可能被问到的各种问题,然后把这些问题也一并做向量化。 检索的时候,用户的问题跟这些生成的问题去匹配,而不是直接跟原文匹配。

具体怎么做?上代码。

def generate_questions_for_chunk(knowledge_chunk, num_questions=5):    """为单个知识切片生成多样化问题"""    instruction = """    你是一个专业的问答系统专家。给定的知识内容能回答哪些多样化的问题,    这些问题可以:    1. 使用不同的问法(直接问、间接问、对比问等)    2. 避免重复和相似的问题    3. 确保问题不超出知识内容范围    请返回JSON格式:    {      "questions": [        {          "question": "问题内容",          "question_type": "问题类型(直接问/间接问/对比问/条件问等)",          "difficulty": "难度等级(简单/中等/困难)"        }      ]    }    """    prompt = f"### 指令###\n{instruction}\n### 知识内容###\n{knowledge_chunk}\n### 生成问题数量###\n{num_questions}"    response = get_completion(prompt, model)    return parse_json_response(response)

比如我们拿一段迪士尼的文本跑一下:

知识内容: 上海迪士尼乐园位于上海市浦东新区,是中国大陆首座迪士尼主题乐园,于2016年6月16日开园。乐园占地面积390公顷,包含七大主题园区:米奇大街、奇想花园、探险岛、宝藏湾、明日世界、梦幻世界和迪士尼小镇。

生成的 5 个问题:

问题类型难度
1上海迪士尼乐园是什么时候开园的?直接问简单
2中国大陆第一座迪士尼乐园在哪里?间接问简单
3与美国、日本等地的迪士尼相比,上海迪士尼有什么特别之处?对比问中等
4如果想游览上海迪士尼的所有主题园区,需要了解哪些区域?条件问中等
5上海迪士尼乐园占地多少公顷?直接问简单

看到没?同样一段原文,生成了五种不同类型的问法。有直接问时间的、有间接问地点的、有对比类的问题、有条件类的问题。

如果想让问题更丰富,可以用 generate_diverse_questions() 生成 8 个更精细的问题——要求问题带提问角度和是否可回答的标注:

def generate_diverse_questions(self, knowledge_chunk, num_questions=8):    """生成更多样化的问题(更丰富)"""    instruction = """    你是一个专业的问答系统专家。请为给定的知识内容生成高度多样化的问题:    1. 问题类型多样化:直接问、间接问、对比问、条件问、假设问、推理问等    2. 表达方式多样化:使用不同的句式、词汇、语气    3. 难度层次多样化:简单、中等、困难的问题都要有    4. 角度多样化:从不同角度和维度提问    5. 确保问题不超出知识内容范围    请返回JSON格式,额外包含perspective和is_answerable字段    """

同样的迪士尼文本用这个版本跑出来前几个问题就是这样的:

  1. “上海迪士尼乐园是在哪一年开园的?”(直接问,简单,时间信息角度,可回答)
  2. “如果一个人想在上海体验迪士尼主题乐园,他应该去哪里?”(间接问,简单,地理位置角度,可回答)
  3. “上海迪士尼和香港迪士尼相比,哪个是中国大陆首座迪士尼主题乐园?”(对比问,中等,地域比较角度,可回答)
  4. “假如你计划去上海迪士尼游玩,你会选择哪个主题园区来体验探险氛围?”(假设问,中等,游客体验角度,可回答)

这里有一个关键细节: 生成的问题不能超出原文的内容范围。你看第 3 问"跟香港迪士尼相比"——这段原文其实并没有香港迪士尼的信息,但问题问的是"哪个是中国大陆首座",原文确实说了"是中国大陆首座迪士尼主题乐园",所以这个问题的答案就在原文里。这是可回答的。

如果你让 LLM 生成了 5 个问法基本一样的问题(“迪士尼什么时候开的”、“迪士尼哪年开的”、“迪士尼开园时间是几几年”),说明 prompt 里对多样性的约束不够。一定要要求不同类型的问法。

问题的去向:跟原文一起做 embedding

生成的问题是放在哪里的?很多人以为问题是单独存一个字段或者放到元数据里。其实不是。

我把问题和原文拼在一起,形成一个新的 chunk,再对这个 chunk 做 embedding 存到向量库里。

# 原始 chunkoriginal = "上海迪士尼乐园位于上海市浦东新区..."# 生成的 5 个问题questions = [    "上海迪士尼乐园是什么时候开园的?",    "中国大陆第一座迪士尼乐园在哪里?",    ...]# 拼接后:augmented_chunk = original + "\n" + "\n".join(questions)# → "上海迪士尼乐园位于上海市浦东新区...上海迪士尼乐园是什么时候开园的?..."# 对这个 augmented_chunk 做 embedding(1024维)embedding = embedding_model.encode(augmented_chunk)# 存入向量库

这样做的逻辑是:你存的不是"原文的特征",而是"原文 + 它可能被怎么问"的特征。用户的问题来的时候,它的特征跟这个"丰富过的特征"去匹配,匹配精度就会更高。

提取时的逻辑是这样的——不管你是匹配到原文,还是匹配到生成的问题,最终返回的永远是原始的知识内容。因为 embedding 只是一个帮你做特征提取和计算的工具,它帮你找"谁跟谁更像",但最终要送到大模型里的、要展示给用户的,是那个原始的文本。embedding 只是替你做筛选的。

反向:Query-to-Doc——改写用户的提问

双向奔赴的另一端,是改用户的问题。

用户问"如何提高深度学习模型的训练效率",这个提问本身可能跟你的知识库里的"分布式训练"、"混合精度训练"这些知识对不上——因为用户没提到这些具体术语。

这时候可以让大模型帮你做一次意图扩展:

用户问:如何提高深度学习模型的训练效率大模型扩展后:可以从以下几个角度回答:1. 优化算法2. 混合精度训练3. 分布式训练4. 数据增强...

把扩展后的内容也拿去检索。实际上这就是很多大模型的"深度思考"模式在做的事——先想一下"我这个提问可以拆成哪些方面",再针对每个方面去检索。

不过我个人的经验是:一般我不会单独写一个 prompt 来做 query 改写。 现在的大模型基本都支持深度思考模式,开启这个模式它天然就会帮你做意图扩展,不需要你额外写逻辑。

评估:两种检索方式的差异到底多大

光说理论不行,我们直接看数据。

我拿一个迪士尼问答场景做了三组测试查询,分别跑 BM25 原文检索和 BM25 问题检索(对生成的问题建索引):

测试查询原文检索分数原文是否命中问题检索分数问题是否命中
如果我想体验最刺激的过山车,应该去哪个区域?0.155✗1.000✓
可以带食物进去吗?0.153✓0.556✓
什么时间去人比较少?0.168✓0.279✓

**原文检索准确率:66.7%(3中2)**问题检索准确率:100.0%(3中3)

从三分之二到全对——区别就只是你花那十几分钟去生成了一批问题。

不过你也看到了,问题检索虽然全中了,但第二题的分数差异很大(0.556 vs 1.000),第三题的分数增量也不明显。所以我的建议是:两个索引都建,结果做融合。 后面讲到高级召回的时候,我会细说 RRF 和加权混合的方法。

还有一个重要的细节你一定要注意:确保生成的问题足够多样化。 如果你生成的 5 个问题都是"迪士尼开园时间"、“迪士尼哪年开的”、"迪士尼什么时候开的"这种同一个角度的变体——那它们测的是同一个维度,约等于只做了一次检索。问题的多样性 = 召回的覆盖面。

关键是要覆盖:直接问、间接问、条件问、假设问、推理问。每个问题要有不同的提问角度。

再说个实用的策略:Small-to-Big

上面说的是"给原文生成问题"来丰富特征。还有一个我特别喜欢用的策略叫 Small-to-Big。

简单说就是:如果你的文档特别长、特别碎,不要直接拿原文去做检索。先把原文生成一个摘要(small),放到一个向量库。用户来提问时,先用 small 做一轮粗筛。如果 small 表明这篇文档跟用户问题相关,再把完整的原文(big)取出来拼到 prompt 里。

用户提问    ↓Step 1: 检索 small(摘要/标题)——快速过一遍    ↓Step 2: 如果 small 匹配 → 找到对应的 big(原文)    ↓Step 3: 把 big 放入 prompt → LLM 生成回答

这个跟直接检索的差别在哪?直接检索是"在细节的海洋里找准确的信息",Small-to-Big 是"先定位到正确的岛屿,再在岛上找细节"。

你看 NotebookLM 这个工具。它在检索之前帮你做了大量的预处理:每段原文都生成了摘要。你去提一个问题,它先匹配摘要,再用摘要定位到具体的原文段落。它做得很自然,你甚至感觉不到这个环节的存在,但这个预处理就是它效果好最核心的原因之一。

场景 2:对话知识沉淀

产品上线后每天产生大量对话。这些对话里埋着金子。

但大部分团队的做法是什么都不做。对话就躺在数据库里,直到被清理。

核心流程:

def extract_knowledge_from_conversation(conversation):    """从单次对话中提取结构化知识"""    instruction = """    你是一个专业的知识提取专家。请从给定的对话中提取有价值的知识点:    1. 事实性信息(地点、时间、价格、规则等)    2. 用户需求和偏好    3. 常见问题和解答    4. 操作流程和步骤    5. 注意事项和提醒    请返回JSON格式:    {      "extracted_knowledge": [        {          "knowledge_type": "事实/需求/问题/流程/注意",          "content": "知识内容",          "confidence": 置信度(0-1),          "source": "来源(用户/AI/对话)",          "keywords": ["关键词1", "关键词2"],          "category": "分类"        }      ],      "conversation_summary": "对话摘要",      "user_intent": "用户意图"    }    """    response = get_completion(prompt, model)    return parse_json_response(response)

提取出五类知识:

  • 事实:价格、规则、参数等稳定信息
  • 需求:用户当下想要什么(临时性,需过滤)
  • 问题:用户怎么问的(临时性,需过滤)
  • 流程:操作步骤、方法论
  • 注意:提醒、风险、边界条件

关键过滤:需求和问题类型是临时性、个性化的,不应入库。只保留事实、流程、注意三类。

# 过滤掉临时性的知识和问题filtered_knowledge = [    k for k in knowledge_list    if k.get('knowledge_type') not in ['需求', '问题']]

智能合并:一次性可能从多条对话中提取相似知识。用 LLM 做合并比用规则好得多:

def merge_knowledge_with_llm(knowledge_group, knowledge_type):    prompt = f"""    你是一个专业的知识整理专家。请将以下{knowledge_type}类型的知识点进行智能合并:    合并要求:    1. 保留所有重要信息,避免信息丢失    2. 消除重复内容,整合相似表述    3. 提高内容的准确性和完整性    4. 合并后的置信度取所有知识点中的最高值    ### 待合并的知识点:    {chr(10).join(knowledge_contents)}    """    return get_completion(prompt, model)

一个真实运行的例子——3 条对话,提取了 22 个知识点,过滤后剩 17 个,合并后压缩到3 个综合知识点。合并率 86%,信息完整度接近 100%。

在实操中,这个 pipeline 应该跑在定时任务里——每天凌晨处理前一天的对话,把新知识增量写入。不是"想起来跑一次",是基础设施级别的运维操作。

场景 3:知识库健康度检查

你的知识库三个月前建的,现在还好吗?

答案通常是:不好。

健康度检查从三个维度切入:完整性、时效性、一致性。

完整性检查(查缺失):

用测试查询去问知识库,看它能不能答上来。具体做法:准备一批(>30 条)典型的用户问题,逐一检索知识库,让 LLM 判断库里是否有匹配的知识。

def check_completeness(knowledge_text, test_queries):    instruction = """    你是一个知识库完整性检查专家。请分析给定的测试查询和知识库内容,    判断知识库中是否缺少相关的知识。    检查标准:    1. 查询是否能在知识库中找到相关答案    2. 知识是否完整、准确    3. 是否存在知识空白    返回JSON格式,包含missing_knowledge列表和coverage_score(0-1)    """    # 输出示例:    # coverage_score: 0.75    # missing_knowledge: [{query: "...", missing_aspect: "...", importance: "高"}]

时效性检查(查过期):

价格信息、政策规则、技术版本——这三种知识过期速度惊人。用 LLM 逐项扫描:

  1. 时间相关信息是否过期(年份、日期、时间范围)
  2. 价格信息是否最新(价格、费用、票价)
  3. 政策规则是否更新
  4. 技术信息是否过时(版本、技术标准)
def check_freshness(knowledge_text, current_time):    instruction = """    你是一个知识时效性检查专家。    检查标准:    1. 时间相关信息是否过期    2. 价格信息是否最新    3. 政策规则是否更新    4. 技术信息是否过时    """    prompt += f"### 当前时间###\n{current_time}\n### 分析结果###"

过期的知识比没有知识更可怕——它让你误以为系统是对的。

一致性检查(查冲突):

同一份产品参数,A 文档写 100 元,B 文档写 120 元。两个都在库里。用户问价钱,模型随机选一个回答——选对的概率是 50%。

def check_consistency(knowledge_text):    """    检查同一主题的多篇文档是否存在矛盾信息。    检查标准:    1. 价格信息的差异    2. 规则政策的冲突    3. 时间信息的不一致    4. 操作流程的差异    """

健康度检测不是一次性的。查一次没意义,关键是建立巡检节奏——每周跑一次,结果挂看板。最好有个自动化 Pipeline:检测到异常 → 自动生成问题清单 → 通知运营人员处理。

场景 4:知识库版本管理与性能比较

你的知识库改了一版,你怎么知道改了是好是坏?没法回滚的 RAG,就像没有 Git 的代码库。

版本管理应该包含什么?

class KnowledgeBaseVersionManager:    def__init__(self):        self.versions = {}  # version_name -> {metadata, chunks, index}        defcreate_version(self, name, description, chunks):        """保存知识库快照,构建向量索引"""        pass        defdetect_changes(self, kb1, kb2):        """版本差异检测——基于集合论"""        kb1_dict = {chunk['id']: chunk for chunk in kb1}        kb2_dict = {chunk['id']: chunk for chunk in kb2}                added_ids = set(kb2_dict.keys()) - set(kb1_dict.keys())  # 新增        removed_ids = set(kb1_dict.keys()) - set(kb2_dict.keys())  # 删除        common_ids = set(kb1_dict.keys()) & set(kb2_dict.keys())  # 共有                # 检测内容修改        modified_ids = [            cid for cid in common_ids            if kb1_dict[cid]['content'] != kb2_dict[cid]['content']        ]        return {"added": added_ids, "removed": removed_ids, "modified": modified_ids}        defevaluate_performance(self, version_name, test_queries):        """用标准测试集评估版本性能"""        correct = 0        total_time = 0        for query_info in test_queries:            start = datetime.now()            results = self.retrieve(version_name, query_info['query'], k=3)            elapsed = (datetime.now() - start).total_seconds()            total_time += elapsed            # 简单字符串匹配评估            if query_info['expected_answer'] in results:                correct += 1        return {            'accuracy': correct / len(test_queries),            'avg_response_time': total_time / len(test_queries)        }        defcompare_versions(self, v1_name, v2_name, test_queries):        """A/B 对比两个版本"""        perf1 = self.evaluate_performance(v1_name, test_queries)        perf2 = self.evaluate_performance(v2_name, test_queries)        return {            'accuracy_improvement': perf2['accuracy'] - perf1['accuracy'],            'time_delta': perf2['avg_response_time'] - perf1['avg_response_time'],            'recommendation': '推荐使用版本2'if perf2['accuracy'] > perf1['accuracy'] else'维持版本1'        }        defregression_test(self, version_name, test_cases):        """回归测试——确保版本更新不破坏原有功能"""        passed = sum(            1for tc in test_cases            ifself.evaluate_retrieval_quality(version_name, tc['query'], tc['expected'])        )        return {'pass_rate': passed / len(test_cases)}

一个实际跑过的对比结果:

指标版本1(v1.0,3个chunk)版本2(v2.0,5个chunk)变化
知识切片数35+2
平均切片长度36字符54字符+50%
检索准确率60.0%100.0%+40%
平均响应时间115.8ms120.2ms+4.4ms
回归测试通过率—100.0%—

版本 2 准确率提升 40%,响应时间几乎不变,回归测试全过。这种情况下,"推荐使用版本 2"是明确的。

版本之间怎么检索?FAISS + embedding:

def build_vector_index(chunks):    vectors = [get_text_embedding(c['content']) for c in chunks]    vectors = np.array(vectors).astype('float32')    ids = np.array([c['id'] for c in chunks]).astype('int64')        dim = vectors.shape[1]    text_index = faiss.IndexFlatL2(dim)  # L2距离    text_index.add_with_ids(vectors, ids)    return text_indexdefretrieve(query, index, metadata_store, k=3):    query_vec = get_text_embedding(query).astype('float32')    distances, indices = index.search(query_vec.reshape(1, -1), k)        results = []    for i, doc_id inenumerate(indices[0]):        results.append({            "id": doc_id,            "content": metadata_store[doc_id],            "similarity_score": 1.0 / (1.0 + distances[0][i])  # 距离转分数        })    return results

但说实话:版本管理这件事,实际项目中很少有人做。为什么?成本太高。你要保存快照、建索引、跑测试题、产报告。一次可能要几小时。

但生产环境到了规模——当你的知识库从几百篇膨胀到几万篇,每天有新增和修改,没有版本管理你连"哪里出了问题"都定位不出来。

一句话建议:至少做到两点——每次改知识前打个 snapshot,每次上线前跑一轮回归测试。就这两条,已经能挡住 80% 的翻车。


精准雷达——高级召回

知识库做好了,下一步就是怎么从里面找到最相关的知识。从"纯向量"到"混合检索+重排序",下面三个技术依次递进。

查询优化:MultiQuery 与改写

传统 RAG 的召回链路:用户提问 → 向量化 → 跟所有知识算相似度 → 取 top-K。

这个链路有一个根本问题:用户的提问方式跟你知识库里的表述方式,可能完全不一样。

“怎么退款"和"退货后的资金流向处理”——在向量空间里可能是两个方向。但它们是同一个意思。

MultiQuery 的思想极其简单:别拿用户原话去检索。先让 LLM 把问题改写/扩展成多个版本,分别检索,合并去重。

def multi_query_retrieve(query, kb_index, k=5, n_queries=4):    # Step 1: 改写    expansion_prompt = f"""    用户的问题是:{query}        请从不同角度生成{n_queries}个改写版本的问题,让它们覆盖    不同的表述方式和提问角度。直接返回改写后的问题列表。    """    rewritten_queries = get_completion(expansion_prompt, model="qwen")    # 通常会返回类似:    # 1. 客户经理投诉处罚细则?    # 2. 一次投诉扣几分?    # 3. 投诉处罚的量化标准是什么?    # 4. 扣分规则是什么?        # Step 2: 并行检索    all_results = []    for q in rewritten_queries + [query]:        results = vector_retrieve(q, kb_index, k=n_queries*2)        all_results.extend(results)        # Step 3: 去重合并打分    merged = {}    for doc in all_results:        if doc['id'] notin merged or doc['score'] > merged[doc['id']]['score']:            merged[doc['id']] = doc        returnsorted(merged.values(), key=lambda x: x['score'], reverse=True)[:k]

LangChain 之前内置了 MultiQueryRetriever,新版本做了简化去掉了,但逻辑是一样的。自己写一个 prompt 就能搞定——关键是改写时要多样化(不同句式、不同关键词、不同颗粒度),不是简单的同义替换。

代价是什么?一次改写 + N 次检索,接口调用翻了 N 倍。不过并发检索可以优化延时,收益(召回率提升 20-30%)通常远超成本。

混合检索:BM25 + Vector

这是大厂 RAG 项目的事实标配。不是 embedding 不好——但纯 embedding 有三个硬伤:

  1. 精确匹配不敏感——搜"第3条 第2款",向量检索大概率匹配到跟"3"和"2"相关的无关内容
  2. 低频术语衰竭——稀有术语的语义表征不够,容易被淹没
  3. 缺乏字面信号——某些场景下用户就是要精确关键词命中

BM25 恰好擅长这些。它不关心语义,只关心:关键词在文档里出现的频率 × 关键词在整个语料里的稀有度 ÷ 文档长度的归一化。

# BM25 的核心逻辑(简化):# score(D, Q) = Σ IDF(qi) × TF(qi, D) × (k1 + 1) / (TF(qi, D) + k1 × (1 - b + b × |D| / avgdl))# # 其中:# TF(qi, D) = 词qi在文档D中的出现频率# IDF(qi) = log((N - n(qi) + 0.5) / (n(qi) + 0.5))  —— 词越稀有,IDF越高# k1 = 1.2 ~ 2.0  —— 词频饱和参数# b = 0.75         —— 文档长度归一化参数# |D| = 文档长度# avgdl = 语料库平均文档长度

所以 BM25 打分规律:关键词越稀有、出现频率越高、文档越短 → 分数越高。

BM25 + Vector 混合——怎么混?

最常见的是 RRF(Reciprocal Rank Fusion)。

def rrf_merge(vector_scores, bm25_scores, k_rrf=60):    """    RRF: 两个排序列表融合成一个。    k_rrf 控制平滑度——越大,排名靠后的文档越难逆袭。    标准值:60    """    doc_scores = {}        for rank, (doc_id, _) in enumerate(vector_scores):        doc_scores[doc_id] = doc_scores.get(doc_id, 0) + 1.0 / (k_rrf + rank + 1)        for rank, (doc_id, _) in enumerate(bm25_scores):        doc_scores[doc_id] = doc_scores.get(doc_id, 0) + 1.0 / (k_rrf + rank + 1)        return sorted(doc_scores.items(), key=lambda x: -x[1])

RRF 的优势是不需要分数归一化——直接拿排名算分,两个模型各自输出 top-K,谁排得高谁权重大。

另一种更常见的做法是用权重混合:

def hybrid_weighted(query, vector_index, bm25_index, alpha=0.5, top_k=30):    """    alpha = 1.0 → 纯向量    alpha = 0.0 → 纯 BM25    alpha = 0.5 → 等权混合    """    vector_results = vector_index.search(query, top_k)    bm25_results = bm25_index.search(query, top_k)        # 分数归一化    vector_scores = normalize(vector_results.scores)    bm25_scores = normalize(bm25_results.scores)        combined = {}    for i, doc inenumerate(vector_results):        combined[doc.id] = combined.get(doc.id, 0) + alpha * vector_scores[i]    for i, doc inenumerate(bm25_results):        combined[doc.id] = combined.get(doc.id, 0) + (1 - alpha) * bm25_scores[i]        returnsorted(combined.items(), key=lambda x: -x[1])[:top_k]

调参建议:alpha 从 0.5 开始。如果你的领域偏精确检索(法律条文、政策条款),alpha 降到 0.3。如果偏语义相似(智能客服问答),alpha 升到 0.7。

初召的 K 设定也很关键——不要设太小。一般 30-50,给后面的 Rerank 留足候选。

精细排序:Rerank 模型

召回管饱了,但你从 30 个候选里怎么挑 top-3?

用向量相似度排?但向量的"相似"跟用户的"相关"很多时候不是一回事。向量相似度高 ≠ 对你的问题有用。

Rerank 模型(也叫 Cross-Encoder)跟向量检索(Bi-Encoder)的核心区别:

维度Bi-Encoder(向量检索)Cross-Encoder(Rerank)
计算方式问题和文档各自算 embedding问题和文档拼接过编码器
交互粒度粗,一次推理可对比百万级细,一次推理只算一对
速度快(毫秒级)慢(几十毫秒级)
精度中等高
适用阶段初召(海选)精排(top-N里排)

Rerank 把 query 和每个候选文档拼成一个序列穿进模型,做全连接交互计算——它能捕捉"这个文档对这个问题有多具体地有用"。

def rerank(query, candidate_docs, rerank_model, top_k=3):    """    对初召结果进行重排序。    候选通常 30-50 个,排到 top-3 到 top-5。    """    scores = []    for doc in candidate_docs:        # 拼接 query 和文档内容        pair_text = f"[CLS] {query} [SEP] {doc['content']} [SEP]"        score = rerank_model.predict(pair_text)  # 相关性分数        scores.append((doc, score))        # 按分数降序    return sorted(scores, key=lambda x: x[1], reverse=True)[:top_k]

完整的召回链路应该是这样:

用户问题    ↓Step 1: BM25 + Vector 混合初召(召 30-50 个)    ↓Step 2: Rerank 精排(排到 top-3 到 top-5)    ↓Step 3: 拼入 prompt → LLM 生成回答

前沿探索——GraphRAG

以上所有技术都建立在"向量 + 关键词"的检索框架上。但如果你遇到的问题是多跳推理(比如"迪士尼的票价体系为什么有淡旺季差异"),本质上是需要理解知识之间的逻辑关系。

这时候就是 GraphRAG 的舞台了,简单说两句。

GraphRAG 做的不是检索,是关系理解。它先把文档里的实体和关系抽出来构建知识图谱,再按关联密度聚成社区、生成摘要。查询时,它不只是在找"跟问题相似的段落",而是在图里走关系链路。

但需要说明的是:大部分场景不需要 GraphRAG。 Native RAG + BM25 + Rerank 的组合能解决 95% 的检索问题。GraphRAG 适合的是"高决策"场景——需要综合多个维度的信息才能回答、需要逻辑推理的复杂问题。

考虑到接入成本和维护成本,建议先把你的一二篇做好再说。


总结

从知识库的加工处理到召回再到排序,这一步一步都是工程活,没有太多花活。

几个教训收尾:

  1. 测试才是大头。“测试肯定是大头,就是工程,没有太多难的环节。就是要仔细,不断地反复去盯,盯得眼睛累。” 这就是真实的 RAG 工作场景。
  2. 你不可能一次查全。一千个 chunk 里的冲突检测,每次都要跑多次 LLM 判断。你只能做分类,在每个类别里单独查。
  3. 一开始别想太多,先跑起来。纯向量就能用。等到用户说"找不到"了,加 BM25。还不够,上 MultiQuery。Rerank 在第三顺位——收益最大,但成本也最高。

这大概就是 RAG 调优的真相——技术选型不是问题,工程落地才是。所有人在 PPT 上都做得很好,真正拉开差距的,是进了生产环境之后那些没人管的知识库和没人跑的回归测试。

能把一个系统的各个环节都看住的人,比做新模型的人值钱得多。

后面我们会聊聊某些传统RAG无法满足的应用场景我们应该用什么技术替代,为大家介绍两个比较新的方向 Agentic Retrieval 和 LLM Wiki

学AI大模型的正确顺序,千万不要搞错了

🤔2026年AI风口已来!各行各业的AI渗透肉眼可见,超多公司要么转型做AI相关产品,要么高薪挖AI技术人才,机遇直接摆在眼前!

有往AI方向发展,或者本身有后端编程基础的朋友,直接冲AI大模型应用开发转岗超合适!

就算暂时不打算转岗,了解大模型、RAG、Prompt、Agent这些热门概念,能上手做简单项目,也绝对是求职加分王🔋

在这里插入图片描述

📝给大家整理了超全最新的AI大模型应用开发学习清单和资料,手把手帮你快速入门!👇👇

学习路线:

✅大模型基础认知—大模型核心原理、发展历程、主流模型(GPT、文心一言等)特点解析
✅核心技术模块—RAG检索增强生成、Prompt工程实战、Agent智能体开发逻辑
✅开发基础能力—Python进阶、API接口调用、大模型开发框架(LangChain等)实操
✅应用场景开发—智能问答系统、企业知识库、AIGC内容生成工具、行业定制化大模型应用
✅项目落地流程—需求拆解、技术选型、模型调优、测试上线、运维迭代
✅面试求职冲刺—岗位JD解析、简历AI项目包装、高频面试题汇总、模拟面经

以上6大模块,看似清晰好上手,实则每个部分都有扎实的核心内容需要吃透!

我把大模型的学习全流程已经整理📚好了!抓住AI时代风口,轻松解锁职业新可能,希望大家都能把握机遇,实现薪资/职业跃迁~

这份完整版的大模型 AI 学习资料已经上传优快云,朋友们如果需要可以微信扫描下方优快云官方认证二维码免费领取【保证100%免费】

在这里插入图片描述

RAG知识库检索参数调优实战指南 信息检索技术是构建智能问答系统的核心基础,其中BM25算法作为经典检索模型,通过词频统计和文档长度归一化实现相关性排序。在RAG(检索增强生成)架构中,检索参数的优化直接影响知识库的召回质量,top_k参数控制初始检索规模,而重排序(Rerank)技术则通过深度语义模型提升结果精度。工程实践中需要平衡计算效率与检索效果,例如动态调整top_k值、优化BM25的k1/b参数、选择适合领域的rerank模型等。这些技术在金融合规文档检索、医疗知识问答等场景中具有重要应用价值,合理的参数组合可使检索准确率提升30 阅读详情

相关推荐

RAG 调优指南:Spring AI Alibaba 模块化 RAG 原理与使用

RAG(Retrieval Augmented Generation,检索增强生成)与模块化 RAG (Modular RAG)简介。Spring AI Alibaba 模块化 RAG 原理与实践。

Apache Dubbo 官方博客 1602

一本详解15种高级RAG技术的使用手册

深入探讨了15种高级的检索增强生成(Retrieval-Augmented Generation, RAG)技术,旨在提高生成式人工智能系统在输出质量和整体性能鲁棒性方面的优化。生成优化,关注于生成最终用户响应的LLM调用的改进。包括调整提示、确定插入生成提示的最佳文档数量、通过思维链提示调出噪声、使用Self-RAG使系统自反性等。

m0_59163425的博客 1117

【速通RAG实战:索引】5.RAG分块策略与Embedding技术

分块策略:根据文档类型选择策略(固定分块为基线,语义分块为最优)。嵌入模型:参考 MTEB 榜单,结合业务场景测试模型性能。代码仓库Gitee项目。

2025博客之星Top81。专注AI工程化与架构实战。从分布式思维到模型部署,用工程化视角为你厘清AI落地的真实路径。 2231

RAG入门第四课:RAG系统调优与Streamlit交互实战

文章摘要 本文介绍了如何优化本地RAG问答助手,使其从"能用"变为"好用"。重点包括:1) 调优top_k和chunk_size参数,找到检索数量与文档切分的平衡点;2) 设计双重Prompt系统,通过隐式检索和显式生成两个阶段优化回答质量;3) 使用Streamlit为RAG系统创建可视化界面,提供常见组件的用法速查表;4) 提供完整的app.py代码解析,展示如何将各组件集成到实际应用中。文章强调RAG系统是一个需要持续调优的过程,并提供了具体的参数建议和代码示例

m0_45093055的博客 453

RAG优化知识库检索(4):混合检索技术

混合检索技术在RAG(检索增强生成)系统中的应用显著提升了检索效果。本文探讨了语义检索与关键词检索的优缺点,指出两者在语义理解和精确匹配方面的互补性。通过结合BM25与向量检索,混合检索系统能够更全面地捕捉文档的相关性。文章详细介绍了并行检索、级联检索、稀疏-密集混合表示等多种结合方式,并探讨了权重调整策略,如线性组合、动态权重调整和排序融合算法。此外,稀疏-密集混合检索架构的设计和实现方案也被深入分析,展示了如何通过结合不同检索方法的优势,提升RAG系统的检索质量和效率。

分享一些感兴趣的技术方面 2074

实战解析:如何利用MDFEND与Weibo21数据集构建多领域假新闻检测系统

本文实战解析了如何利用MDFEND模型与Weibo21数据集构建多领域假新闻检测系统。文章深入剖析了MDFEND的领域门控与专家混合机制,并提供了从数据预处理、模型理解到训练部署的完整指南,旨在解决通用模型在不同领域新闻检测中的性能衰减问题,提升检测的准确性与适应性。

vulkan6gpu的博客 583

关于 RAG,我的学习路径与调优心得

年初给自己定了个小目标:系统学一遍大模型应用开发相关的东西,重点放在 MCP、RAG 和 Agent 上。这篇文章就是我在学习 RAG 过程中的一些整理和思考,也当作发出来和大家一起交流。

Y525698136的博客 1101

麒麟系统下PaddleOCR的离线部署实战:从环境搭建到模型优化

本文详细介绍了在国产麒麟操作系统上离线部署百度PaddleOCR的完整实战流程。从系统环境准备、Conda虚拟环境搭建,到PaddlePaddle框架和PaddleOCR的离线安装,再到预训练模型的本地部署与优化技巧,提供了全面的文字识别解决方案。重点解决了离线环境下依赖包管理、模型量化加速等核心问题,并附带了批量处理与内存监控的进阶代码,适用于对数据安全有严格要求的政务、金融等场景。

docker7nomad的博客 964

驯服大模型--大模型RAG调优总结

随着ChatGPT的兴起,大语言模型再次走进人们的视野,其在NLP领域表现出的语言识别、理解以及推理能力令人惊叹。越来越多的行业开始探索大语言模型的应用,比如航空、医疗等行业,针对特定领域设计的大模型往往对大模型的回答严谨程度有更高的要求,要求大模型“言之有据“是在解决细分问题是最基本的要求。在这样的普遍需求之下,本文将介绍针对大模型回复质量的调优方法,主要将以RAG与超参数设置作为主要切入点,介绍RAG技术基本架构与常见的实现流程,以及影响大模型回复质量的超参数解析。大语言模型的不足及RAG优化。

Z4400840的博客 924

ADC学习(3)——采样电路

第三章 采样电路

夏风喃喃的博客 3万+

快速傅里叶变换(The Fast Fourier Transform,FFT)

快速傅里叶变换 傅里叶的思想:将函数 fff 表示成类似于调和级数∑ckeikx\sum c_ke^{ikx}∑ck​eikx,这个函数是通过频率空间中的系数ckc_kck​呈现出来,而不是通过物理空间中的函数值f(x)f(x)f(x)来呈现函数 下图来自:傅里叶分析之掐死教程(完整版)更新于2014.06.06 主要思想: 笔记来源于:The Fast Fourier Transform (FFT): Most Ingenious Algorithm Ever? 表达多项式的两种方法: 1.系数表示

一个搬运知识的笨小孩 1476

Docker容器化LangChain RAG(性能调优+故障排查完整手册)

掌握高效稳定的Docker与LangChain的RAG部署方案,解决本地部署性能瓶颈与服务不稳定难题。涵盖容器化配置、模型加速、内存优化及常见故障排查技巧,适用于AI问答、知识库检索等场景,提升系统响应速度与可维护性,值得收藏。

LogicGlow的博客 922

零基础 ABAP 学习教程系列文章的目录

曾几何时,ABAP 就是 SAP 的代名词。ABAP 这门编程语言造就了 SAP 名噪一时的 R/3 产品,同时也是如今 SAP 旗舰级产品,SAP S/4HANA 底层的实现语言。 ABAP 不仅代表着 SAP 这家公司在企业级管理软件市场辉煌的过去,ABAP 自身也在不断地进化着。SAP 不仅在本地部署(On-Premise)领域继续保持着自己绝对的统治地位,而且在云应用领域(Software-as-a-Service, 简称 SaaS), 也推出了自己的解决方案,比如 SAP S/4HANA Clo

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 2万+

【收藏必看】RAG技术全解析:从入门到精通,8大核心策略+实战调优指南

本文系统探讨了RAG(检索增强生成)技术的核心原理与应用实践。首先分析了LLM的局限性(知识缺乏、幻觉问题、信息过时等)以及RAG的解决方案价值,通过对比RAG与微调的优劣势,指出RAG更适合文档问答场景。文章详细解析了RAG三大核心组件(嵌入模型、向量、向量数据库)的工作原理,并拆解标准流程的索引、检索、生成三个阶段。重点讨论了文档分块策略(固定大小、重叠、递归、结构化分块)的选择与实践建议,为构建高效RAG系统提供了方法论指导。全文兼顾技术深度与实用考量,是开发者实施RAG项目的重要参考。

优快云_224022的博客 803

惠普M329打印机更换副厂硒鼓后提示墨粉不足并无法打印

买了一个惠普M329打印机,打印效果不错,速度快,大量复印比较方便。因为最近打印和复印比较多,很快原装墨粉用完了。又买了一个副厂(带芯片)的硒鼓换上。不到一个月,又用光了,这次买了同一个副厂的硒鼓(不带芯片)。将原来的芯片(副厂的)拆下来,装在新硒鼓上。装到M329上以后,打印机依旧是提示墨粉不足。

bigwood99的博客 7691

基于物联网的门禁与考勤系统(阿里云)_81

本课题设计的基于物联网的门禁与考勤管理系统,结合现代信息技术,利用指纹识别、射频卡、密码输入和远程控制等多种开锁方式,提升门禁系统的安全性和灵活性;同时,通过物联网平台进行数据上传和远程管理,极大提高了管理效率。通过智能化的考勤功能,系统可以实时记录员工的出入情况,并通过云平台进行远程查询和管理,推动门禁与考勤管理的数字化、智能化和高效化。

1万+

大模型论文 | RAG技术的三大范式(基础RAG、高级RAG、模块化RAG)和技术演进

大模型的技术原理是不断预测下一个Token,且每一个已经生成的Token都会影响下一个Token的生成。简单来说,大模型就是一个概率预测机器,同样的Prompt会产生不同的答案,这就是所谓的信息幻觉问题。换个容易理解的说法,针对同一个或同一组Prompt,大模型的结果不具备幂等性。从2022年底ChatGPT横空出世以来,大模型的信息幻觉(生成错误信息)、知识过时、推理过程不透明等问题,一直困扰着业内各方技术人员,直至RAG技术出现,才算缓解了这个难题。

m0_56255097的博客 1060

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

小白也能懂!一文吃透 RAG:从原理到调优,让你的 AI 回答精准翻倍

小白也能懂!一文吃透 RAG:从原理到调优,让你的 AI 回答精准翻倍

qq_46094651的博客 850

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

RAG文本分割:RecursiveCharacterTextSplitter原理、调优与实战

在检索增强生成(RAG)系统中,文本分割是决定效果上限的关键环节。其核心原理是将文档切分为语义完整、长度适宜的片段,以供向量化与检索。传统按字符或句子分割的方法容易破坏语义连贯性,而递归字符分割器通过优先级分隔符列表实现优雅降级,优先在段落、句子等自然边界处切割,兼顾了语义完整性与长度控制。这一技术能显著提升后续嵌入模型与检索器的效果,广泛应用于技术文档、学术论文等场景。针对中文文档,需调整分隔符加入标点;针对长句与表格等特殊结构,则需结合预处理策略。通过合理设置chunk_size、chunk_overl

weixin_30550081的博客 417

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

一文读懂传统 RAG 与 Agentic RAG 的技术差异与实战应用

一文读懂传统 RAG 与 Agentic RAG 的技术差异与实战应用

EnjoyEDU的博客 1467

全面解析RAG技术:原理拆解、行业应用与进阶调优,让AI输出精准度飙升

全面解析RAG技术:原理拆解、行业应用与进阶调优,让AI输出精准度飙升

大模型研究中心 1462

RAG技术实战:从核心组件到企业级调优

检索增强生成(RAG)技术通过结合信息检索与生成模型,有效解决了大语言模型在专业领域知识不足的问题。其核心原理是通过向量数据库(如Milvus)快速检索相关文档片段,再经由LLM生成符合上下文的回答。这种架构既保留了基础模型的通用能力,又能动态接入最新知识库,在金融、医疗等行业的知识问答场景表现突出。关键技术环节包括嵌入模型选型(如BGE)、混合检索策略设计以及生成结果的真实性校验。生产部署时需特别注意知识库版本管理、GPU加速优化和细粒度访问控制,典型应用可达到80ms内的检索延迟和90%以上的问答准确率

weixin_42620255的博客 301
上一篇: RAG 混合检索生产实战指南:从召回原理到高并发架构落地
下一篇: 面试官:Plan-Execute-Replan 和 ReAct 有啥区别?
Python_金钱豹
博客等级 码龄5年 1万+粉丝 2841原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值