1. 多模态本地搜索：为什么文件多了之后，传统搜索就不够用了？

相信不少开发者和内容创作者都有这样的经历：电脑里存了上万张图片、几十个视频素材，某天想找一张“去年活动海报里带蓝色背景的那张图”，或者想定位某个视频里“主角出现在第几分钟”的画面，传统文件管理器只能按文件名、修改日期、类型过滤，完全帮不上忙。

即使你把文件命名得再规范，也挡不住素材量增长到一定程度后的检索困难。更麻烦的是，图片和视频本身是“非结构化数据”，没有干净的字段可以索引。想搜图片中的物体、场景、文字，想搜视频中的某一帧画面，传统基于文件名的搜索根本无法理解内容语义。

这时候就需要引入 多模态本地搜索 ：让机器像人一样理解图像、视频、文本之间的关系，在本地环境完成“以文搜图”“以图搜图”“以文搜视频片段”等操作。腾讯开源生态中已经有相关方向的多模态检索项目出现，这里不讨论某一个特定仓库的名字和版本，而是围绕 多模态本地搜索这一技术方向 ，拆解从原理到部署落地的完整方案。整篇文章会覆盖技术概念、环境准备、索引构建、代码示例、常见报错和工程最佳实践，无论你是想给个人素材库做检索工具，还是想在业务系统里实现多模态搜索能力，都可以直接参考。

2. 多模态搜索的核心概念：向量化、嵌入与相似度检索

在动手写代码之前，先理解多模态检索背后最重要的三个概念。只有理解了向量化为什么是“让机器理解图片和视频”的基础，后面调参和排错才不会一头雾水。

2.1 什么是多模态嵌入

“模态”在机器学习里指的是数据的存在形式，比如文本、图像、音频、视频。单模态模型只能处理一种输入，多模态模型则能把不同类型的输入映射到同一个数学空间。

多模态嵌入的核心思想是：用一个神经网络模型，把一张图片压缩成一个固定长度的向量（例如 512 维或 1024 维浮点数数组），把一段文本也压缩成同样长度的向量。然后通过训练让模型学会：语义相近的图文，在向量空间里的距离更近；语义不相关的图文，距离更远。

经典的 CLIP 模型就是这种思路的代表：它把图片和文本分别编码，再通过对比学习拉近匹配图文对的距离。这种“图文对齐”能力正是多模态本地搜索的技术基石。

2.2 相似度检索：向量之间怎么“比大小”

当图片、视频帧、文本都被转换成向量之后，搜索问题就变成了向量检索问题。给定一个查询文本，系统先把它编码成查询向量，然后在海量向量库中查找与查询向量最相似的若干条记录。

常用指标有余弦相似度（Cosine Similarity）和内积（Dot Product）。余弦相似度关注方向一致性，对向量长度不敏感，因此在文本和图文检索中非常常用。计算公式也很简单：

similarity = (A · B) / (||A|| * ||B||)

实际工程中很少暴力遍历所有向量，而是使用近似最近邻（ANN，Approximate Nearest Neighbor）索引来加速。常见开源方案有 Meta 开源的 FAISS、Zilliz 的 Milvus、以及各种 HNSW 图索引实现。

2.3 为什么“本地搜索”有独特价值

把搜索工具部署在本地环境（个人 PC、内网服务器、边缘设备），而不是调用云端 API，主要有三大优势：

1. 数据隐私 ：图片、视频往往包含敏感信息，本地索引可以做到数据不出域。
2. 离线可用 ：内网环境或者无外网环境下，也可以完成索引和检索。
3. 成本可控 ：数据量大时，云 API 的调用费用会快速上升，本地推理一次性投入显卡或 CPU 算力即可。

代价是需要自己管理模型、索引和运维。下面我们就来完整走一遍这套流程。

3. 环境准备与版本说明

多模态模型对运行环境有一定要求，但并不是说没有 3090 或者 A100 就跑不起来。个人素材库规模的检索，CPU 推理虽然慢一些，但也能完成任务；如果数据量达到几十万张图，或者需要实时索引视频，就建议准备一块 NVIDIA 显卡。

3.1 操作系统与 Python 环境

本文示例以 Linux 或 Windows 10/11 为演示环境，Python 版本建议使用 3.9 或 3.10。如果你是 Windows 用户，注意部分深度学习和向量检索库在安装时对 Python 版本比较敏感，建议直接用 Anaconda 创建独立虚拟环境，避免污染系统 Python。

