RAG

为什么分块策略如此重要？ 在RAG系统中，分块（Chunking）是影响检索质量的第一道关卡。同样的文档、同样的Embedding模型、同样的LLM，仅仅因为分块策略不同，检索准确率可以相差30%以上。 核心矛盾在于：块太大，检索精度下降（噪声多）；块太小，上下文不足（语义不完整）。 好的分块策略要在这两端之间找到最优解。 六种分块策略全面对比 1. 固定大小分块（Fixed-Size Chunking） 最简单的策略：按固定token数切分，带overlap。 from langchain.text_splitter import RecursiveCharacterTextSplitter splitter = RecursiveCharacterTextSplitter( chunk_size=512, chunk_overlap=50, separators=["\n\n", "\n", "。", "！", "？", "，", " "], ) chunks = splitter.split_text(document) 参数 推荐值 说明 chunk_size 256-1024 取决于文档类型，技术文档建议512 chunk_overlap 10-20% 防止语义在切分边界断裂 优点：实现简单、速度快、可预测 缺点：可能在句子中间切断，破坏语义完整性 适用：快速原型、均匀文本（如日志、评论） 2. 语义分块（Semantic Chunking） 不按固定大小切，而是按语义相似度断点切。当相邻句子的语义相似度低于阈值时，在此处分块。 from semantic_chunker import SemanticChunker from langchain_openai import OpenAIEmbeddings # 基于Embedding相似度的语义分块 chunker = SemanticChunker( OpenAIEmbeddings(model="text-embedding-3-large"), breakpoint_threshold_type="percentile", # 或 "standard_deviation" breakpoint_threshold_amount=95, # 百分位阈值 ) chunks = chunker.split_text(document) 工作原理： 句子1 → 句子2 → 句子3 → 句子4 → 句子5 0.92 0.88 0.45↓ 0.91 0.87 ↑ 语义断点（相似度骤降） 在这里切分 # 自定义语义分块实现 import numpy as np from sklearn.metrics.pairwise import cosine_similarity def semantic_chunk(text, embeddings_model, threshold=0.5): """基于句子间语义相似度的自适应分块""" sentences = split_into_sentences(text) # 计算每对相邻句子的相似度 embeddings = [embeddings_model.embed(s) for s in sentences] similarities = [ cosine_similarity([embeddings[i]], [embeddings[i+1]])[0][0] for i in range(len(embeddings) - 1) ] # 找到相似度低于阈值的位置作为断点 chunks = [] current_chunk = [sentences[0]] for i, sim in enumerate(similarities): if sim < threshold: chunks.append(" ".join(current_chunk)) current_chunk = [sentences[i + 1]] else: current_chunk.append(sentences[i + 1]) chunks.append(" ".join(current_chunk)) return chunks 优点：语义完整、适应文档结构 缺点：计算开销大（每句话都要Embedding）、块大小不可控 适用：长文章、研究报告、新闻 ...

前言：RAG从Demo到生产的鸿沟 写一个RAG Demo只需要30分钟——加载文档、Embedding、存向量库、检索、生成，完成。但把它放到生产环境，你会发现： 幻觉：LLM明明拿到了正确文档，还是编造了不存在的信息 漏检：库里明明有相关文档，检索就是找不到 延迟：用户等了8秒还没返回，体验崩溃 这三个问题构成了RAG生产环境的"不可能三角"。本文分享2026年我们在生产环境中踩过的坑和解决方案。 难题一：幻觉问题 幻觉的三种形态 类型 表现 根因 忠实性幻觉 答案与检索文档矛盾 LLM忽略上下文，依赖自身参数知识 编造型幻觉 答案包含文档中不存在的信息 LLM"脑补"细节 来源混淆 将多个文档的信息错误组合 多文档检索时上下文混淆 解决方案矩阵 方案1：强约束Prompt # ❌ 容易幻觉的Prompt prompt = f"""基于以下资料回答问题： {context} 问题：{question} """ # ✅ 抗幻觉的Prompt prompt = f"""你是一个严格的信息提取助手。请遵循以下规则： 1. **只使用**以下参考资料回答问题 2. 如果参考资料中没有相关信息，直接回答"根据现有资料无法回答此问题" 3. 不要添加任何参考资料中未提及的信息 4. 不要进行推理、猜测或补全 5. 回答中需要引用具体的资料来源 参考资料： --- {context} --- 问题：{question} 回答格式： [来源：文档名] 回答内容... """ 方案2：置信度校准 def answer_with_confidence(question, retrieved_docs): """带置信度的回答""" # 第一步：评估检索质量 relevance_prompt = f"""评估以下文档与问题的相关性(0-10): 问题: {question} 文档: {retrieved_docs[0].page_content[:500]} 只返回数字。""" relevance_score = int(llm.invoke(relevance_prompt).strip()) if relevance_score < 4: return { "answer": "抱歉，知识库中没有找到与您问题相关的信息。", "confidence": 0.2, "should_answer": False, } # 第二步：生成回答并自我验证 answer = rag_chain.invoke(question) # 第三步：验证回答是否忠于上下文 verify_prompt = f"""判断以下回答的每个陈述是否能在参考资料中找到支撑。 参考资料: {retrieved_docs} 回答: {answer} 返回JSON: {{"faithful": true/false, "unsupported_claims": [...]}}""" verification = json.loads(llm.invoke(verify_prompt)) return { "answer": answer if verification["faithful"] else "无法确认回答准确性", "confidence": relevance_score / 10.0, "should_answer": verification["faithful"], } 方案3：Citation机制 def generate_with_citations(question, retrieved_docs): """强制引用来源的生成""" # 给每个文档编号 numbered_context = "\n\n".join([ f"[{i+1}] {doc.page_content}" for i, doc in enumerate(retrieved_docs) ]) prompt = f"""基于以下编号的参考资料回答问题。每个陈述后必须标注来源编号[1]。 参考资料： {numbered_context} 问题：{question} 要求： - 每个事实陈述后标注来源编号，如"GraphRAG由微软提出[1]" - 如果某个陈述来自多个文档，标注所有来源，如"[1][3]" - 无法找到来源的陈述不要写出 回答：""" return llm.invoke(prompt) 幻觉抑制效果实测 方案 幻觉率↓ 答案完整度↓ 延迟增加 强约束Prompt 45% 15% +0s 置信度校准 68% 8% +1.5s Citation机制 72% 5% +0.8s 三者结合 85% 22% +2.3s 建议组合：强约束Prompt + Citation机制，性价比最高。 ...

