Redis8向量搜索性能飙升87%九大内置数据结构AI全栈

【Redis 硬核系列·第五篇·收官】Redis 8 新纪元：Vector Set 向量搜索、9 大内置数据结构、87% 性能提升，用 Redis 一个库搞定 AI 全栈（含 RAG 完整代码）

系列完整进度

目录

• 一、Redis 8 的革命性变化：从缓存到统一数据平台
• 二、9 大内置数据结构总览
• 三、JSON 数据结构：文档存储与 JSONPath 查询
• 四、时序数据 TimeSeries：IoT 与监控场景
• 五、概率数据结构：Count-Min Sketch / Top-K / t-digest
• 六、Vector Set：向量存储与 HNSW 相似度搜索
• 七、HNSW 算法深度拆解：O(log N) ANN 搜索
• 八、Redis Query Engine：全文检索 + 向量混合搜索
• 九、关键公式：余弦相似度与 HNSW 内存估算
• 十、实战：用 Redis 8 构建完整 RAG 系统

如果一个数据库能同时搞定缓存、JSON 文档存储、时序数据监控、实时热榜统计、P99 延迟分位数计算，甚至直接支持向量搜索和语义检索——你会不会觉得它已经超出了“缓存”的范畴？Redis 8 恰恰做到了这一点。

这一篇作为系列压轴，我们将视角从传统的缓存与架构领域全面转向 Redis 8 带来的质变——那些过去需要额外安装模块、甚至必须更换数据库才能实现的场景，现在只需一个 Redis 实例即可完成。

一、Redis 8 的革命性变化：从缓存到统一数据平台

1.1 什么变了？

Redis 8 新增了 8 种数据结构，包括向量集合（beta）、JSON、时序数据，以及布隆过滤器、布谷鸟过滤器、Count-Min Sketch、Top-K、t-digest 共 5 种概率数据结构——此前这些功能依赖独立安装的 Redis 模块，版本兼容性差，使用体验也不理想。

现在的情况是：

Redis 7 及以前：需要手动 LOADMODULE 才能用 JSON/Search/TimeSeries
Redis 8：一个二进制文件，所有功能内置

# 无需任何 LOADMODULE，直接用：
redis-cli JSON.SET doc $ '{"name":"Alice"}'
redis-cli FT.CREATE idx ON JSON PREFIX 1 doc: SCHEMA $.name AS name TEXT
redis-cli BF.ADD myfilter "item1"
redis-cli TS.CREATE temperature RETENTION 86400000
redis-cli VADD myvectors VALUES 3 0.1 0.2 0.3 "element1"

1.2 Redis 8 的性能数字

Redis 8 是 Redis 历史上性能提升幅度最大的版本——超过 30 项优化，命令执行速度提升 87%，吞吐量翻倍，复制内存节省 35%，Query Engine 处理能力提升 16 倍。

核心动力来自全新的异步 I/O 线程（io-threads 配置）、改进的内存碎片整理以及 30 余项内部优化。

1.3 安装 Redis 8

# Docker（最快）
docker run -d --name redis8 -p 6379:6379 redis:8

# Ubuntu/Debian
curl -fsSL https://packages.redis.io/gpg | gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | tee /etc/apt/sources.list.d/redis.list
apt update && apt install redis

# 验证内置模块
redis-cli MODULE LIST # 应看到 search、json、timeseries、bf 等模块
redis-cli INFO server | grep redis_version # 8.x.x

二、9 大内置数据结构总览

读到这儿你应该已经意识到：Redis 8 早已不是记忆中的那个缓存组件了。下面这张表能帮你快速建立整体认知：