# 创建并激活虚拟环境
conda create -n multimodal-search python=3.10
conda activate multimodal-search

版本需要根据你的项目实际情况调整，本文示例以常见环境为例，重点演示配置思路。如果你的环境是 ARM 架构，或者 CUDA 版本比较特殊，需要额外留意依赖是否提供了对应预编译包。

3.2 核心依赖库

多模态搜索项目通常由四部分依赖组成：

• 模型推理框架 ：负责加载多模态模型并生成向量，常见如 PyTorch。
• 多模态模型库 ：提供预训练模型权重，常见如 Hugging Face Transformers、OpenCLIP。
• 向量检索库 ：负责向量的索引和相似度检索，常见如 FAISS。
• 图像/视频处理库 ：负责读取图片、抽视频帧，常见如 Pillow、OpenCV。

安装示例：

pip install torch torchvision
pip install transformers
pip install faiss-cpu
pip install opencv-python pillow

如果你有 NVIDIA GPU，并且 CUDA 环境已经准备好，可以把 FAISS 替换成 GPU 版本：

pip install faiss-gpu

这里需要特别说明：不同库的版本迭代速度很快，本文不写死具体版本号。你在安装时如果遇到依赖冲突，建议优先查看各库官方文档中列出的兼容版本组合，或者使用 pip check 检查依赖关系。

3.3 模型选择思路

多模态模型的选择范围很广。个人学习和本地小规模数据，可以选择参数量较小的开源 CLIP 系列模型；如果追求更高的图文匹配精度，可以选用更大的开源多模态模型。

模型选型时重点考虑三点：

1. 向量维度 ：不同模型输出的向量维度不同（例如 512 维、768 维、1024 维），维度越高通常表达力越强，但存储和检索开销也越大。
2. 中文支持 ：如果你的素材以中文场景为主，优先选择在中文图文对上训练过的模型，否则中文检索效果会明显下降。
3. 显存占用 ：个人本地部署时，优先选 2GB 显存以内能跑起来的模型，视频抽帧索引才不至于卡顿。

4. 从零实现一个多模态本地搜索工具

这一节是全文的重点。我们将实现一个最小可运行的多模态本地搜索工具，支持：

• 图片素材批量索引
• 以文搜图
• 以图搜图
• 视频关键帧提取、索引与搜索

为了便于理解，我们把整个项目拆成数据准备、索引构建、搜索服务三个模块。

4.1 创建项目结构

建议目录结构如下：

multimodal_search/
├── config.py           # 配置文件
├── index_images.py     # 图片索引脚本
├── index_videos.py     # 视频索引脚本
├── search_engine.py    # 搜索服务
├── data/
│   ├── images/         # 待索引图片
│   └── videos/         # 待索引视频
└── storage/            # 向量索引保存位置

4.2 配置文件

所有可调整参数集中放在 config.py 中，方便后续切换模型和调整检索参数。

# 文件路径：config.py

# 模型名称：这里用 Hugging Face 上常见的 CLIP 模型为例
# 实际名称需要根据你可获取的模型调整
MODEL_NAME = "openai/clip-vit-base-patch32"

# 向量维度，不同模型不一样，需要和模型输出保持一致
VECTOR_DIM = 512

# 图片/视频帧输入尺寸
IMAGE_SIZE = 224

# 向量索引保存路径
FAISS_INDEX_PATH = "storage/faiss_index.bin"
META_PATH = "storage/meta.jsonl"

# 视频抽帧间隔（秒），可根据视频时长和素材类型调整
FRAME_INTERVAL = 2

# 检索返回数量
TOPK = 5

把模型名和向量维度拆出来是为了避免在代码里到处写魔法值。换模型时只需要改配置文件，不需要动业务代码。

4.3 编写向量编码模块

核心功能是加载多模态模型，把图片和文本编码成向量。这里我们封装一个 Encoder 类：

# 文件路径：encoder.py

import torch
import torch.nn.functional as F
from PIL import Image
from transformers import CLIPProcessor, CLIPModel