LlamaIndex 2026：RAG之王的Agent转型 LlamaIndex（原GPT Index）最初是一个专注于RAG（检索增强生成）的框架。2024年，它是构建知识增强LLM应用的事实标准。但市场在变——单纯的RAG已经不够了，用户需要Agent：能够自主检索、推理、行动的智能体。2026年，LlamaIndex完成了从"RAG框架"到"Agent平台"的战略转型。 转型背景：为什么RAG不够了 RAG的局限 RAG能力 局限性 单轮检索 无法处理需要多步推理的复杂问题 静态知识库 无法实时更新和动态检索 被动回答 不能主动行动（发邮件、调API） 单一数据源 难以跨多个异构数据源联合查询 无任务规划 无法分解复杂任务为子任务 Agent化解决方案 传统RAG：用户提问 → 检索 → 生成回答 Agent化：用户提问 → 理解意图 → 规划任务 → 多步检索/行动 → 综合回答 AgentWorkflow：LlamaIndex的Agent编排引擎 2026版本引入了AgentWorkflow作为核心Agent编排组件： from llama_index.core.agent.workflow import ( AgentWorkflow, FunctionAgent, ReActAgent, RouterAgent ) from llama_index.core.tools import QueryEngineTool, ToolMetadata # 创建RAG工具 stock_engine = create_stock_query_engine() # 股票数据引擎 news_engine = create_news_query_engine() # 新闻数据引擎 report_engine = create_report_query_engine() # 财报数据引擎 # 定义工具 tools = [ QueryEngineTool( query_engine=stock_engine, metadata=ToolMetadata( name="stock_data", description="查询股票实时行情和历史数据" ) ), QueryEngineTool( query_engine=news_engine, metadata=ToolMetadata( name="news_data", description="搜索财经新闻和公告" ) ), QueryEngineTool( query_engine=report_engine, metadata=ToolMetadata( name="report_data", description="查询上市公司财报数据" ) ) ] # 创建专业Agent analyst_agent = ReActAgent( name="分析Agent", description="负责数据分析和技术指标计算", tools=[stock_engine, report_engine], llm=OpenAI(model="gpt-4o"), system_prompt="你是一位专业的金融分析师..." ) research_agent = ReActAgent( name="研究Agent", description="负责新闻搜集和信息检索", tools=[news_engine], llm=OpenAI(model="gpt-4o"), system_prompt="你是一位财经研究员..." ) writer_agent = FunctionAgent( name="撰写Agent", description="负责综合分析报告撰写", llm=OpenAI(model="gpt-4o"), system_prompt="你是一位专业的金融报告撰写人..." ) # 创建工作流 workflow = AgentWorkflow( agents=[analyst_agent, research_agent, writer_agent], root_agent=analyst_agent, # 主入口Agent max_steps=20, # 最大执行步数 max_time=180, # 最大执行时间（秒） ) # 执行 response = await workflow.run( "分析贵州茅台2025年年报，结合近期新闻，给出投资建议" ) Agent类型对比 Agent类型 决策方式 适合场景 灵活性 ReActAgent 推理-行动循环 需要多步推理的任务 高 FunctionAgent 直接函数调用 简单确定性任务 低 RouterAgent 路由到子Agent 需要分领域处理 中 CustomAgent 自定义逻辑 特殊需求 完全可控 数据代理：RAG的Agent化升级 LlamaIndex 2026提出了"Data Agent"概念——专门处理数据的智能Agent： ...

