多模态 RAG 实战：图片与文档混合检索系统的完整构建指南

2026 年 kapa.ai 团队在 Hacker News 分享了他们的图片 RAG 索引实践，引发了开发者社区的广泛讨论——文本 RAG 的天花板远比你想象的低。研究表明，在包含图表、流程图和技术文档的检索场景中，纯文本 RAG 的召回率（Recall）比多模态方案低 30%-50%。如果你的 RAG 系统还在丢弃 PDF 里的图片、忽略截图中的关键信息，那么你很可能在「检索增强」的名义下做着「检索削弱」的事情。

本文将从工程实践角度，完整拆解多模态 RAG 的构建过程——从嵌入模型选型到生产级管线搭建，附完整可运行代码。

🔍 一、为什么文本 RAG 不够用？多模态检索的核心价值

1.1 文本 RAG 的三个致命盲区

传统 RAG 流程是「文档 → 文本提取 → 分块 → 嵌入 → 检索」。这个流程在面对纯文本文档时表现优秀，但在以下场景中会严重失效：

• 技术文档中的架构图：一张微服务架构图承载的信息密度，相当于 500 字的文字描述。文本 RAG 直接丢弃图片，等于丢失了文档的骨架。
• 数据报告中的图表：柱状图、折线图、热力图中的趋势和异常值，OCR 提取后变成无意义的数字列表。
• UI/UX 设计稿：截图中的布局、颜色、交互逻辑，纯文本无法表达。
• 代码仓库截图：Stack Overflow 上大量答案以截图形式存在。

⚠️ **警告：**如果你的文档中有超过 20% 的关键信息以图片形式存在，纯文本 RAG 的端到端准确率会低于 60%。这在技术文档、产品手册、数据报告等场景中非常常见。

1.2 多模态 RAG 的两种架构

当前主流的多模态 RAG 架构分为两大流派：

💡 **提示：**如果你的场景是「给定一个问题，从大量 PDF 中找到包含答案的页面」，优先考虑 ColPali。如果是「根据文字描述找到最相关的图片」，CLIP/SigLIP 更合适。

🛠️ 二、三种嵌入模型深度对比与实战

2.1 CLIP：开山之作，依然好用

CLIP（Contrastive Language-Image Pre-training）是 OpenAI 在 2021 年提出的多模态嵌入模型。尽管已有 5 年历史，它仍然是许多生产系统的首选。

# 使用 transformers 加载 CLIP 模型进行图文嵌入
import torch
from transformers import CLIPProcessor, CLIPModel
from PIL import Image

# 加载模型（首次运行会自动下载 ~1.7GB）
model = CLIPModel.from_pretrained("openai/clip-vit-large-patch14")
processor = CLIPProcessor.from_pretrained("openai/clip-vit-large-patch14")

# 嵌入图片
image = Image.open("architecture_diagram.png")
image_inputs = processor(images=image, return_tensors="pt")
image_embedding = model.get_image_features(**image_inputs)
image_embedding = image_embedding / image_embedding.norm(dim=-1, keepdim=True)  # L2 归一化

# 嵌入文本查询
text_inputs = processor(text=["微服务架构设计"], return_tensors="pt", padding=True)
text_embedding = model.get_text_features(**text_inputs)
text_embedding = text_embedding / text_embedding.norm(dim=-1, keepdim=True)

# 计算相似度
similarity = (image_embedding @ text_embedding.T).item()
print(f"图文相似度: {similarity:.4f}")  # 通常 0.2-0.35 为合理范围

CLIP 的优势在于生态成熟——LangChain、LlamaIndex、Haystack 都有原生支持。但它的弱点也很明显：对中文支持较弱，对细粒度文本（如图片中的小字）识别能力不足。

2.2 SigLIP：Google 的升级方案

SigLIP（Sigmoid Loss for Language Image Pre-training）是 Google 在 2023 年提出的改进方案，用 Sigmoid Loss 替代了 CLIP 的 Softmax Loss，在零样本分类和跨模态检索上都有显著提升。

# 使用 SigLIP 进行多模态嵌入 —— 比 CLIP 精度更高
import torch
from transformers import AutoProcessor, AutoModel
from PIL import Image
import requests

# 加载 SigLIP 模型
processor = AutoProcessor.from_pretrained("google/siglip-so400m-patch14-384")
model = AutoModel.from_pretrained("google/siglip-so400m-patch14-384")

# 批量处理多张图片
image_paths = ["diagram1.png", "screenshot2.png", "chart3.png"]
images = [Image.open(p) for p in image_paths]