class Encoder:
    def __init__(self, model_name):
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.model = CLIPModel.from_pretrained(model_name).to(self.device)
        self.processor = CLIPProcessor.from_pretrained(model_name)
        self.model.eval()

    def encode_image(self, image_path: str):
        image = Image.open(image_path).convert("RGB")
        inputs = self.processor(images=image, return_tensors="pt").to(self.device)
        with torch.no_grad():
            image_features = self.model.get_image_features(**inputs)
        # 归一化，便于后续余弦相似度计算
        image_features = F.normalize(image_features, p=2, dim=-1)
        return image_features.cpu().numpy()[0]

    def encode_text(self, text: str):
        inputs = self.processor(text=text, return_tensors="pt").to(self.device)
        with torch.no_grad():
            text_features = self.model.get_text_features(**inputs)
        text_features = F.normalize(text_features, p=2, dim=-1)
        return text_features.cpu().numpy()[0]

这里需要注意几点：

• get_image_features 和 get_text_features 是 CLIP 模型提供的独立编码接口，不要直接走 forward ，否则得到的是图文匹配 logits，不是用于检索的特征向量。
• 归一化是很有必要的。后续使用 FAISS 的内积检索时，归一化后的向量内积就等价于余弦相似度，效果更稳定。
• with torch.no_grad() 能显著减少推理时的显存占用，索引阶段不需要反向传播。

4.4 图片索引构建

有了编码器之后，遍历图片目录，逐张编码并写入 FAISS 索引：

# 文件路径：index_images.py

import os
import json
import faiss
import numpy as np
from tqdm import tqdm
from encoder import Encoder
from config import *


def build_image_index(image_dir: str):
    encoder = Encoder(MODEL_NAME)

    if os.path.exists(FAISS_INDEX_PATH):
        os.remove(FAISS_INDEX_PATH)

    # FAISS 索引：IndexFlatIP 是精确内积检索，数据量小时最准确
    index = faiss.IndexFlatIP(VECTOR_DIM)

    # 保存元数据：每个向量对应的文件路径
    meta_list = []

    image_paths = []
    for root, _, files in os.walk(image_dir):
        for name in files:
            if name.lower().endswith((".jpg", ".jpeg", ".png", ".webp", ".bmp")):
                image_paths.append(os.path.join(root, name))

    print(f"发现 {len(image_paths)} 张图片，开始编码...")

    for img_path in tqdm(image_paths):
        try:
            vec = encoder.encode_image(img_path)
            index.add(np.array([vec], dtype=np.float32))
            meta_list.append({"path": img_path, "type": "image"})
        except Exception as e:
            print(f"处理失败: {img_path}，错误: {e}")
            continue

    # 保存索引和元数据
    os.makedirs("storage", exist_ok=True)
    faiss.write_index(index, FAISS_INDEX_PATH)

    with open(META_PATH, "w", encoding="utf-8") as f:
        for meta in meta_list:
            f.write(json.dumps(meta, ensure_ascii=False) + "\n")

    print(f"索引构建完成，共 {len(meta_list)} 条记录")


if __name__ == "__main__":
    build_image_index("data/images")

说明几点：

• tqdm 用来显示进度，图片量大的时候非常有用。
• 编码失败时不要直接中断整个流程，单张损坏图片跳过即可。
• IndexFlatIP 是暴力精确检索，准确度最高。数据量超过 50 万条时再考虑 IndexIVFFlat 或 IndexHNSWFlat 等近似索引。

4.5 视频索引构建：抽帧与索引

视频本身不是静态内容，直接给整个视频编码并不现实。常规做法是按固定间隔抽帧，把每一帧作为一张“图片”来索引，同时保留帧对应的时间点。

# 文件路径：index_videos.py

import os
import json
import faiss
import numpy as np
import cv2
from tqdm import tqdm
from encoder import Encoder
from config import *


def extract_frames(video_path: str, interval: float):
    """按间隔抽取视频帧，返回帧列表，每帧为 (时间戳, numpy图像)"""
    cap = cv2.VideoCapture(video_path)
    if not cap.isOpened():
        return []

    fps = cap.get(cv2.CAP_PROP_FPS)
    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    frame_step = max(1, int(fps * interval))

    frames = []
    frame_idx = 0
    while True:
        ret, frame = cap.read()
        if not ret:
            break
        if frame_idx % frame_step == 0:
            timestamp = frame_idx / fps
            # BGR 转 RGB，方便和图片编码流程保持一致
            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            frames.append((timestamp, frame_rgb))
        frame_idx += 1

    cap.release()
    return frames