引言 幻觉（Hallucination）——大模型生成看似合理但事实上不正确的内容——是大模型走向实际应用的最大障碍之一。在医疗、法律、金融等高风险场景中，一次幻觉可能导致严重后果。2026年，尽管模型能力大幅提升，幻觉问题仍然存在，但业界已发展出一系列从训练到推理的缓解技术。本文将系统分析幻觉的根因并梳理全景式的解决方案。 幻觉的定义与分类 定义 幻觉指模型生成的内容与已知事实不符，或与给定上下文矛盾。形式化定义： $$ \text{Hallucination}: \exists f \in \text{output}, \quad f \not\in \text{Facts} \lor f \not\in \text{Context} $$ 分类体系 幻觉类型 描述 示例 严重程度 事实性幻觉 生成不存在的事实 “爱因斯坦出生于1890年”（实际1879） 高 上下文幻觉 与给定上下文矛盾 RAG场景中忽略检索到的事实 高 推理幻觉 推理链中包含错误步骤 数学证明中跳过关键步骤 中 来源幻觉 错误归因信息来源 “根据2024年Nature论文…"（不存在） 中 自我矛盾 前后陈述矛盾 先说"是”，后说"不是" 低 幻觉的量化评估 class HallucinationEvaluator: def __init__(self, fact_checker=None): self.fact_checker = fact_checker # 外部事实核查器 def evaluate(self, response, context=None, reference=None): """多维度幻觉评估""" results = { 'factual_accuracy': self.check_facts(response), 'context_consistency': self.check_context(response, context) if context else None, 'internal_consistency': self.check_internal(response), 'source_accuracy': self.check_sources(response), } # 综合幻觉分数 scores = [v for v in results.values() if v is not None] results['overall_hallucination_rate'] = 1 - np.mean(scores) return results def check_facts(self, response): """事实准确性检查""" if self.fact_checker: return self.fact_checker.verify(response) return None def check_context(self, response, context): """上下文一致性检查""" # 使用NLI模型检查蕴含关系 nli_score = self.nli_model(context, response) return nli_score # 0-1, 1=完全蕴含 def check_internal(self, response): """内部一致性检查""" sentences = split_sentences(response) contradictions = 0 for i, s1 in enumerate(sentences): for s2 in sentences[i+1:]: if self.nli_model(s1, s2) < 0.3: contradictions += 1 return 1 - contradictions / max(1, len(sentences)) 幻觉的根因分析 1. 训练数据层面 数据噪声：训练数据中包含错误信息，模型学习了这些错误。 ...

2026年，RAG（Retrieval-Augmented Generation）技术已经走过了三年的演进历程。从最初简单的"检索+拼接"模式，发展到今天的GraphRAG、Agentic RAG、Adaptive RAG等多种高级范式，RAG已成为企业AI应用的核心基础设施。本文将系统梳理2026年RAG技术的全景图。 一、RAG技术演进路线 四代RAG架构 代际 名称 核心特征 时间 代表方案 第一代 Naive RAG 简单向量检索+拼接 2023 LangChain Basic RAG 第二代 Advanced RAG 查询改写、重排序、多路召回 2024 LlamaIndex Advanced 第三代 Modular RAG 模块化、可插拔、自适应路由 2025 LangGraph RAG 第四代 Agentic RAG Agent驱动、多步推理、工具调用 2026 Agentic RAG, GraphRAG 为什么需要更先进的RAG？ Naive RAG的根本问题在于： 检索质量不稳定：向量相似度≠语义相关性 缺乏推理能力：无法处理"需要多步推理才能回答"的问题 无结构化知识：无法利用实体关系、时序信息等结构化知识 无自适应能力：对所有问题用同一套检索策略 2026年企业RAG部署的统计：Naive RAG的准确率仅55-65%，而Agentic RAG可达85-92%——差距巨大。 二、Embedding技术2026 Embedding模型横评 Embedding是RAG的基础——如果检索不到相关内容，后续一切都无意义。 模型 维度 最大序列 MTEB分数 中文表现 特点 OpenAI text-embedding-3-large 3072 8191 72.5 良好 通用、稳定 Voyage-3 1024 32000 74.8 良好 2026最强 BGE-M3 1024 8192 73.2 优秀 多语言、开源 GTE-Large-ZH 1024 512 71.5 优秀 中文优化 Jina Embeddings v3 1024 8192 72.8 良好 长文本 Cohere Embed v4 1536 512 73.5 良好 多语言 2026年Embedding技术趋势 1. 多向量嵌入（Multi-Vector Embedding） ...