# 批量嵌入
inputs = processor(images=images, return_tensors="pt")
with torch.no_grad():
    image_embeds = model.get_image_features(**inputs)
    image_embeds = image_embeds / image_embeds.norm(dim=-1, keepdim=True)

# 查询嵌入
text_inputs = processor(text=["系统架构图", "性能监控面板", "销售数据趋势"], return_tensors="pt", padding=True)
with torch.no_grad():
    text_embeds = model.get_text_features(**text_inputs)
    text_embeds = text_embeds / text_embeds.norm(dim=-1, keepdim=True)

# 计算相似度矩阵
similarity_matrix = (image_embeds @ text_embeds.T).numpy()
print("相似度矩阵:")
print(similarity_matrix)
# 输出示例:
# [[0.31 0.08 0.05]   <- diagram1 与 "系统架构图" 最匹配
#  [0.06 0.29 0.12]   <- screenshot2 与 "性能监控面板" 最匹配
#  [0.04 0.10 0.33]]  <- chart3 与 "销售数据趋势" 最匹配

📌 **记住：**SigLIP 的 so400m 版本（400M 参数）在大多数基准测试上超过了 CLIP 的 ViT-L/14（428M 参数），是 2026 年通用多模态嵌入的首选。

2.3 ColPali：文档理解的颠覆者

ColPali 是 2024 年提出的革命性方法——它不提取文档文本，而是直接用视觉模型理解文档页面的视觉布局，生成多向量表示。这彻底改变了 PDF/RAG 的游戏规则。

# ColPali 索引构建 —— 直接从 PDF 页面图片生成嵌入
# pip install colpali-engine torch Pillow pdf2image
from colpali_engine.models import ColPali, ColPaliProcessor
from PIL import Image
import torch

# 加载 ColPali 模型
model = ColPali.from_pretrained(
    "vidore/colpali-v1.3",
    torch_dtype=torch.bfloat16,
    device_map="cuda:0",  # 需要 GPU，至少 16GB 显存
)
processor = ColPaliProcessor.from_pretrained("vidore/colpali-v1.3")

# 将 PDF 页面转为图片（需要 poppler-utils）
from pdf2image import convert_from_path
pages = convert_from_path("technical_report.pdf", dpi=144)

# 为每个页面生成多向量嵌入
# ColPali 的独特之处：每个页面生成 ~1000 个 patch 向量，而非单个向量
for i, page_img in enumerate(pages):
    inputs = processor(images=page_img).to(model.device)
    with torch.no_grad():
        page_embedding = model(**inputs)  # shape: [1, 1030, 128]

    # 存储时需要保存所有 patch 向量
    # 向量维度: 1030 个 patch × 128 维 = 每页 ~500KB
    torch.save(page_embedding.cpu(), f"page_{i}_embedding.pt")
    print(f"页面 {i+1}: 生成 {page_embedding.shape[1]} 个 patch 向量")

ColPali 的检索过程也不同——它使用 MaxSim（最大相似度）操作来计算查询与文档的匹配分数：

# ColPali 检索：使用 MaxSim 计算查询-文档相关性
def maxsim_retrieval(query_embedding, page_embeddings):
    """
    ColPali 的核心检索算法：MaxSim
    对于查询的每个 token 向量，找到文档中与之最相似的 patch 向量，
    然后对所有 token 取平均。
    """
    scores = []
    for page_emb in page_embeddings:
        # query_emb: [1, Q_len, 128], page_emb: [1, P_len, 128]
        sim_matrix = torch.matmul(
            query_embedding.squeeze(0),      # [Q_len, 128]
            page_emb.squeeze(0).T            # [128, P_len]
        )  # -> [Q_len, P_len]

        # 对每个 query token，取最大的 patch 相似度，然后求平均
        max_sim_per_token = sim_matrix.max(dim=1).values  # [Q_len]
        score = max_sim_per_token.mean().item()
        scores.append(score)

    return scores

# 查询示例
query_inputs = processor(text="系统性能瓶颈在哪里？").to(model.device)
with torch.no_grad():
    query_emb = model(**query_inputs)

# 检索最相关的页面
scores = maxsim_retrieval(query_emb, all_page_embeddings)
top_pages = sorted(enumerate(scores), key=lambda x: x[1], reverse=True)[:3]
for page_idx, score in top_pages:
    print(f"页面 {page_idx + 1}: 相关性分数 {score:.4f}")

🚀 三、生产级多模态 RAG 管线构建

3.1 完整管线架构

一个生产级多模态 RAG 系统包含以下阶段：