数据结构          命令前缀         典型用途
JSON              JSON.*           文档存储、会话管理、用户画像
TimeSeries        TS.*             IoT传感器、监控指标、金融行情
Bloom Filter      BF.*             去重、防缓存穿透（见第四篇）
Cuckoo Filter     CF.*             支持删除的去重（BF的增强版）
Count-Min Sketch  CMS.*            Top N统计、流量计数、热词频率
Top-K             TOPK.*           实时热榜、热搜词、热商品
t-digest          TDIGEST.*        P99延迟、分位数统计、SLA报告
Vector Set        VADD/VSIM        语义搜索、推荐系统、RAG
Query Engine      FT.*             全文检索、混合查询、聚合

三、JSON 数据结构：文档存储与 JSONPath 查询

3.1 核心命令

如果你之前用 Redis 存过 JSON，一定经历过“序列化成字符串存进去，取出时反序列化再手动改字段”的痛苦。Redis 8 的 JSON 模块直接解决了这个问题——不光能存能查，还能原地更新任意字段，完全不需要把整个文档拉出来。

# 存储 JSON 文档（$ 代表根节点）
JSON.SET product:1001 $ '{"name":"MacBook Pro","price":12999,"category":"laptop","tags":["portable","m3"]}'

# JSONPath 精确查询
JSON.GET product:1001 $.name    # ["MacBook Pro"]
JSON.GET product:1001 $.price   # [12999]

# 原子更新（无需读取整个文档）
JSON.NUMINCRBY product:1001 $.price 1000  # price 变成 13999

# 追加数组元素
JSON.ARRAPPEND product:1001 $.tags '"pro"'  # tags 追加 "pro"

# 条件查询（嵌套）
JSON.GET product:1001 $.tags[0]   # ["portable"]
JSON.OBJKEYS product:1001 $       # 获取所有顶层字段名

3.2 JSON + Search 联合索引（电商搜索）

JSON 和 Search 组合之后，相当于给 Redis 嵌入了“小型搜索引擎”——你可以对 JSON 文档内的特定字段建立索引，然后像写 SQL 一样组合过滤条件：
import redis from redis.commands.search.field import TextField, NumericField, TagField from redis.commands.search.indexDefinition import IndexDefinition, IndexType from redis.commands.search.query import Query r = redis.Redis() # 批量写入商品 products = [ {"name": "MacBook Pro M3", "price": 12999, "category": "laptop", "rating": 4.8}, {"name": "iPad Pro 13", "price": 8999, "category": "tablet", "rating": 4.7}, {"name": "iPhone 16 Pro", "price": 9999, "category": "phone", "rating": 4.9}, ] for i, p in enumerate(products): r.json().set(f"product:{i+1}", "$", p) # 创建 Search 索引 r.ft("idx:products").create_index( fields=[ TextField("$.name", as_name="name"), NumericField("$.price", as_name="price"), TagField("$.category", as_name="category"), NumericField("$.rating", as_name="rating"), ], definition=IndexDefinition(prefix=["product:"], index_type=IndexType.JSON), ) # 搜索：名称含 "Pro"，价格 < 10000，按评分排序 results = r.ft("idx:products").search( Query("@name:Pro @price:[0 10000]").sort_by("rating", asc=False) ) for doc in results.docs: print(doc.name, doc.price, doc.rating)

四、时序数据 TimeSeries：IoT 与监控场景

4.1 核心操作

如果你觉得 Redis 8 做时序数据库的事情有些夸张，但它的 TimeSeries 模块确实支持保留策略、标签维度、自动降采样，甚至还能与其他数据结构配合进行高级分析：

# 创建时序（保留1天数据，带标签）
TS.CREATE temp:sensor1 RETENTION 86400000 LABELS sensor_id 1 location warehouse

# 写入数据点（* = 当前毫秒时间戳）
TS.ADD temp:sensor1 * 22.5
TS.ADD temp:sensor1 * 23.1

# 批量写入（高吞吐场景）
TS.MADD temp:sensor1 1000 22.5 temp:sensor1 2000 23.1 temp:sensor2 1000 19.5