引言 2026年，AI客服系统已经从简单的FAQ机器人进化为具备深度理解、情感识别和主动服务能力的智能体。根据Gartner最新报告，全球78%的企业客服中心已部署AI驱动的话务系统，平均首次解决率（FCR）从传统IVR的42%提升至71%。本文将系统性地介绍如何从零构建一套现代AI客服系统。 一、架构总览 现代AI客服系统的核心架构包含以下层级： 层级 组件 技术选型 接入层 Web/App/电话/社交媒体 WebSocket + SIP + Webhook 对话层 意图识别 + 对话管理 LLM + Function Calling 知识层 RAG + 知识图谱 向量数据库 + 图数据库 业务层 工单/CRM/ERP集成 REST API + 消息队列 分析层 质检/分析/监控 实时流处理 + BI看板 二、知识库搭建 2.1 知识来源梳理 构建客服系统的第一步是建立高质量知识库。典型的知识来源包括： 产品文档：用户手册、FAQ、操作指南 历史工单：已解决的客服记录，经过脱敏和结构化处理 政策法规：退换货政策、隐私条款、合规要求 对话记录：优秀人工客服的对话样本 2.2 知识处理流水线 # 知识处理流水线伪代码 def process_knowledge(raw_docs): # 1. 文档解析与清洗 chunks = [] for doc in raw_docs: parsed = parse_document(doc) # PDF/Word/HTML统一解析 cleaned = clean_text(parsed) # 去除噪声、标准化格式 chunks.extend(chunk_text(cleaned, max_tokens=512, overlap=64)) # 2. 向量化与索引 embeddings = embedding_model.encode(chunks) # 如 bge-m3, text-embedding-3-large vector_db.upsert(chunks, embeddings, metadata) # 3. 知识图谱构建 entities = ner_model.extract(chunks) relations = relation_extractor.extract(chunks, entities) graph_db.insert(entities, relations) # 4. 质量校验 qa_pairs = generate_qa_pairs(chunks) # 用LLM自动生成测试集 validate_retrieval(qa_pairs) # 验证召回率和准确率 2.3 RAG检索优化 2026年主流的RAG优化策略已从简单向量检索演进为多路召回+重排序： ...