def build_video_index(video_dir: str):
    encoder = Encoder(MODEL_NAME)

    video_paths = []
    for root, _, files in os.walk(video_dir):
        for name in files:
            if name.lower().endswith((".mp4", ".avi", ".mov", ".mkv")):
                video_paths.append(os.path.join(root, name))

    print(f"发现 {len(video_paths)} 个视频，开始抽帧并编码...")

    index = faiss.IndexFlatIP(VECTOR_DIM)
    meta_list = []

    for video_path in tqdm(video_paths):
        frames = extract_frames(video_path, FRAME_INTERVAL)
        print(f"{video_path}: 抽取 {len(frames)} 帧")

        for timestamp, frame in frames:
            # 将 numpy 图像转换为 PIL Image，复用图文编码逻辑
            from PIL import Image
            pil_image = Image.fromarray(frame)
            vec = encoder.encode_image_from_pil(pil_image)
            index.add(np.array([vec], dtype=np.float32))
            meta_list.append({
                "path": video_path,
                "type": "video",
                "timestamp": round(timestamp, 2)
            })

    faiss.write_index(index, FAISS_INDEX_PATH if not os.path.exists(FAISS_INDEX_PATH) else FAISS_INDEX_PATH.replace(".bin", "_video.bin"))

    meta_path = META_PATH.replace(".jsonl", "_video.jsonl")
    with open(meta_path, "w", encoding="utf-8") as f:
        for meta in meta_list:
            f.write(json.dumps(meta, ensure_ascii=False) + "\n")

    print(f"视频索引构建完成，共 {len(meta_list)} 帧记录")

这里需要同步修改 encoder.py ，增加一个接收 PIL Image 对象的方法：

# 在 encoder.py 中新增方法

def encode_image_from_pil(self, image: Image.Image):
    inputs = self.processor(images=image, return_tensors="pt").to(self.device)
    with torch.no_grad():
        image_features = self.model.get_image_features(**inputs)
    image_features = F.normalize(image_features, p=2, dim=-1)
    return image_features.cpu().numpy()[0]

视频抽帧间隔是一个需要权衡的参数：

• 间隔太短，帧数爆炸，索引时间和存储空间都会大幅上升。
• 间隔太长，可能漏掉关键画面。
• 一般建议先按 2 到 5 秒抽帧，观察检索效果后再调整。

对于有字幕或语音讲解较多的视频，可以进一步结合 OCR 或语音识别，把文本信息也纳入索引，形成“视觉 + 文本”的混合检索，但那是进阶方案，本文先不展开。

4.6 搜索服务实现

索引构建完成后，就可以编写检索函数了。给定一句查询文本，编码成向量后，从 FAISS 索引中搜索最相近的 K 条记录：

# 文件路径：search_engine.py

import json
import faiss
import numpy as np
from encoder import Encoder
from config import *


class SearchEngine:
    def __init__(self):
        self.encoder = Encoder(MODEL_NAME)
        self.index = faiss.read_index(FAISS_INDEX_PATH)
        self.meta_list = self._load_meta(META_PATH)

    def _load_meta(self, path):
        metas = []
        with open(path, "r", encoding="utf-8") as f:
            for line in f:
                line = line.strip()
                if line:
                    metas.append(json.loads(line))
        return metas

    def search_by_text(self, query_text: str, topk: int = TOPK):
        vec = self.encoder.encode_text(query_text)
        scores, indices = self.index.search(
            np.array([vec], dtype=np.float32), topk
        )
        results = []
        for score, idx in zip(scores[0], indices[0]):
            if idx < 0:
                continue
            results.append({
                "score": float(score),
                **self.meta_list[idx]
            })
        return results

    def search_by_image(self, image_path: str, topk: int = TOPK):
        vec = self.encoder.encode_image(image_path)
        scores, indices = self.index.search(
            np.array([vec], dtype=np.float32), topk
        )
        results = []
        for score, idx in zip(scores[0], indices[0]):
            if idx < 0:
                continue
            results.append({
                "score": float(score),
                **self.meta_list[idx]
            })
        return results


if __name__ == "__main__":
    engine = SearchEngine()

    print("=== 以文搜图示例 ===")
    query = "一只在草地上奔跑的狗"
    results = engine.search_by_text(query)
    for r in results:
        print(f"相似度: {r['score']:.4f}, 文件: {r['path']}")

    print("\n=== 以图搜图示例 ===")
    results = engine.search_by_image("query_images/example.jpg")
    for r in results:
        print(f"相似度: {r['score']:.4f}, 文件: {r['path']}")

搜索接口返回的结果中不仅包含相似度分数，还保留了文件的路径和类型。对于视频帧，元数据里还有 timestamp ，可以精确告诉用户“在第几分第几秒出现该画面”。