# 范围查询 + 聚合（按小时均值）
TS.RANGE temp:sensor1 - + AGGREGATION a vg 3600000

# 按标签查询多个传感器
TS.MRANGE - + AGGREGATION a vg 3600000 FILTER location=warehouse

# 创建自动降采样规则（原始数据 -> 1小时均值）
TS.CREATE temp:sensor1:hourly RETENTION 2592000000 # 30天
TS.CREATERULE temp:sensor1 temp:sensor1:hourly AGGREGATION a vg 3600000

4.2 监控 P99 延迟（结合 t-digest）

这是一个贴合生产场景的例子。TimeSeries 负责记录原始延迟数据，t-digest 负责计算分位数——两个模块协作，你就能在不消耗大量内存的前提下拿到 P99 延迟：

import redis, time, random

r = redis.Redis()

def record_latency(service: str, latency_ms: float):
    """记录 API 延迟到 TimeSeries"""
    key = f"metrics:{service}:latency"
    try:
        r.ts().create(key, retention_msecs=86400000,
                      labels={"service": service})
    except Exception:
        pass
    r.ts().add(key, "*", latency_ms)

def get_p99_latency(service: str, minutes: int = 5) -> float:
    """获取最近 N 分钟的 P99 延迟（使用 t-digest）"""
    key = f"metrics:{service}:latency"
    now_ms = int(time.time() * 1000)
    start_ms = now_ms - minutes * 60 * 1000
    samples = r.ts().range(key, start_ms, now_ms)
    if not samples:
        return 0.0
    td_key = f"__tmp_tdigest:{service}"
    r.execute_command("TDIGEST.CREATE", td_key)
    r.execute_command("TDIGEST.ADD", td_key, *[v for _, v in samples])
    p99 = float(r.execute_command("TDIGEST.QUANTILE", td_key, 0.99)[0])
    r.delete(td_key)
    return p99

# 模拟数据
for _ in range(500):
    record_latency("api-gateway", max(1, random.gauss(50, 15)))
print(f"P99 延迟: {get_p99_latency('api-gateway'):.1f}ms")


五、概率数据结构：Count-Min Sketch / Top-K / t-digest
三个数据结构放到一起讲，因为它们都属于“用极小内存代价换取近似结果”的典型代表。在生产中用好它们，效果非常惊艳。
5.1 Count-Min Sketch：流量计数
假设你需要统计每个搜索词的频率——用 Redis 的 String 类型做计数器，10万个词可能耗掉几兆内存；而用 Count-Min Sketch，固定 40KB 就够了，误差控制在 0.1% 以内。
# 创建（0.1%误差，1%超出概率）
CMS.INITBYPROB search_freq 0.001 0.01

# 记录搜索词频率
CMS.INCRBY search_freq "Redis" 5 "Python" 3 "AI" 10

# 查询某词的估计频率
CMS.QUERY search_freq "Redis"
# 估计值

# 优势：固定内存（约40KB），无论插入多少词

5.2 Top-K：实时热榜
# 创建 Top-10 热榜
TOPK.RESERVE trending 10 50 3 0.9

# 添加元素（返回被挤出的元素）
TOPK.ADD trending "product:1001" "product:1002" "product:1001"

# 查询热榜（带计数）
TOPK.LIST trending WITHCOUNT

# 判断是否在热榜中
TOPK.QUERY trending "product:1001" # 1=在 0=不在

5.3 t-digest：精确分位数
如果做精确排序来算 P99，100 万样本需要约 8MB 内存；t-digest 只需固定约 10KB，且尾部分位数（P99/P999）精度极高，非常适合监控延迟场景。
# 创建
TDIGEST.CREATE response_times COMPRESSION 100

# 批量添加延迟样本
TDIGEST.ADD response_times 12.3 45.6 78.9 23.4 56.7

# 查询 P50 / P95 / P99
TDIGEST.QUANTILE response_times 0.5 0.95 0.99
# 返回：[23.4, 67.8, 95.2]（毫秒）