幻觉：LLM 最棘手的问题 大模型的幻觉（Hallucination）——自信地输出错误或虚构的信息——是 2026 年 LLM 生产应用中最大的痛点。Stanford 2026 年 AI Index 报告显示，即使是最先进的模型，在事实性问答中的幻觉率仍有 3-8%，在专业领域更是高达 15-20%。幻觉不是 bug，而是 LLM 生成式架构的特性——但我们可以系统性地缓解它。 一、幻觉的分类 1.1 幻觉类型体系 类型 描述 示例 严重性 事实性幻觉 输出与事实不符 “爱因斯坦出生于1890年”（实际1879） 高 来源幻觉 虚构引用/出处 编造不存在的论文 高 推理幻觉 推理链条中出错 正确前提但错误结论 中 时间幻觉 时间线混乱 “2024年奥运会在北京举办” 中 实体幻觉 虚构人/组织/产品 “微软CEO John Smith” 高 数值幻觉 数字/计算错误 “12×13=146”（实际156） 高 代码幻觉 API/函数不存在 调用不存在的库函数 中 自我幻觉 虚构自身能力 “我可以访问实时互联网” 低 1.2 幻觉产生的根因 ┌──────────────────────────────────────────┐ │ 幻觉根因分析 │ ├──────────────────────────────────────────┤ │ │ │ 1. 训练数据问题 │ │ ├── 训练数据中的错误信息 │ │ ├── 知识截止日期后的信息缺失 │ │ └── 长尾知识表示不足 │ │ │ │ 2. 模型架构问题 │ │ ├── 自回归生成无法回溯修正 │ │ ├── 注意力机制对事实关注不足 │ │ └── 知识存储与检索机制不完善 │ │ │ │ 3. 推理机制问题 │ │ ├── 缺乏事实核查机制 │ │ ├── 过度依赖模式匹配而非知识检索 │ │ └── 采样温度增加随机性 │ │ │ │ 4. 交互问题 │ │ ├── 模型倾向"回答"而非"承认不知道" │ │ ├── 用户问题中的错误前提引导 │ │ └── 上下文中的错误信息被采纳 │ │ │ └──────────────────────────────────────────┘ 二、幻觉检测方法 2.1 基于一致性的检测 class ConsistencyBasedDetector: """基于一致性的幻觉检测""" def __init__(self, llm_client, n_samples: int = 5): self.llm = llm_client self.n_samples = n_samples def detect(self, query: str, response: str) -> dict: """通过多次采样检测一致性""" # 1. 对同一问题生成多个回答 responses = [] for _ in range(self.n_samples): r = self.llm.generate(query, temperature=0.7) responses.append(r) # 2. 提取每个回答中的事实性陈述 all_claims = [] for r in responses: claims = self._extract_claims(r) all_claims.append(claims) # 3. 检查事实一致性 consistency_scores = self._check_consistency(all_claims) # 4. 原始回答的事实性评估 original_claims = self._extract_claims(response) original_scores = [] for claim in original_claims: # 该claim在其他回答中出现的比例 support_count = sum( 1 for claims in all_claims if self._claim_match(claim, claims) ) original_scores.append({ 'claim': claim, 'support_rate': support_count / len(all_claims), 'likely_hallucination': support_count / len(all_claims) < 0.4 }) hallucination_rate = sum( 1 for s in original_scores if s['likely_hallucination'] ) / len(original_scores) if original_scores else 0 return { 'hallucination_rate': hallucination_rate, 'claim_scores': original_scores, 'overall_consistency': np.mean(consistency_scores) } def _extract_claims(self, text: str) -> list: """提取文本中的事实性陈述""" prompt = f"""提取以下文本中的所有事实性陈述，每条一行： {text}""" result = self.llm.generate(prompt) return [line.strip() for line in result.split('\n') if line.strip()] def _claim_match(self, claim: str, other_claims: list) -> bool: """判断claim是否在other_claims中存在""" prompt = f"""判断以下陈述是否语义等价： 陈述A：{claim} 陈述B列表：{other_claims} 如果A与B中任一陈述语义等价，返回"是"，否则"否"。""" return '是' in self.llm.generate(prompt) 2.2 基于来源验证的检测 class SourceVerificationDetector: """基于来源验证的幻觉检测""" def __init__(self, llm_client, search_client): self.llm = llm_client self.search = search_client def detect(self, response: str, sources: list = None) -> dict: """验证回答中的事实是否有来源支持""" # 1. 提取事实性陈述 claims = self._extract_claims(response) # 2. 对每个claim进行验证 results = [] for claim in claims: # 如果有现成来源，在来源中验证 if sources: verification = self._verify_in_sources(claim, sources) else: # 搜索验证 verification = self._verify_by_search(claim) results.append({ 'claim': claim, 'verdict': verification['verdict'], # supported | refuted | unverifiable 'evidence': verification['evidence'], 'confidence': verification['confidence'] }) hallucination_claims = [ r for r in results if r['verdict'] == 'refuted' ] unsupported_claims = [ r for r in results if r['verdict'] == 'unverifiable' ] return { 'total_claims': len(results), 'supported': len([r for r in results if r['verdict'] == 'supported']), 'refuted': len(hallucination_claims), 'unverifiable': len(unsupported_claims), 'hallucination_rate': len(hallucination_claims) / len(results), 'details': results } def _verify_in_sources(self, claim: str, sources: list) -> dict: """在给定来源中验证claim""" prompt = f"""判断以下陈述是否被来源文本支持。 陈述：{claim} 来源文本： {chr(10).join(f'[{i+1}] {s[:500]}' for i, s in enumerate(sources))} 判断： - "supported"：来源支持该陈述 - "refuted"：来源与该陈述矛盾 - "unverifiable"：来源无法验证该陈述 返回判断和依据。""" result = self.llm.generate(prompt) if 'supported' in result.lower(): verdict = 'supported' elif 'refuted' in result.lower(): verdict = 'refuted' else: verdict = 'unverifiable' return { 'verdict': verdict, 'evidence': result, 'confidence': 0.8 } def _verify_by_search(self, claim: str) -> dict: """通过搜索验证claim""" search_results = self.search.search(claim, top_k=3) return self._verify_in_sources(claim, search_results) 2.3 基于模型置信度的检测 class ConfidenceBasedDetector: """基于模型内部置信度的幻觉检测""" def __init__(self, model): self.model = model def detect(self, prompt: str) -> dict: """通过logits分析检测幻觉""" # 1. 获取模型输出和logits with torch.no_grad(): outputs = self.model.generate( prompt, return_logits=True, output_scores=True ) # 2. 计算每个token的置信度 token_confidences = [] for i, (token, score) in enumerate( zip(outputs.tokens, outputs.scores) ): # softmax得到概率 probs = torch.softmax(score, dim=-1) token_prob = probs[token].item() token_confidences.append(token_prob) # 3. 分析低置信度区域 low_confidence_threshold = 0.5 low_conf_regions = [ {'position': i, 'token': outputs.tokens[i], 'confidence': conf} for i, conf in enumerate(token_confidences) if conf < low_confidence_threshold ] # 4. 计算整体置信度指标 avg_confidence = np.mean(token_confidences) min_confidence = np.min(token_confidences) return { 'avg_confidence': avg_confidence, 'min_confidence': min_confidence, 'low_confidence_tokens': len(low_conf_regions), 'hallucination_risk': 'high' if avg_confidence < 0.6 else 'medium' if avg_confidence < 0.8 else 'low', 'low_conf_regions': low_conf_regions[:10] # 前10个低置信度token } 三、幻觉缓解策略 3.1 RAG 增强 class RAGHallucinationMitigator: """RAG 增强缓解幻觉""" def __init__(self, llm_client, retrieval_client): self.llm = llm_client self.retrieval = retrieval_client def generate(self, query: str) -> dict: """RAG增强生成""" # 1. 检索相关文档 docs = self.retrieval.search(query, top_k=5) # 2. 构建RAG Prompt prompt = self._build_rag_prompt(query, docs) # 3. 生成回答 response = self.llm.generate(prompt) # 4. 后验证 verification = self._verify_response(response, docs) return { 'response': response, 'sources': docs, 'verification': verification, 'hallucination_risk': verification['hallucination_rate'] } def _build_rag_prompt(self, query: str, docs: list) -> str: return f"""请基于以下参考资料回答问题。如果资料中没有答案，请明确说明"根据现有资料无法回答"。 ## 参考资料 {self._format_docs(docs)} ## 回答规则 1. 只使用参考资料中的信息 2. 每个事实性陈述必须标注来源 [1], [2] 等 3. 如果资料中有矛盾信息，指出矛盾 4. 不确定的信息要标注"可能" 5. 资料中未涉及的信息不要编造 ## 问题 {query} ## 回答""" 3.2 自我验证机制 class SelfVerificationGenerator: """自我验证生成机制""" def __init__(self, llm_client): self.llm = llm_client def generate_with_verification(self, query: str) -> dict: """带自我验证的生成""" # Step 1: 初步生成 initial_response = self.llm.generate(query) # Step 2: 自我事实核查 fact_check = self._self_fact_check(query, initial_response) # Step 3: 如果发现幻觉，修正 if fact_check['has_issues']: corrected = self._correct_hallucinations( query, initial_response, fact_check ) else: corrected = initial_response # Step 4: 最终验证 final_check = self._final_verification(query, corrected) return { 'response': corrected, 'initial_response': initial_response, 'fact_check': fact_check, 'final_verification': final_check, 'corrections_made': fact_check['issues_found'] } def _self_fact_check(self, query: str, response: str) -> dict: """自我事实核查""" prompt = f"""请对你自己的回答进行事实核查。 问题：{query} 你的回答：{response} 请逐句检查： 1. 每个事实性陈述是否准确？ 2. 是否有编造的信息？ 3. 是否有不确定但表述为事实的内容？ 4. 数字和日期是否正确？ 对每个可能的问题，标注： - 陈述内容 - 问题类型（错误/编造/不确定） - 修正建议 如果一切正确，返回"无问题"。""" result = self.llm.generate(prompt) has_issues = '无问题' not in result issues = [] if has_issues: # 解析问题列表 issues = self._parse_issues(result) return { 'has_issues': has_issues, 'issues_found': issues, 'raw_check': result } def _correct_hallucinations(self, query, response, fact_check): """修正检测到的幻觉""" prompt = f"""请修正以下回答中的事实性错误。 原始问题：{query} 原始回答：{response} 检测到的问题：{fact_check['raw_check']} 修正规则： 1. 修正所有检测到的事实性错误 2. 不确定的信息添加"据我所知"等限定词 3. 无法确认的信息直接删除或标注"需查证" 4. 保持回答的连贯性和有用性 修正后的回答：""" return self.llm.generate(prompt) 3.3 多模型交叉验证 class CrossModelVerification: """多模型交叉验证""" def __init__(self, models: list): self.models = models # 多个不同厂商的模型 def generate_verified(self, query: str) -> dict: """多模型交叉验证生成""" # 1. 每个模型独立生成回答 responses = [] for model in self.models: r = model.generate(query, temperature=0.0) responses.append(r) # 2. 提取各模型的事实性陈述 all_claims = [] for r in responses: claims = self._extract_claims(r) all_claims.append(set(claims)) # 3. 找出共识陈述和分歧陈述 consensus = set.intersection(*all_claims) if all_claims else set() all_claims_set = set.union(*all_claims) if all_claims else set() disputed = all_claims_set - consensus # 4. 只保留共识陈述 verified_response = self._build_response_from_consensus( query, consensus, responses[0] # 以第一个模型的回答为模板 ) return { 'response': verified_response, 'model_count': len(self.models), 'consensus_claims': len(consensus), 'disputed_claims': len(disputed), 'agreement_rate': len(consensus) / max(len(all_claims_set), 1) } 四、幻觉评估基准 4.1 评估指标 指标 计算方式 目标 事实准确率 事实正确陈述/总事实陈述 > 95% 幻觉率 虚构陈述/总事实陈述 < 5% 来源准确率 正确引用/总引用 > 90% 拒绝准确率 正确拒绝不该回答的问题比例 > 95% 过度拒绝率 错误拒绝合理问题的比例 < 5% 自校准ECE 预期校准误差 < 0.1 4.2 评估数据集构建 class HallucinationEvalDataset: """幻觉评估数据集""" CATEGORIES = { 'factual_qa': { 'description': '事实性问答', 'examples': [ {'q': '中国最长的河流是？', 'a': '长江', 'type': 'fact'}, {'q': '光速是多少？', 'a': '约3×10^8 m/s', 'type': 'fact'}, ] }, 'unanswerable': { 'description': '无法回答的问题（测试是否承认不知道）', 'examples': [ {'q': '2028年的奥斯卡最佳影片是哪部？', 'a': '无法回答', 'type': 'refuse'}, {'q': '张三的手机号码是多少？', 'a': '无法回答', 'type': 'refuse'}, ] }, 'false_premise': { 'description': '错误前提问题', 'examples': [ {'q': '林黛玉倒拔垂杨柳的故事告诉我们什么？', 'a': '指出前提错误', 'type': 'correct'}, ] }, 'multi_hop': { 'description': '多跳推理（每跳都可能出错）', 'examples': [ {'q': '相对论提出者出生国家的首都人口是多少？', 'a': '需推理：爱因斯坦→德国→柏林→人口', 'type': 'reasoning'} ] } } 五、2026 前沿方向 检索增强自我修正：模型生成后自动检索验证并修正 事实性训练：用事实核查数据做偏好优化 知识编辑：直接在模型权重中修正错误知识 不确定性量化：模型输出附带校准的不确定性分数 因果推理增强：用因果推理替代模式匹配 工具增强事实性：自动调用搜索引擎、计算器等工具 结语 幻觉是 LLM 的"原罪"——源于其自回归生成架构和统计学习本质。完全消除幻觉在当前技术范式下不可能，但通过 RAG、自我验证、交叉验证等手段，可以将其控制在可接受范围内。 ...