文档输入 → 内容提取 → 多模态分块 → 嵌入生成 → 向量存储 → 混合检索 → 上下文组装 → LLM 生成
   │           │           │            │           │           │
   │        文本+图片    文本块+图片块   统一向量空间   Milvus/      关键词+向量
   │        分离提取    关联元数据      CLIP/SigLIP   Qdrant       + Reranker

3.2 图片分块策略

图片的「分块」不像文本那么简单——你需要决定：是整张图作为一个块，还是切割成子区域？

# 图片分块策略：根据图片类型选择不同处理方式
from PIL import Image
import base64
from io import BytesIO

class MultiModalChunker:
    """多模态文档分块器"""

    def __init__(self, max_image_size=(1024, 1024)):
        self.max_image_size = max_image_size

    def chunk_page(self, page_image: Image.Image, page_text: str, page_num: int):
        """将一个文档页面分为文本块和图片块"""
        chunks = []

        # 策略 1：小图（< 200px）内嵌到文本块中
        if self._is_small_image(page_image):
            img_b64 = self._image_to_base64(page_image)
            chunks.append({
                "type": "text_with_image",
                "text": page_text,
                "image": img_b64,
                "metadata": {"page": page_num, "strategy": "inline"}
            })
            return chunks

        # 策略 2：大图 —— 图文分离，建立关联
        # 文本块
        if page_text.strip():
            chunks.append({
                "type": "text",
                "text": page_text,
                "metadata": {"page": page_num, "has_image": True}
            })

        # 图片块 —— 压缩到合理大小
        resized = self._resize_image(page_image)
        chunks.append({
            "type": "image",
            "image": self._image_to_base64(resized),
            "text": f"[图片: 文档第 {page_num} 页]",
            "metadata": {"page": page_num, "dimensions": resized.size}
        })

        # 策略 3：超大图（如长页面截图）—— 切片
        if page_image.height > 2000:
            slices = self._slice_vertical(page_image, slice_height=800, overlap=100)
            for i, slice_img in enumerate(slices):
                chunks.append({
                    "type": "image_slice",
                    "image": self._image_to_base64(slice_img),
                    "text": f"[图片切片: 第 {page_num} 页, 区域 {i+1}/{len(slices)}]",
                    "metadata": {"page": page_num, "slice_index": i}
                })

        return chunks

    def _is_small_image(self, img):
        return img.width < 200 and img.height < 200

    def _resize_image(self, img):
        img.thumbnail(self.max_image_size, Image.LANCZOS)
        return img

    def _image_to_base64(self, img):
        buffer = BytesIO()
        img.save(buffer, format="WEBP", quality=85)  # WebP 比 PNG 小 60%
        return base64.b64encode(buffer.getvalue()).decode()

    def _slice_vertical(self, img, slice_height=800, overlap=100):
        slices = []
        y = 0
        while y < img.height:
            end_y = min(y + slice_height, img.height)
            slices.append(img.crop((0, y, img.width, end_y)))
            y += slice_height - overlap
        return slices

⚠️ **警告：**图片切片时务必保留重叠区域（overlap），否则关键信息可能被切断在两个切片的边界上。推荐 overlap 为切片高度的 10%-15%。

3.3 端到端管线实现

下面是一个使用 CLIP + Milvus 的完整多模态 RAG 管线：

# 完整的多模态 RAG 管线：从索引到检索
import torch
from transformers import CLIPProcessor, CLIPModel
from pymilvus import Collection, FieldSchema, CollectionSchema, DataType, connections
from PIL import Image
import numpy as np