4.7 运行与验证

依次执行下面的命令：

# 1. 把测试图片放到 data/images 目录
# 2. 构建图片索引
python index_images.py

# 3. 搜索测试
python search_engine.py

预期输出类似：

发现 120 张图片，开始编码...
索引构建完成，共 120 条记录

=== 以文搜图示例 ===
相似度: 0.8632, 文件: data/images/dog_running_01.jpg
相似度: 0.8120, 文件: data/images/park_dog_03.jpg

分数越高表示相似度越高。注意不同模型的分数分布区间不一样，有些模型的相似度普遍在 0.6 以上才认为相关，有些则 0.3 就可能语义相近，建议在实际数据上多测试，找到合适的阈值。

5. 多模态搜索的进阶优化：从能用走向好用

最小可运行版本跑通之后，可以按需投入以下优化点。

5.1 使用近似最近邻索引提升检索速度

IndexFlatIP 是精确检索，数据量很大时内存和耗时都会线性增长。如果索引条目超过几十万，推荐换成 IndexHNSWFlat ：

import faiss

# HNSW 图索引，检索速度和精度之间可以调参
index = faiss.IndexHNSWFlat(VECTOR_DIM, 32)  # 32 表示邻接数量
index.hnsw.efConstruction = 200   # 构建索引时的搜索范围，越大越精准但构建越慢
index.hnsw.efSearch = 64          # 检索时的搜索范围，越大越精准但耗时越久

HNSW 是当前工业界非常流行的 ANN 算法，兼顾了高召回率和低查询延迟。如果你的数据本身就有明显的类别结构，也可以考虑 IVF 系列索引。

5.2 重排序：向量检索不是终点

向量检索找到的 top-K 只是“候选集”，并不一定完全精确。更稳妥的做法是：

1. 第一轮用 ANN 索引快速召回 200 条候选。
2. 第二轮用更精确的跨模态模型（或更大的模型）对候选做精细排序，取前 5 条返回。

这种“粗排 + 精排”的架构在搜索系统中非常常见，也是多模态搜索工具达到生产可用水平的关键一步。

5.3 混合检索：叠加 OCR 和音频信息

视频搜索的体验瓶颈往往在于“画面里有文字，但模型没有识别出文字”。例如想搜“视频里出现 'Hello World' 文字的所有画面”，纯视觉特征很难命中。

解决方案是在抽帧后加一步 OCR：

import pytesseract
from PIL import Image

text = pytesseract.image_to_string(pil_image, lang="eng")

OCR 结果可以作为文本字段保存到元数据中，构建一个额外的文本倒排索引（例如使用 Whoosh、Elasticsearch）。查询时先做常规多模态向量检索，再做关键字过滤，两者取交集或者加权融合。

5.4 增量索引与数据更新

本地素材库是动态增长的，每次全量重建索引会非常耗时。更合理的做法是：

• 对新加入的文件，只对新文件编码，追加到已有 FAISS 索引。
• 对删除的文件，在元数据中标记为不可用，定期全量重建清理。
• 对同一目录设置监听（比如 watchdog ），文件变化时自动增量更新。

增量追加 FAISS 索引很简单：

index.add(new_vectors)

但 FAISS 本身不支持删除指定向量，所以生产环境通常需要维护“失效列表”，或者定期重建索引。

6. 常见问题与排查思路

多模态本地搜索在部署和使用阶段有一些高频问题，整理成表格方便快速定位。

问题现象	常见原因	解决思路
安装 faiss 时报错	Python 版本或平台不支持预编译包	使用 conda 安装： conda install -c conda-forge faiss-cpu
编码速度极慢	使用了 CPU 推理，模型又偏大	换小模型；开启 fp16 ；升级到 GPU
中文查询效果差	模型以英文图文训练为主	换用中文多模态模型；在元数据中补充中文关键词
视频抽帧数量过多	抽帧间隔设置太短	提高 FRAME_INTERVAL ；对画面相似度做去重
搜索结果的相似度都偏高	查询词太笼统或模型区分度不足	细化查询描述；换更大参数量模型
索引构建时内存溢出	图片太多且一次性加载	分批编码，每批处理后释放变量；改用磁盘映射索引
换模型后向量维度对不上	配置文件中的 VECTOR_DIM 未更新	统一修改 VECTOR_DIM ，并删除旧索引重建