Dify 2026：从工作流到 AI 操作系统 Dify 在 2026 年经历了从"LLM 应用开发平台"到"AI 操作系统"的蜕变。这个由苏州语灵科技打造的开源平台，已经积累了 45.6k GitHub Stars，成为亚洲最大的 AI 应用开源项目之一。本文将从实际使用出发，对 Dify 2026 版本进行全面评测。 核心能力总览 1. 可视化 Workflow 编排 Dify 2026 的 Workflow 编辑器是评测中体验最好的部分。拖拽式画布支持以下节点类型： ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ Start 节点 │───→│ LLM 节点 │───→│ 条件分支节点 │ │ (输入定义) │ │ (模型选择) │ │ (IF/ELSE) │ └─────────────┘ └─────────────┘ └──────┬──────┘ │ ┌──────────────────┤ ▼ ▼ ┌─────────────┐ ┌─────────────┐ │ 知识检索节点 │ │ HTTP 请求节点 │ │ (RAG) │ │ (API 调用) │ └──────┬──────┘ └──────┬──────┘ │ │ └────────┬─────────┘ ▼ ┌─────────────┐ │ End 节点 │ │ (输出定义) │ └─────────────┘ 评测中发现，Workflow 的条件分支节点支持嵌套逻辑，代码节点支持 Python 和 JavaScript 双语言： ...