# 查询某值处于第几百分位
TDIGEST.RANK response_times 50
# 0.78 = 78%的请求 < 50ms

总结一下区别：
精确排序 P99：存储所有数据，排序 O(n log n)，100万样本需 ~8MB
t-digest：固定约 10KB，尾部分位数（P99/P999）精度极高
适合：监控延迟、SLA 报告、实时分位数计算

六、Vector Set：向量存储与 HNSW 相似度搜索
这是 Redis 8 最令 AI 开发者兴奋的新特性。

6.1 向量搜索的本质
传统关键词搜索："苹果手机" -> 精确匹配包含"苹果手机"的文档
                          不能找到"iPhone"、"智能手机"

向量（语义）搜索："苹果手机" -> Embedding 模型 -> [0.12, 0.87, -0.34, ...] (768维)
                         "iPhone"    ->                        [0.11, 0.85, -0.32, ...] (向量相似!)
                 搜索 = 在向量空间找最近的邻居
                 语义相关的文本 -> 向量距离近 -> 一起被找到

6.2 核心命令
向量集合是 Redis 的原生数据类型，用于存储元素和关联向量，实现快速相似度搜索。VADD 插入带向量的元素，VSIM 查找最近邻居：
# VADD：添加元素（VALUES 格式，指定维度和向量值）
VADD products:emb VALUES 4 0.1 0.2 0.3 0.4 "product:1001"

# 带 JSON 属性（用于混合搜索过滤）
VADD products:emb VALUES 4 0.1 0.2 0.3 0.4 "product:1001"  SETATTR '{"category":"laptop","price":12999,"year":2024}'

# FP32 格式（二进制，速度比 VALUES 快 10-20 倍，生产推荐）
# VADD products:emb FP32  "product:1001"

# CAS 参数：候选搜索在后台线程执行，降低插入延迟
VADD products:emb VALUES 4 0.1 0.2 0.3 0.4 "product:1001" CAS

# VSIM：近似最近邻搜索
VSIM products:emb VALUES 4 0.11 0.21 0.31 0.41 COUNT 10

# 带相似度分数 + 属性
VSIM products:emb VALUES 4 0.11 0.21 0.31 0.41 COUNT 10 WITHSCORES WITHATTRIBS

# 混合搜索：向量相似 + 属性过滤
VSIM products:emb VALUES 4 0.11 0.21 0.31 0.41 COUNT 10  WITHSCORES FILTER ".category == "laptop" && .price < 15000"

# EF 参数控制精度（越大越准确，越慢）
VSIM products:emb VALUES 4 0.11 0.21 0.31 0.41 COUNT 10 EF 200

# 查询向量集合信息
VINFO products:emb

6.3 量化：内存压缩
# INT8 量化（内存减少 75%，精度损失 < 1%）
VADD products:emb VALUES 4 0.1 0.2 0.3 0.4 "product:1001" Q8

# INT4 量化（内存减少 87%，精度损失约 2-3%）
VADD products:emb VALUES 4 0.1 0.2 0.3 0.4 "product:1002" Q4

量化
每维度
768维内存
精度损失
FP32（无）
4 字节
3 KB
0%
INT8（Q8）
1 字节
0.75 KB
< 1%
INT4（Q4）
0.5 字节
0.375 KB
约 2-3%


七、HNSW 算法深度拆解：O(log N) ANN 搜索

VSIM 使用 HNSW（Hierarchical Navigable Small World）近似最近邻算法，即使在百万向量规模下也能实现亚毫秒级搜索。
7.1 为什么不用暴力搜索？
暴力搜索：遍历所有向量计算距离
          100万向量 × 768维 = 7.68亿次运算/次查询 -> 几十毫秒
ANN：接受微小精度损失换取极大速度提升
HNSW：O(log N) 查询，亿级向量毫秒响应