class MultimodalRAGPipeline:
    """多模态 RAG 管线 —— 支持图片和文本的混合检索"""

    def __init__(self, clip_model_name="openai/clip-vit-large-patch14"):
        # 初始化 CLIP 模型
        self.model = CLIPModel.from_pretrained(clip_model_name)
        self.processor = CLIPProcessor.from_pretrained(clip_model_name)
        self.model.eval()

        # 连接 Milvus 向量数据库
        connections.connect("default", host="localhost", port="19530")
        self._init_collection()

    def _init_collection(self):
        """创建 Milvus 集合"""
        fields = [
            FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=True),
            FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=768),
            FieldSchema(name="content_type", dtype=DataType.VARCHAR, max_length=20),  # "text" 或 "image"
            FieldSchema(name="text_content", dtype=DataType.VARCHAR, max_length=8192),
            FieldSchema(name="image_path", dtype=DataType.VARCHAR, max_length=512),
            FieldSchema(name="source_page", dtype=DataType.INT64),
            FieldSchema(name="source_doc", dtype=DataType.VARCHAR, max_length=256),
        ]
        schema = CollectionSchema(fields, description="Multi-modal RAG chunks")
        self.collection = Collection("multimodal_rag", schema)

        # 创建向量索引
        index_params = {
            "metric_type": "COSINE",
            "index_type": "IVF_FLAT",
            "params": {"nlist": 256}
        }
        self.collection.create_index("embedding", index_params)

    def embed_text(self, text: str) -> np.ndarray:
        """文本嵌入"""
        inputs = self.processor(text=[text], return_tensors="pt", padding=True, truncation=True)
        with torch.no_grad():
            emb = self.model.get_text_features(**inputs)
        return (emb / emb.norm(dim=-1, keepdim=True)).numpy().flatten()

    def embed_image(self, image_path: str) -> np.ndarray:
        """图片嵌入"""
        image = Image.open(image_path).convert("RGB")
        inputs = self.processor(images=image, return_tensors="pt")
        with torch.no_grad():
            emb = self.model.get_image_features(**inputs)
        return (emb / emb.norm(dim=-1, keepdim=True)).numpy().flatten()

    def index_chunks(self, chunks: list[dict]):
        """批量索引文本和图片块"""
        embeddings = []
        content_types = []
        text_contents = []
        image_paths = []
        source_pages = []
        source_docs = []

        for chunk in chunks:
            if chunk["type"] in ("text", "text_with_image"):
                emb = self.embed_text(chunk["text"])
                content_types.append("text")
                text_contents.append(chunk["text"][:8192])
                image_paths.append("")
            elif chunk["type"] in ("image", "image_slice"):
                emb = self.embed_image(chunk["image_path"])
                content_types.append("image")
                text_contents.append(chunk.get("text", ""))
                image_paths.append(chunk["image_path"])

            embeddings.append(emb.tolist())
            source_pages.append(chunk["metadata"].get("page", 0))
            source_docs.append(chunk["metadata"].get("source", ""))

        # 批量插入
        self.collection.insert([
            embeddings, content_types, text_contents,
            image_paths, source_pages, source_docs
        ])
        self.collection.flush()
        print(f"✅ 索引完成: {len(chunks)} 个块已入库")

    def search(self, query: str, top_k: int = 5) -> list[dict]:
        """混合检索：同时搜索文本和图片"""
        query_emb = self.embed_text(query)

        self.collection.load()
        results = self.collection.search(
            data=[query_emb.tolist()],
            anns_field="embedding",
            param={"metric_type": "COSINE", "params": {"nprobe": 32}},
            limit=top_k,
            output_fields=["content_type", "text_content", "image_path", "source_page", "source_doc"]
        )

        retrieved = []
        for hit in results[0]:
            retrieved.append({
                "score": hit.score,
                "type": hit.entity.get("content_type"),
                "text": hit.entity.get("text_content"),
                "image_path": hit.entity.get("image_path"),
                "page": hit.entity.get("source_page"),
                "doc": hit.entity.get("source_doc"),
            })
        return retrieved

# 使用示例
pipeline = MultimodalRAGPipeline()
results = pipeline.search("系统的性能监控架构是怎样的？", top_k=5)
for r in results:
    icon = "📄" if r["type"] == "text" else "🖼️"
    print(f"{icon} [{r['type']}] (score: {r['score']:.4f}) {r['text'][:100]}")

💡 **提示：**CLIP ViT-L/14 的嵌入维度是 768。如果切换到 SigLIP so400m，维度变为 1152，需要同步修改 Milvus 的 dim 参数。

3.4 检索质量优化

多模态 RAG 的检索质量优化比纯文本 RAG 更复杂——你需要同时优化文本检索和图片检索。

推荐的做法是组合使用：先用 CLIP/SigLIP 做初始召回，再用 Cross-encoder 做精排。

# Cross-encoder Reranking 用于多模态检索的精排
# pip install sentence-transformers
from sentence_transformers import CrossEncoder

class MultimodalReranker:
    """对多模态检索结果进行精排"""

    def __init__(self, model_name="cross-encoder/ms-marco-MiniLM-L-6-v2"):
        self.reranker = CrossEncoder(model_name)

    def rerank(self, query: str, candidates: list[dict], top_k: int = 3) -> list[dict]:
        """对候选结果进行精排"""
        pairs = []
        for c in candidates:
            # 图片类型的候选需要用其描述文本参与排序
            if c["type"] == "image":
                text = c.get("text", "[图片]")  # 使用图片描述或 caption
            else:
                text = c.get("text", "")[:512]  # 截断避免过长
            pairs.append([query, text])

        scores = self.reranker.predict(pairs)

        # 合并分数并排序
        for i, score in enumerate(scores):
            candidates[i]["rerank_score"] = float(score)

        reranked = sorted(candidates, key=lambda x: x["rerank_score"], reverse=True)
        return reranked[:top_k]