从 RAG 到 Agent：LlamaIndex 的范式跃迁 LlamaIndex 在 2023 年以"RAG 框架"闻名——它是构建检索增强生成应用最简单的方式。但创始人 Jerry Liu 很早就意识到：RAG 本质上是 Agent 的一个特例。到 2026 年，LlamaIndex 已经完成了从"RAG 框架"到"数据驱动 Agent 平台"的转型。 2026 架构演进 核心层次 ┌──────────────────────────────────────────────────┐ │ Agent Layer │ │ Workflows │ Data Agents │ Multi-Agent │ Tools │ ├──────────────────────────────────────────────────┤ │ Orchestration Layer │ │ Query Engine │ Router │ Planner │ Evaluator │ ├──────────────────────────────────────────────────┤ │ Data Layer │ │ ┌──────────┐ ┌──────────┐ ┌──────────────────┐ │ │ │ Ingestion│ │ Indexing │ │ Retrieval │ │ │ │ Pipeline │ │ (多索引) │ │ (混合检索) │ │ │ └──────────┘ └──────────┘ └──────────────────┘ │ ├──────────────────────────────────────────────────┤ │ Integration Layer │ │ 50+ LLM │ 30+ Vector DB │ 100+ Data Source │ └──────────────────────────────────────────────────┘ 版本对比 特性 LlamaIndex 0.10 (2024) LlamaIndex 1.0 (2026) 核心定位 RAG 框架 Agent 平台 Agent 支持 实验性 一等公民 Workflow 不支持 事件驱动 Workflow 多模态 基础 原生多模态 评估 离线评估 在线评估 + A/B 测试 部署 Python 脚本 LlamaCloud + 本地 性能 中等 优化 40-60% 核心新特性 1. Workflows：事件驱动编排 LlamaIndex 2026 的 Workflow 系统采用事件驱动模型，与 LangGraph 的状态机模型形成对比： ...