7.2 HNSW 层次图结构
Layer 2（最高层，稀疏）：  [A]──────[E]──────[J]

Layer 1（中间层）：        [A]──[C]──[E]──[G]──[J]

Layer 0（底层，全量）：    [A][B][C][D][E][F][G][H][I][J]

查询过程（找最近 K 个）：
1. 从 Layer 2 入口节点，贪心爬山到本层最近点
2. 下降到 Layer 1，继续贪心
3. 下降到 Layer 0，在 EF 个候选中精确找最近 K 个
高层：快速粗定位（跳过大片区域）
低层：精确局部搜索

7.3 关键参数
M 参数是每个节点在 HNSW 图中的最大连接数：连接数越多，内存消耗越大，但图探索能力更强。默认值为 16。
M（默认 16）：每个节点的最大连接数
  M=16：标准配置（性能与内存平衡）
  M=32/64：高精度场景（内存增加但 recall 更高）

EF 构建（默认 200）：构建阶段候选数，越大图质量越好（构建越慢）

EF 搜索：
  EF=50：快速，recall 约 90%
  EF=200：标准，recall 约 95%
  EF=500：高精度，recall 约 99%（但变慢）


八、Redis Query Engine：全文检索 + 向量混合搜索
Redis Query Engine 支持向量搜索、精确字段过滤、全文关键词搜索，以及词干提取、同义词扩展和模糊匹配：
from redis.commands.search.field import (TextField, NumericField, TagField, VectorField)
from redis.commands.search.indexDefinition import IndexDefinition, IndexType
from redis.commands.search.query import Query
import struct

r = redis.Redis()

# 创建包含向量字段的混合索引
r.ft("idx:products").create_index(
    fields=[
        TextField("$.name", as_name="name"),
        NumericField("$.price", as_name="price"),
        TagField("$.category", as_name="category"),
        VectorField("$.embedding",
                     "HNSW",
                     {
                         "TYPE": "FLOAT32",
                         "DIM": 1536,  # 向量维度
                         "DISTANCE_METRIC": "COSINE",
                         "M": 16,
                         "EF_CONSTRUCTION": 200,
                     },
                     as_name="embedding",
                     ),
    ],
    definition=IndexDefinition(prefix=["product:"], index_type=IndexType.JSON),
)

def knn_search(query_vec: list, category: str = None,
               max_price: float = None, top_k: int = 10) -> list:
    """KNN 向量搜索 + 结构化过滤"""
    vec_bytes = struct.pack(f"{len(query_vec)}f", *query_vec)
    filters = []
    if category:
        filters.append(f"@category:{{{category}}}")
    if max_price:
        filters.append(f"@price:[0 {max_price}]")
    filter_str = " ".join(filters) if filters else "*"
    query_str = f"({filter_str})=>[KNN {top_k} @embedding $vec AS score]"
    results = r.ft("idx:products").search(
        Query(query_str)
        .sort_by("score")
        .return_fields("name", "price", "category", "score")
        .dialect(2),
        query_params={"vec": vec_bytes},
    )
    return [{"name": doc.name, "price": doc.price,
             "similarity": round(1 - float(doc.score), 4)}
            for doc in results.docs]


九、关键公式：余弦相似度与 HNSW 内存估算
9.1 余弦相似度（Redis Vector Set 默认距离度量）
CosSim(a, b) = (a · b) / (||a|| · ||b||)
余弦距离（Redis 中存储的是距离，值越小越相似）：
d_cos(a, b) = 1 - CosSim(a, b) ∈ [0, 2]
9.2 HNSW 复杂度
Redis Vector Sets 提供 O(log N) 的近似最近邻搜索：
T_search = O(log N), T_build = O(N log N)
9.3 内存估算
Mem = N × (d × b_dim + M × 8 + meta)
配置
100万向量（768维）估算内存
FP32，M=16
约 3 GB
INT8（Q8），M=16
约 0.9 GB
INT4（Q4），M=16
约 0.6 GB