# 使用示例
reranker = MultimodalReranker()
raw_results = pipeline.search("系统瓶颈分析", top_k=20)  # 先召回 20 个
final_results = reranker.rerank("系统瓶颈分析", raw_results, top_k=5)  # 精排取 5 个

⚡ 四、性能基准与成本分析

4.1 嵌入模型性能对比

在 NVIDIA A100 (80GB) 上的基准测试结果：

⚡ **关键结论：**对于大多数生产场景，SigLIP SO400M 是性价比最高的选择——精度超过 CLIP ViT-L/14，延迟接近 CLIP ViT-B/32。只有在需要页面级文档理解时，才值得为 ColPali 付出 6 倍的延迟代价。

4.2 成本估算

以索引 10,000 页 PDF 文档为例（假设每页含 1 张图片 + 500 字文本）：

💡 **提示：**自托管开源模型（CLIP/SigLIP）在大规模场景下的成本优势极其明显——10,000 页文档的全生命周期成本（计算+存储+检索）不到 API 方案的 1/10。

✅ 五、最佳实践与避坑指南

5.1 六条实战经验

经过多个生产项目的验证，以下是多模态 RAG 的核心实践：

• ✅ 先做文本 RAG，再加图片：不要一上来就搞多模态。先确保纯文本 RAG 的基线质量达标，再逐步引入图片检索。
• ✅ 图片预处理是关键：统一图片分辨率、去噪、增强对比度，对嵌入质量影响巨大。
• ✅ 为图片生成 Caption：用 BLIP-2 或 LLaVA 为每张图片生成文字描述，存入文本索引，形成「双重索引」。
• ✅ 使用 WebP 格式存储图片：比 PNG 小 60%，比 JPEG 小 25%，且支持透明通道。
• ✅ 建立图片-文本关联元数据：每张图片必须关联其所在页面的文本内容，便于检索时组装上下文。
• ❌ 不要用 OCR 代替图片理解：OCR 只能提取文字，无法理解图表、流程图、UI 截图的语义信息。
• ❌ 不要忽略图片去重：同一张 logo 图片出现在 100 个页面中，会导致检索结果严重偏向该图片。
• ⚠️ ColPali 需要 GPU：至少 16GB 显存。没有 GPU 的团队请选择 CLIP/SigLIP 方案。

5.2 常见坑点

坑点 1：图文嵌入空间不对齐

不同版本的 CLIP 模型生成的向量空间不同。如果你用 CLIP ViT-B/32 索引图片，但用 CLIP ViT-L/14 检索文本，检索结果会完全随机。确保索引和检索使用同一模型。

坑点 2：图片分辨率过高导致内存爆炸

一张 4K 截图（3840×2160）在 CLIP 中会占用约 120MB 内存。批量处理时很容易 OOM。务必在嵌入前将图片缩放到模型要求的输入尺寸（CLIP 为 224×224，SigLIP 为 384×384）。

坑点 3：向量数据库维度不匹配

切换嵌入模型后忘记更新 Milvus/Pinecone 的维度配置，会导致写入失败或检索结果混乱。建议在配置中用环境变量统一管理模型名称和维度。

📝 总结

多模态 RAG 不是「锦上添花」，而是处理包含图片的技术文档时的必需能力。核心选型建议：

• 🎯 通用场景（图片搜索、商品匹配）：SigLIP SO400M + Milvus/Qdrant
• 🎯 文档问答（PDF、技术手册）：ColPali + Vespa/Qdrant
• 🎯 预算有限（无 GPU）：CLIP ViT-B/32 + ChromaDB
• 🎯 追求极致精度：SigLIP 初始召回 + Cross-encoder 精排 + Caption 双重索引

⚡ **关键结论：**2026 年，多模态嵌入模型的推理成本已经降低到可以在单张消费级 GPU（RTX 4060 8GB）上运行 SigLIP 的水平。没有理由再丢弃文档中的图片了。

相关工具推荐：

• 📦 CLIP — OpenAI 多模态嵌入模型
• 📦 ColPali — 视觉文档检索引擎
• 📦 Milvus — 开源向量数据库，支持多模态索引
• 📦 pdf2image — PDF 页面转图片
• 📦 BLIP-2 — 图片 Caption 生成模型
• 🔧 jsjson.com JSON 格式化工具 — 处理 RAG 系统中的 JSON 配置和元数据