另一个值得注意的点是：不要在所有素材上盲目追求高精度模型。图片和视频检索任务里，速度往往比一点点精度提升更重要。建立索引时多花一小时，可能拖垮整个更新流程。

7. 工程落地建议与最佳实践

7.1 索引与元数据分离

向量索引只负责“找相似向量”，元数据负责“告诉用户这是什么”。永远不要在向量文件中塞太多业务字段，否则后续更新、迁移都会非常痛苦。建议元数据使用 JSON Lines 或者 SQLite，按行读写方便，也支持按路径去重。

7.2 使用独立的模型服务

如果搜索服务会提供给多个模块使用，强烈建议把模型推理改造成独立服务（例如通过 FastAPI 暴露 HTTP 接口），而不是在业务进程中直接加载模型。原因有两点：

• 模型加载会占用较多内存，多次加载浪费资源。
• 模型推理是 CPU/GPU 密集操作，独立服务更方便做并发控制和水平扩展。

下面是一个简单的 FastAPI 检索服务片段，仅作参考思路：

from fastapi import FastAPI
from search_engine import SearchEngine

app = FastAPI()
engine = SearchEngine()

@app.get("/search")
def search(q: str, topk: int = 5):
    results = engine.search_by_text(q, topk=topk)
    return {"results": results}

7.3 安全与权限边界

涉及多模态内容检索时，需要注意合规与安全边界：

• 本地索引的元数据中可能包含文件路径等敏感信息，跨机器传输时要脱敏。
• 如果搜索服务部署在服务器并对外提供接口，必须加认证鉴权，避免未授权访问导致数据泄露。
• 内部数据处理要遵守最小权限原则，模型文件、索引文件尽量不放在公网可访问目录下。
• 上线生产环境前，先在测试环境完整跑通索引构建、检索、索引重建流程，确认没有副作用再切换。

7.4 显存与性能优化

多模态模型的显存占用主要来自模型权重和中间激活值。如果显存比较紧张，可以尝试：

• 加载模型时使用半精度： from_pretrained(model_name, torch_dtype=torch.float16)
• 推理不用的变量及时 del 并调用 torch.cuda.empty_cache()
• 批量编码，而不是单张循环，利用 batch 提升吞吐

批量编码示例思路：

# 假设 batch_size 为 32
images = []
paths = []
batch_size = 32

for img_path in all_paths:
    img = load_image(img_path)
    images.append(img)
    paths.append(img_path)
    if len(images) == batch_size:
        inputs = processor(images=images, return_tensors="pt").to(device)
        with torch.no_grad():
            feats = model.get_image_features(**inputs)
        # 归一化、保存 feats 和 paths
        images = []
        paths = []

7.5 日志与可观测性

索引任务通常耗时较长，一定要记录足够多的日志：每批处理了多少文件、耗时多少、失败原因是什么。检索服务也要记录查询语句、响应耗时和命中结果，方便后续分析用户搜索意图、优化模型和阈值。

8. 总结与下一步学习方向

基于开源多模态模型和向量检索库，完全可以搭建一套可用的本地搜索工具，让图片、视频素材不再“只可存放，不可检索”。本文实现的核心链路可以概括为：

1. 用多模态编码模型把图片、视频帧转化为高维向量。
2. 用 FAISS 构建向量索引，并保存文件路径、视频时间戳等元数据。
3. 查询时把文本或图片编码为向量，在索引中做相似度检索。
4. 通过近似索引、重排序、OCR 混合检索等机制提升效果。

下一步的方向可以从这几个点深入：

• 尝试不同规模的多模态模型，测量同一批数据上的检索精度和耗时差异。
• 引入更完整的视频理解能力，不单单抽帧，还可以做镜头切换检测、关键人物识别。
• 构建一个 Web 界面，用拖拽上传和实时检索替代命令行。
• 如果数据量达到百万级，考虑迁移到 Milvus 等分布式向量数据库，并接入 Kubernetes 部署。

不要一开始就追求完美，先用最小的数据量跑通闭环，再逐步迭代优化。毕竟，搜索工具的核心价值是“帮助人在海量素材里快速找到目标”，如果你的素材库现在还只有几百张图，直接上大模型和分布式架构反而是过度设计。先动手试试，第一批索引跑起来，你对多模态检索的理解就已经超过大多数停留在概念阶段的人了。

如果这篇文章对你有帮助，建议收藏备用，后续需要给个人素材库或业务系统搭建多模态本地搜索时，可以直接参照这份完整流程操作。