从 RAG 到 Agentic RAG 的范式转移 传统 RAG 是一个线性的流水线：检索→拼接→生成。它被动地执行预定义的步骤，没有自主决策能力。而 Agentic RAG 将 LLM Agent 作为核心控制器，赋予 RAG 系统"思考"和"行动"的能力。 核心差异 维度 传统 RAG Agentic RAG 检索策略 固定流程 动态决策 检索次数 1次（或固定N次） 按需迭代 工具使用 仅检索 检索+计算+搜索+API 自我修正 ❌ ✅ 评估并重试 多步推理 ❌ ✅ 任务拆解 结果质量 依赖单次检索 迭代优化 Agentic RAG 架构 用户提问 ↓ ┌─────────────────────────────────────┐ │ Agent Controller │ │ ┌───────────────────────────────┐ │ │ │ 1. 意图理解 & 任务规划 │ │ │ │ 2. 工具选择 & 执行 │ │ │ │ 3. 结果评估 & 决策 │ │ │ │ 4. 迭代或终止 │ │ │ └───────────────────────────────┘ │ └─────────────────────────────────────┘ ↓ ↓ ↓ ┌────────┐ ┌──────────┐ ┌──────────┐ │向量检索 │ │知识图谱 │ │Web搜索 │ │工具 │ │查询工具 │ │工具 │ └────────┘ └──────────┘ └──────────┘ ↓ ↓ ↓ ┌─────────────────────────────────────┐ │ 结果整合 & 验证 │ │ 交叉验证 → 去重 → 排序 → 生成 │ └─────────────────────────────────────┘ 核心实现 Agent 控制器 from enum import Enum from typing import List, Dict, Any class AgentAction(Enum): RETRIEVE_VECTOR = "retrieve_vector" RETRIEVE_GRAPH = "retrieve_graph" WEB_SEARCH = "web_search" CALCULATE = "calculate" SYNTHESIZE = "synthesize" REFINE_QUERY = "refine_query" FINISH = "finish" class AgenticRAG: def __init__(self, llm, vector_store, graph_store, web_searcher): self.llm = llm self.tools = { AgentAction.RETRIEVE_VECTOR: self._retrieve_vector, AgentAction.RETRIEVE_GRAPH: self._retrieve_graph, AgentAction.WEB_SEARCH: self._web_search, AgentAction.CALCULATE: self._calculate, } self.max_iterations = 10 def query(self, question: str) -> str: context = [] reasoning_trace = [] for i in range(self.max_iterations): # Agent 决策：下一步做什么？ decision = self._decide_action(question, context, reasoning_trace) reasoning_trace.append({ "iteration": i, "thought": decision.thought, "action": decision.action.value, "action_input": decision.action_input }) if decision.action == AgentAction.FINISH: # 生成最终答案 return self._generate_answer(question, context, reasoning_trace) if decision.action == AgentAction.REFINE_QUERY: question = decision.action_input["refined_query"] continue # 执行工具 tool_result = self.tools[decision.action](**decision.action_input) context.append(tool_result) # 评估结果质量 evaluation = self._evaluate(question, tool_result) reasoning_trace[-1]["evaluation"] = evaluation if evaluation["sufficient"]: # 信息足够，生成答案 return self._generate_answer(question, context, reasoning_trace) return self._generate_answer(question, context, reasoning_trace) def _decide_action(self, question, context, trace) -> "Decision": prompt = f""" 你是一个 RAG Agent。根据当前状态决定下一步行动。 问题：{question} 已收集的上下文： {self._format_context(context)} 推理历史： {self._format_trace(trace)} 可选行动： 1. retrieve_vector - 向量检索（语义相关信息） 2. retrieve_graph - 图谱查询（实体关系） 3. web_search - 网络搜索（实时信息） 4. calculate - 计算（数值处理） 5. refine_query - 优化查询 6. finish - 信息足够，生成答案 请输出 JSON： {{"thought": "思考过程", "action": "行动名称", "action_input": {{...}}}} """ result = self.llm.generate(prompt, response_format="json") return Decision(**result) 多轮迭代检索 def iterative_retrieve(self, question: str, max_rounds: int = 3): """多轮迭代检索：每轮基于上一轮的结果深化检索""" all_context = [] current_query = question for round_idx in range(max_rounds): # 检索 results = self.vector_store.search( embed_model.encode(current_query), top_k=10 ) # 评估检索结果 relevance = self._assess_relevance(question, results) if relevance["score"] > 0.8: all_context.extend(results) break # 生成 follow-up query current_query = self._generate_followup_query( question, results, all_context ) all_context.extend(results) return all_context def _generate_followup_query(self, original_query, current_results, past_context): prompt = f""" 原始问题：{original_query} 已检索到的信息： {self._format_results(current_results)} 已有上下文： {self._format_results(past_context)} 信息缺口分析：还有哪些信息需要检索？ 请生成一个更精确的 follow-up 查询。 """ return self.llm.generate(prompt).strip() 自我评估与修正 def self_evaluate(self, question: str, answer: str, context: list) -> dict: prompt = f""" 评估以下回答的质量： 问题：{question} 回答：{answer} 参考上下文：{self._format_context(context)} 请从以下维度评估（0-1分）： 1. 准确性：回答是否与上下文一致？ 2. 完整性：是否回答了问题的所有方面？ 3. 引用性：关键论断是否有引用支撑？ 4. 幻觉率：回答中是否有上下文不支持的内容？ 输出 JSON：{{"accuracy": 0.0, "completeness": 0.0, "citation": 0.0, "hallucination": 0.0, "needs_retry": false, "reason": "..."}} """ return self.llm.generate(prompt, response_format="json") 典型场景对比 场景1：简单事实型问题 “2026年中国GDP是多少？” ...