9.4 Recall 与 EF 的关系
Recall@K = |ANN_results ∩ true_knn| / K
EF 越大，Recall 越高，查询延迟也越高。EF=200 通常可达 Recall > 95%。

十、实战：用 Redis 8 构建完整 RAG 系统

RAG（Retrieval-Augmented Generation）= 向量检索 + LLM 生成，是 2026 年最主流的 AI 应用架构。
10.1 系统架构
文档入库：原始文档 -> 分块(chunk) -> Embedding模型 -> 向量
                                                             -> VADD -> Redis Vector Set
查询：    用户问题 -> Embedding -> 查询向量
                                   -> VSIM(HNSW ANN) -> Top-K 相关文本块
                                   -> 构建 Prompt（问题 + 上下文）
                                   -> LLM(GPT-4o/Claude) -> 最终回答

10.2 完整实现
"""
redis_rag.py - 基于 Redis 8 Vector Set 的 RAG 系统
"""
import redis
import json
import struct
import time
from typing import Optional
from openai import OpenAI

r = redis.Redis(host='localhost', port=6379, decode_responses=False)
client = OpenAI()

VECTOR_KEY = "rag:docs:vectors"
CONTENT_PREFIX = "rag:docs:content:"
EMBEDDING_DIM = 1536

def get_embedding(text: str) -> list:
    resp = client.embeddings.create(input=text, model="text-embedding-3-small")
    return resp.data[0].embedding

def encode_fp32(vec: list) -> bytes:
    return struct.pack(f"{len(vec)}f", *vec)

def chunk_text(text: str, size: int = 500, overlap: int = 50) -> list:
    words = text.split()
    chunks, step = [], size - overlap
    for i in range(0, len(words), step):
        chunk = " ".join(words[i:i + size])
        if chunk:
            chunks.append(chunk)
        if i + size >= len(words):
            break
    return chunks

def ingest_document(doc_id: str, content: str, metadata: dict = None):
    """将文档分块入库 Redis Vector Set"""
    chunks = chunk_text(content)
    pipeline = r.pipeline()
    for i, chunk in enumerate(chunks):
        chunk_id = f"{doc_id}:chunk:{i}"
        embedding = get_embedding(chunk)
        vec_bytes = encode_fp32(embedding)
        attrs = {"doc_id": doc_id, "chunk_idx": i,
                 "content": chunk[:200], **(metadata or {})}
        r.execute_command("VADD", VECTOR_KEY,
                          "FP32", vec_bytes,
                          chunk_id,
                          "SETATTR", json.dumps(attrs),
                          "CAS",
                          )
        pipeline.set(f"{CONTENT_PREFIX}{chunk_id}", chunk)
    pipeline.execute()
    print(f"入库完成：{doc_id}，共 {len(chunks)} 个向量块")

def semantic_search(query: str, top_k: int = 5,
                    ef: int = 200, filter_expr: str = None) -> list:
    """语义检索：返回最相关的 top_k 个文本块"""
    query_vec = get_embedding(query)
    vec_bytes = encode_fp32(query_vec)
    cmd = ["VSIM", VECTOR_KEY, "FP32", vec_bytes,
           "COUNT", top_k, "WITHSCORES", "WITHATTRIBS", "EF", ef]
    if filter_expr:
        cmd.extend(["FILTER", filter_expr])
    raw = r.execute_command(*cmd)
    results = []
    for i in range(0, len(raw), 3):
        chunk_id = raw[i].decode()
        score = float(raw[i + 1])
        attrs = json.loads(raw[i + 2])
        content_bytes = r.get(f"{CONTENT_PREFIX}{chunk_id}")
        content = content_bytes.decode() if content_bytes else attrs.get("content", "")
        results.append({
            "chunk_id": chunk_id,
            "similarity": round(1 - score, 4),
            "content": content,
            "attrs": attrs,
        })
    return results

