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

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

作者：技术博主 | 更新时间：2026-05-11 | 阅读时长：约 25 分钟 系列：Redis 硬核技术系列（共 5 篇）收官篇 标签：Redis 8 Vector Set HNSW RAG 向量数据库 RedisSearch 时序数据 AI 语义搜索

Redis 8 是 Redis 历史上最大的架构转变——从"只是一个缓存"到一个统一数据平台，支持缓存、实时分析、文档存储、向量相似度搜索和时序分析，全部内置，零模块管理开销。本篇带你把 9 大内置数据结构全部吃透，并用 Redis 8 构建完整的 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 系统

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

1.1 什么变了？

Redis 8 新增了 8 种数据结构，包括向量集合（测试版）、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 大内置数据结构总览

数据结构 命令前缀 典型用途
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 核心命令

# 存储 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 联合索引（电商搜索）

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 核心操作

# 创建时序（保留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 avg 3600000

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

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

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

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：流量计数

# 创建（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：精确分位数

# 创建
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

t-digest vs 精确排序：

精确排序 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 <binary_bytes> "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

七、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

∥

\\text{CosSim}(\\mathbf{a}, \\mathbf{b}) = \\frac{\\mathbf{a} \\cdot \\mathbf{b}}{\\|\\mathbf{a}\\| \\cdot \\|\\mathbf{b}\\|}

CosSim(a,b)=∥a∥⋅∥b∥a⋅b​

余弦距离（Redis 存储的是距离，越小越相似）：

d

cos

⁡

(

a

,

b

)

=

1

−

CosSim

(

a

,

b

)

∈

[

0

,

2

]

d_{\\cos}(\\mathbf{a}, \\mathbf{b}) = 1 – \\text{CosSim}(\\mathbf{a}, \\mathbf{b}) \\in [0, 2]

dcos​(a,b)=1−CosSim(a,b)∈[0,2]

d_{\\cos} = 1 – \\frac{\\mathbf{a}\\cdot\\mathbf{b}}{\\|\\mathbf{a}\\|\\|\\mathbf{b}\\|}

9.2 HNSW 复杂度

Redis Vector Sets 提供 O(log N) 的近似最近邻搜索：

T

search

=

O

(

log

⁡

N

)

,

T

build

=

O

(

N

log

⁡

N

)

T_{\\text{search}} = O(\\log N), \\quad T_{\\text{build}} = O(N \\log N)

Tsearch​=O(logN),Tbuild​=O(NlogN)

T_{\\text{search}} = O(\\log N),\\quad T_{\\text{build}} = O(N\\log N)

9.3 内存估算

Mem

=

N

×

(

d

×

b

dim

+

M

×

8

+

meta

)

\\text{Mem} = N \\times \\left(d \\times b_{\\text{dim}} + M \\times 8 + \\text{meta}\\right)

Mem=N×(d×bdim​+M×8+meta)

\\text{Mem} = N \\times (d \\times b_{\\text{dim}} + M \\times 8 + \\text{meta})

9.4 Recall 与 EF 的关系

Recall

@

K

=

∣

ANN_results

∩

true_knn

∣

K

\\text{Recall}@K = \\frac{|\\text{ANN\\_results} \\cap \\text{true\\_knn}|}{K}

Recall@K=K∣ANN_results∩true_knn∣​

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\\n".join([
f"[片段{i+1}（相似度{doc['similarity']:.2%}）]\\n{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"文档片段：\\n\\n{context}\\n\\n—\\n用户问题：{question}\\n\\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 五篇全景回顾

五篇系列，完整覆盖了 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 的 Vector Set 你会用到项目里吗？ 欢迎评论区聊！

🙏 五篇系列完结撒花！如果整个系列帮到你，最后一次三连（点赞 + 收藏 + 关注）！

参考资料

本文为原创技术分享。转载请注明出处。最后更新：2026-05-11 Redis 硬核系列（五篇）完结 🎉