响应合成器 #
概述 #
响应合成器（Response Synthesizer）负责将检索到的节点合成为最终回答。选择合适的合成模式对回答质量至关重要。
text
┌─────────────────────────────────────────────────────────────┐
│ 响应合成器架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ Retrieved Nodes │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Node 1 │ │ Node 2 │ │ Node 3 │ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ │ │ │ │
│ └───────────┼───────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Response Synthesizer │ │
│ │ │ │
│ │ 1. 处理节点（合并/迭代/分层） │ │
│ │ 2. 构建提示词 │ │
│ │ 3. 调用 LLM 生成回答 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Response │ │
│ │ "根据检索到的信息，回答如下..." │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
基本用法 #
使用默认合成器 #
python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
documents = SimpleDirectoryReader("./data").load_data()
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()
response = query_engine.query("你的问题")
print(response)
指定响应模式 #
python
query_engine = index.as_query_engine(
response_mode="compact"
)
response = query_engine.query("你的问题")
直接使用合成器 #
python
from llama_index.core import VectorStoreIndex, get_response_synthesizer
index = VectorStoreIndex.from_documents(documents)
response_synthesizer = get_response_synthesizer(
response_mode="compact"
)
query_engine = index.as_query_engine(
response_synthesizer=response_synthesizer,
)
响应模式详解 #
Compact 模式 #
将所有节点合并后一次性生成回答：
text
┌─────────────────────────────────────────────────────────────┐
│ Compact 模式 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 流程： │
│ Node1 + Node2 + Node3 ──→ 合并 ──→ 单次 LLM 调用 ──→ 回答 │
│ │
│ 特点： │
│ ✅ 速度快，只需一次 LLM 调用 │
│ ✅ 适合节点数量较少的场景 │
│ ⚠️ 可能丢失部分细节 │
│ │
│ 适用场景： │
│ - 一般问答 │
│ - 快速响应需求 │
│ - 节点数量 < 5 │
│ │
└─────────────────────────────────────────────────────────────┘
python
from llama_index.core import get_response_synthesizer
synthesizer = get_response_synthesizer(
response_mode="compact",
verbose=True,
)
query_engine = index.as_query_engine(
response_synthesizer=synthesizer,
)
Refine 模式 #
逐个节点迭代优化回答：
text
┌─────────────────────────────────────────────────────────────┐
│ Refine 模式 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 流程： │
│ Node1 ──→ 初始回答 │
│ ↓ │
│ Node2 + 初始回答 ──→ 优化回答 │
│ ↓ │
│ Node3 + 优化回答 ──→ 最终回答 │
│ │
│ 特点： │
│ ✅ 回答更全面、更精细 │
│ ✅ 逐步整合信息 │
│ ⚠️ 需要多次 LLM 调用 │
│ ⚠️ 速度较慢 │
│ │
│ 适用场景： │
│ - 需要高质量回答 │
│ - 信息分散在多个节点 │
│ - 复杂问题 │
│ │
└─────────────────────────────────────────────────────────────┘
python
from llama_index.core import get_response_synthesizer
synthesizer = get_response_synthesizer(
response_mode="refine",
verbose=True,
)
query_engine = index.as_query_engine(
response_synthesizer=synthesizer,
)
Tree Summarize 模式 #
分层总结后合并：
text
┌─────────────────────────────────────────────────────────────┐
│ Tree Summarize 模式 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 流程： │
│ Node1 + Node2 ──→ 摘要1 │
│ Node3 + Node4 ──→ 摘要2 │
│ Node5 + Node6 ──→ 摘要3 │
│ ↓ ↓ ↓ │
│ 摘要1 + 摘要2 + 摘要3 ──→ 最终摘要 │
│ │
│ 特点： │
│ ✅ 适合大量节点 │
│ ✅ 层级化处理 │
│ ⚠️ 可能丢失细节 │
│ │
│ 适用场景： │
│ - 文档总结 │
│ - 大量节点的场景 │
│ - 需要综合概览 │
│ │
└─────────────────────────────────────────────────────────────┘
python
from llama_index.core import get_response_synthesizer
synthesizer = get_response_synthesizer(
response_mode="tree_summarize",
verbose=True,
)
query_engine = index.as_query_engine(
response_synthesizer=synthesizer,
)
Simple Summarize 模式 #
简单拼接后生成：
python
from llama_index.core import get_response_synthesizer
synthesizer = get_response_synthesizer(
response_mode="simple_summarize",
)
query_engine = index.as_query_engine(
response_synthesizer=synthesizer,
)
No Text 模式 #
不生成回答，只返回节点：
python
from llama_index.core import get_response_synthesizer
synthesizer = get_response_synthesizer(
response_mode="no_text",
)
query_engine = index.as_query_engine(
response_synthesizer=synthesizer,
)
response = query_engine.query("查询内容")
for node in response.source_nodes:
print(node.node.text)
Accumulate 模式 #
对每个节点单独生成回答：
python
from llama_index.core import get_response_synthesizer
synthesizer = get_response_synthesizer(
response_mode="accumulate",
)
query_engine = index.as_query_engine(
response_synthesizer=synthesizer,
)
response = query_engine.query("查询内容")
print(response)
自定义提示词 #
自定义 QA 提示词 #
python
from llama_index.core import PromptTemplate, get_response_synthesizer
qa_prompt_tmpl = (
"你是一个专业的助手。请根据以下上下文信息回答问题。\n"
"如果上下文中没有相关信息，请明确说明。\n\n"
"上下文信息：\n"
"---------------------\n"
"{context_str}\n"
"---------------------\n\n"
"问题：{query_str}\n\n"
"回答："
)
qa_prompt = PromptTemplate(qa_prompt_tmpl)
synthesizer = get_response_synthesizer(
response_mode="compact",
text_qa_template=qa_prompt,
)
query_engine = index.as_query_engine(
response_synthesizer=synthesizer,
)
自定义 Refine 提示词 #
python
from llama_index.core import PromptTemplate, get_response_synthesizer
refine_prompt_tmpl = (
"你是一个专业的助手。你已经有了一个初始回答。\n"
"请根据新的上下文信息优化这个回答。\n\n"
"原始问题：{query_str}\n\n"
"初始回答：{existing_answer}\n\n"
"新的上下文信息：\n"
"---------------------\n"
"{context_msg}\n"
"---------------------\n\n"
"请优化回答，使其更加准确和完整："
)
refine_prompt = PromptTemplate(refine_prompt_tmpl)
synthesizer = get_response_synthesizer(
response_mode="refine",
refine_template=refine_prompt,
)
高级配置 #
使用 Refine 合成器 #
python
from llama_index.core.response_synthesizers import Refine
synthesizer = Refine(
llm=llm,
text_qa_template=qa_prompt,
refine_template=refine_prompt,
verbose=True,
)
query_engine = index.as_query_engine(
response_synthesizer=synthesizer,
)
使用 CompactAndRefine 合成器 #
python
from llama_index.core.response_synthesizers import CompactAndRefine
synthesizer = CompactAndRefine(
llm=llm,
text_qa_template=qa_prompt,
refine_template=refine_prompt,
verbose=True,
)
query_engine = index.as_query_engine(
response_synthesizer=synthesizer,
)
使用 TreeSummarize 合成器 #
python
from llama_index.core.response_synthesizers import TreeSummarize
synthesizer = TreeSummarize(
llm=llm,
summary_template=summary_prompt,
verbose=True,
)
query_engine = index.as_query_engine(
response_synthesizer=synthesizer,
)
流式响应 #
python
from llama_index.core import get_response_synthesizer
synthesizer = get_response_synthesizer(
response_mode="compact",
streaming=True,
)
query_engine = index.as_query_engine(
response_synthesizer=synthesizer,
)
response = query_engine.query("你的问题")
for text in response.response_gen:
print(text, end="", flush=True)
print()
异步响应 #
python
import asyncio
from llama_index.core import get_response_synthesizer
async def async_query():
synthesizer = get_response_synthesizer(
response_mode="compact",
)
query_engine = index.as_query_engine(
response_synthesizer=synthesizer,
)
response = await query_engine.aquery("你的问题")
print(response)
asyncio.run(async_query())
响应模式选择指南 #
text
┌─────────────────────────────────────────────────────────────┐
│ 响应模式选择指南 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 场景 推荐模式 │
│ ───────────────────────────────────────────────────────── │
│ 一般问答 compact │
│ 需要高质量回答 refine │
│ 文档总结 tree_summarize │
│ 大量节点 tree_summarize │
│ 只需要检索结果 no_text │
│ 每个节点独立回答 accumulate │
│ 快速响应 compact / simple_summarize │
│ │
└─────────────────────────────────────────────────────────────┘
完整示例 #
python
import os
from llama_index.core import (
VectorStoreIndex,
SimpleDirectoryReader,
Settings,
PromptTemplate,
get_response_synthesizer,
)
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding
os.environ["OPENAI_API_KEY"] = "sk-your-key"
Settings.llm = OpenAI(model="gpt-4o-mini")
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")
documents = SimpleDirectoryReader("./data").load_data()
index = VectorStoreIndex.from_documents(documents)
qa_prompt = PromptTemplate(
"你是一个专业的技术助手。请根据上下文回答问题。\n\n"
"上下文：\n{context_str}\n\n"
"问题：{query_str}\n\n"
"回答："
)
print("\n=== Compact 模式 ===")
compact_synthesizer = get_response_synthesizer(
response_mode="compact",
text_qa_template=qa_prompt,
)
compact_engine = index.as_query_engine(response_synthesizer=compact_synthesizer)
response = compact_engine.query("文档的主要内容是什么？")
print(response)
print("\n=== Refine 模式 ===")
refine_synthesizer = get_response_synthesizer(
response_mode="refine",
text_qa_template=qa_prompt,
verbose=True,
)
refine_engine = index.as_query_engine(response_synthesizer=refine_synthesizer)
response = refine_engine.query("详细解释文档的核心概念")
print(response)
print("\n=== Tree Summarize 模式 ===")
tree_synthesizer = get_response_synthesizer(
response_mode="tree_summarize",
text_qa_template=qa_prompt,
)
tree_engine = index.as_query_engine(response_synthesizer=tree_synthesizer)
response = tree_engine.query("总结所有文档的主要内容")
print(response)
下一步 #
掌握响应合成器后，接下来学习 RAG 高级技术 探索更多 RAG 优化策略！
最后更新：2026-03-30