def rag_query(question: str, top_k: int = 5,
              model: str = "gpt-4o-mini") -> dict:
    """完整 RAG 问答：检索 + 生成"""
    # Step 1：语义检索
    retrieved = semantic_search(question, top_k=top_k)
    if not retrieved:
        return {"question": question, "answer": "未找到相关文档。", "sources": []}
    # Step 2：构建 Prompt
    context = "\n".join([
        f"[片段{i+1}（相似度{doc['similarity']:.2%}）]{doc['content']}"
        for i, doc in enumerate(retrieved)
    ])
    # Step 3：调用 LLM
    response = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": "你是知识库问答助手。基于提供的文档片段回答问题，"
                                          "无相关信息请明确说明，回答要准确简洁。"},
            {"role": "user", "content": f"文档片段：{context}\n---\n用户问题：{question}\n请回答："},
        ],
        temperature=0.2,
        max_tokens=1000,
    )
    return {
        "question": question,
        "answer": response.choices[0].message.content,
        "sources": [{"chunk_id": d["chunk_id"],
                      "similarity": d["similarity"],
                      "preview": d["content"][:100] + "..."}
                     for d in retrieved],
        "tokens_used": response.usage.total_tokens,
    }

# 使用示例
if __name__ == "__main__":
    ingest_document("redis_manual",
                    "Redis 8 新增了向量集合 Vector Set，使用 HNSW 算法实现近似最近邻搜索..."
                    "使用 VADD 命令存储向量，VSIM 命令搜索相似向量..."
                    "支持 FP32/Q8/Q4 量化，大幅降低内存占用...",
                    metadata={"source": "Redis官方文档", "version": "8.0"},
    )
    result = rag_query("Redis 8 的向量搜索功能如何使用？")
    print(f"问题：{result['question']}")
    print(f"回答：{result['answer']}")
    print(f"来源：{[s['chunk_id'] for s in result['sources']]}")

10.3 Vector Set vs 专用向量数据库
维度
Redis 8 Vector Set
Pinecone / Wea viate
额外成本
$0（复用现有 Redis）
额外费用（Pinecone $70+/月）
部署
自托管，已有 Redis 即可
独立部署/云服务
缓存+向量一体
同一实例，零额外网络跳转
需要两套系统
全文检索
内置 Query Engine
部分支持
最大规模
亿级（Cluster 模式）
更大
适用场景
中小规模 RAG，深度集成 Redis
专用大规模向量服务


系列收官：Redis 五篇全景回顾
五篇系列，完整覆盖了 Redis 从底层原理到 AI 应用的全链路：
第一篇：数据结构与底层编码
        SDS / listpack / 跳表 / intset / 渐进式rehash
        → 理解 Redis 为什么快

第二篇：持久化机制
        RDB（fork+COW）/ AOF（三种刷盘）/ 混合持久化
        → 生产环境数据安全基础

第三篇：高可用架构
        主从（PSYNC2）/ Sentinel（Raft投票）/ Cluster（哈希槽）
        → 从单机到集群的完整演进

第四篇：缓存设计与生产实战
        穿透/击穿/雪崩 / 热key/bigkey / 布隆过滤器 / LRU/LFU
        → 生产中真正遇到的问题

第五篇：Redis 8 新纪元（本篇）
        Vector Set / JSON / TimeSeries / 概率结构
        → Redis 从缓存到 AI 数据平台的进化



参考资料

Redis 8 GA 公告：https://redis.io/blog/redis-8-ga/
Redis Vector Sets 教程：https://redis.io/tutorials/howtos/vector-sets-basics/
Redis Vector Sets README：https://github.com/redis/redis/blob/8.2.3/modules/vector-sets/README.md
Redis 8 新特性文档：https://redis.io/docs/latest/develop/whats-new/8-0/
                
来源：互联网