使用 Python 和向量数据库构建实时患者信息管理系统

• HNSW（Hierarchical Navigable Small World）：基于图结构，检索速度快，召回率高，但构建索引较慢。
• IVF（Inverted File Index）：聚类 + 倒排索引，适合大规模数据，速度和内存可调。
• PQ（Product Quantization）：对向量进行压缩，减少内存占用，适合极大规模。

Chroma 底层支持多种 ANN 库（如 HNSW），并提供了简洁的 API，我们无需手动选择算法，直接使用即可。

3. 需求分析

在动手编码之前，我们需要明确系统的功能需求和性能要求。

3.1 数据结构

假设我们要管理每位患者的信息，包括：

• 唯一标识：patient_id（字符串）
• 基本人口学信息：姓名、年龄、性别等
• 临床描述：症状描述、主诉、既往史等（自由文本）
• 实验室检查结果：血压、心率、血糖、体温等（数值型，可能随时间变化）
• 时间戳：记录数据产生的时间，支持时序查询

一个示例患者数据如下：

{
  "patient_id": "P001234",
  "name": "张三",
  "age": 58,
  "gender": "男",
  "symptoms": "发热、咳嗽、乏力，伴胸闷气短",
  "lab_results": {
    "blood_pressure": "145/90",
    "heart_rate": 102,
    "blood_sugar": 7.8,
    "temperature": 38.5
  },
  "timestamp": "2025-04-07T14:30:00Z"
}

3.2 功能需求

1. 插入新患者记录：将完整的患者信息存入数据库。
2. 更新现有患者记录：当患者复诊或新的检查结果产生时，更新其信息（可能包括文本和数值字段）。
3. 删除患者记录：根据 patient_id 移除记录（合规要求，如患者要求删除数据）。
4. 语义相似搜索：给定一段症状描述（如'持续高烧、干咳、呼吸困难'），返回历史上最相似的若干病例及其详细信息。
5. 混合过滤查询：在相似搜索的基础上，增加结构化字段的过滤条件，例如'返回症状相似且收缩压 > 140 的病例'。
6. 实时性：新数据写入后，应能立即被搜索到；对于流式数据（如心率监测），需支持高频更新。

3.3 性能需求

• 数据量：初期可能几千到几万患者，后续可扩展至百万级。
• 查询延迟：语义搜索应在 200ms 内返回结果。
• 更新吞吐量：支持每秒数十次更新（对于流式场景）。

3.4 安全与隐私

患者数据属于高度敏感信息，必须考虑：

• 数据加密：存储和传输过程中的加密。
• 访问控制：仅授权用户可操作数据。
• 审计日志：记录所有访问和修改行为。
• 合规性：符合 HIPAA（美国健康保险携带和责任法案）、GDPR（欧盟通用数据保护条例）或国内相关法规。

4. 技术选型

4.1 向量数据库选择

目前主流的 Python 向量数据库方案有：

考虑到本文的重点是演示实现原理，且希望本地可运行，我们选择 Chroma。Chroma 是一个开源的嵌入式向量数据库，具有以下优点：

• 纯 Python 实现，安装简单（pip install chromadb）。
• 支持持久化存储到磁盘。
• 内置元数据存储和过滤（基于 SQLite）。
• 支持多种嵌入模型，可自定义。
• 提供 upsert 操作，方便实时更新。

4.2 嵌入模型

我们选用 sentence-transformers/all-MiniLM-L6-v2，它是一个轻量级的预训练模型，将句子转换为 384 维向量，兼顾速度和效果。该模型在多语言任务上表现良好，支持中文。

若需更好的中文支持，可考虑 paraphrase-multilingual-MiniLM-L12-v2 或调用商业 API（如 OpenAI）。但为了本地部署和隐私安全，我们优先使用开源模型。

4.3 其他工具

• Python 3.8+：开发语言。
• NumPy：向量运算辅助。
• Pydantic：可选，用于数据模型验证。
• FastAPI：可选，用于构建 RESTful API 接口。
• Redis：可选，用于缓存或消息队列。
• Kafka / RabbitMQ：可选，用于处理实时数据流。

在本文中，我们将聚焦核心的向量数据库操作，不强制使用 Web 框架，但会在扩展部分讨论如何对接实时流。

5. 系统设计与架构

5.1 整体架构

下图展示了系统的核心组件和数据流向：

┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│  数据源     │ ──> │  嵌入服务   │ ──> │  向量数据库   │
│ (手动/流式) │     │(sentence- │     │ (Chroma)    │
└─────────────┘     │ transformers)│     └─────────────┘
                    └─────────────┘
                        ▲
                        │
                        │
└───────────┬───────────┘
            │
┌───────────┴───────────┐
│  查询接口             │
│ (Python 函数)         │
└───────────────────────┘

• 数据源：可以是手动输入的病例文本，也可以是医疗设备实时上传的 JSON 数据。
• 嵌入服务：接收原始患者数据，将其中的文本部分拼接并转换为向量，同时提取结构化元数据。
• 向量数据库：存储向量和元数据，提供增删改查 API。
• 查询接口：供应用程序调用，执行相似搜索和过滤查询。

5.2 模块划分

我们将系统划分为以下模块：

1. 数据模型模块：定义患者数据的结构，便于校验和序列化。
2. 嵌入模块：封装嵌入模型，提供文本到向量的转换函数。
3. 数据库模块：封装对 Chroma 的操作（初始化、增删改查）。
4. 业务逻辑模块：组合嵌入和数据库，实现具体功能（如添加患者、搜索相似病例）。
5. 流处理模块（可选）：处理实时数据流，异步更新数据库。

在接下来的章节中，我们将依次实现这些模块。

6. 详细实现步骤

6.1 环境搭建

首先，创建一个新的 Python 虚拟环境并安装必要的包：

python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate
pip install chromadb sentence-transformers numpy pandas

如果需要构建 API，可以安装 fastapi 和 uvicorn。

6.2 初始化 Chroma 客户端和集合

Chroma 客户端可以指定持久化目录，以便重启后数据不丢失。

import chromadb
from chromadb.config import Settings

# 持久化目录
PERSIST_DIRECTORY = "./chroma_patient_db"

# 初始化客户端
client = chromadb.Client(Settings(
    chroma_db_impl="duckdb+parquet",
    persist_directory=PERSIST_DIRECTORY,
    anonymized_telemetry=False  # 关闭匿名数据收集
))

# 创建或获取集合
COLLECTION_NAME = "patients"
existing_collections = client.list_collections()
if COLLECTION_NAME not in [col.name for col in existing_collections]:
    collection = client.create_collection(name=COLLECTION_NAME)
else:
    collection = client.get_collection(COLLECTION_NAME)

6.3 定义数据模型

为了代码清晰，我们使用 Python 的 dataclass 定义患者信息结构，并包含一个方法生成用于嵌入的文本。

from dataclasses import dataclass, asdict
from typing import Dict, Any

@dataclass
class Patient:
    patient_id: str
    name: str
    age: int
    gender: str
    symptoms: str
    lab_results: Dict[str, float]  # 如 {"blood_pressure_sys": 145, ...}
    timestamp: str  # ISO 格式

    def to_embedding_text(self) -> str:
        """生成用于嵌入的文本，包含关键信息"""
        lab_text = ", ".join([f"{k}:{v}" for k, v in self.lab_results.items()])
        return f"患者姓名：{self.name}，性别：{self.gender}，年龄：{self.age}，症状：{self.symptoms}，检查结果：{lab_text}，时间：{self.timestamp}"

    def to_metadata(self) -> Dict[str, Any]:
        """生成存储在 Chroma 中的元数据字段（用于过滤）"""
        meta = {
            "patient_id": self.patient_id,
            "age": self.age,
            "gender": self.gender,
            "timestamp": self.timestamp,
        }
        # 将 lab_results 展平，方便过滤，例如 blood_pressure_sys, blood_pressure_dia
        for k, v in self.lab_results.items():
            meta[k] = v
        return meta

注意：血压通常表示为两个数值，我们可以拆分为 bp_sys 和 bp_dia 两个字段，或者存储为字符串（但字符串无法用于数值过滤）。为了便于过滤，建议拆分为数值字段。

6.4 嵌入模块

我们封装一个嵌入器类，负责加载模型并将文本转为向量列表。

from sentence_transformers import SentenceTransformer
from typing import List

class Embedder:
    def __init__(self, model_name: str='all-MiniLM-L6-v2'):
        self.model = SentenceTransformer(model_name)

    def encode(self, texts: List[str]) -> List[List[float]]:
        """将文本列表转换为向量列表"""
        embeddings = self.model.encode(texts, convert_to_numpy=True)
        return embeddings.tolist()

    def encode_one(self, text: str) -> List[float]:
        return self.encode([text])[0]

# 全局嵌入器实例（可单例）
embedder = Embedder()

6.5 数据库操作封装

我们将对 Chroma 集合的操作封装成一个类，方便业务层调用。

class PatientVectorDB:
    def __init__(self, collection, embedder):
        self.collection = collection
        self.embedder = embedder

    def upsert_patient(self, patient: Patient):
        """插入或更新患者信息"""
        # 生成嵌入文本并向量化
        text = patient.to_embedding_text()
        embedding = self.embedder.encode_one(text)
        # 准备元数据
        metadata = patient.to_metadata()
        # 使用 upsert：如果 patient_id 已存在，则更新；否则插入
        self.collection.upsert(
            ids=[patient.patient_id],
            embeddings=[embedding],
            metadatas=[metadata],
            documents=[text]  # 可选，存储原始文本便于查看
        )
        print(f"Upserted patient {patient.patient_id}")

    def delete_patient(self, patient_id: str):
        """根据 patient_id 删除患者记录"""
        self.collection.delete(ids=[patient_id])
        print(f"Deleted patient {patient_id}")

    def get_patient(self, patient_id: str) -> Dict[str, Any]:
        """根据 patient_id 查询患者详细信息（返回元数据）"""
        result = self.collection.get(ids=[patient_id])
        if result and result['metadatas']:
            return result['metadatas'][0]
        else:
            return None

    def search_similar(self, query_text: str, n_results: int = 5, where: Dict = None) -> List[Dict]:
        """ 语义搜索相似病例
        :param query_text: 查询文本（如症状描述）
        :param n_results: 返回结果数量
        :param where: 过滤条件，例如 {"age": {"$gt": 50}}
        :return: 匹配的患者元数据列表
        """
        query_emb = self.embedder.encode_one(query_text)
        results = self.collection.query(
            query_embeddings=[query_emb],
            n_results=n_results,
            where=where
        )
        # 解析结果
        metadatas = results['metadatas'][0]  # 第一个查询的结果
        distances = results['distances'][0]  # 距离（越小越相似）
        # 可合并距离返回
        output = []
        for meta, dist in zip(metadatas, distances):
            output.append({
                "patient_id": meta.get("patient_id"),
                "metadata": meta,
                "similarity_score": 1 - dist  # 转换为相似度（0-1，越大越相似）
            })
        return output

6.6 示例数据准备与测试

现在我们编写一些测试数据来验证功能。

# 创建几个患者实例
patient1 = Patient(
    patient_id="P001", name="张三", age=45, gender="男",
    symptoms="发热、咳嗽、乏力，体温 38.5 度",
    lab_results={"bp_sys": 130, "bp_dia": 85, "heart_rate": 90, "blood_sugar": 6.2, "temperature": 38.5},
    timestamp="2025-04-07T10:00:00Z"
)
patient2 = Patient(
    patient_id="P002", name="李四", age=62, gender="男",
    symptoms="胸闷、气短、心悸，偶有胸痛",
    lab_results={"bp_sys": 150, "bp_dia": 95, "heart_rate": 110, "blood_sugar": 7.0, "temperature": 36.8},
    timestamp="2025-04-07T11:20:00Z"
)
patient3 = Patient(
    patient_id="P003", name="王芳", age=34, gender="女",
    symptoms="头痛、恶心、视力模糊",
    lab_results={"bp_sys": 120, "bp_dia": 80, "heart_rate": 75, "blood_sugar": 5.1, "temperature": 36.5},
    timestamp="2025-04-06T09:15:00Z"
)

# 初始化数据库操作对象
db = PatientVectorDB(collection, embedder)

# 插入患者
db.upsert_patient(patient1)
db.upsert_patient(patient2)
db.upsert_patient(patient3)

# 查询相似病例
query = "反复咳嗽伴发热"
results = db.search_similar(query, n_results=2)
print("相似病例搜索结果：")
for r in results:
    print(f"患者 ID: {r['patient_id']}, 相似度：{r['similarity_score']:.3f}, 症状：{r['metadata']['symptoms']}")

输出示例：

相似病例搜索结果：
患者 ID: P001, 相似度：0.923, 症状：发热、咳嗽、乏力，体温 38.5 度
患者 ID: P002, 相似度：0.456, 症状：胸闷、气短、心悸，偶有胸痛

可以看到，与咳嗽发热最相似的病例是 P001，相似度远高于 P002。

6.7 实时更新

实时更新是指当患者的新数据到达时，立即更新数据库中的记录。Chroma 的 upsert 操作正好满足这一需求：如果 ID 已存在，则覆盖原有记录。

假设患者张三（P001）进行了复诊，症状变为'发热已退，仍有咳嗽'，同时新的血压和心率如下：

# 更新患者 P001
patient1_updated = Patient(
    patient_id="P001", name="张三", age=45, gender="男",
    symptoms="咳嗽，少量白痰，无发热",
    lab_results={"bp_sys": 125, "bp_dia": 80, "heart_rate": 80, "blood_sugar": 6.0, "temperature": 36.6},
    timestamp="2025-04-08T09:00:00Z"
)
db.upsert_patient(patient1_updated)

# 再次搜索'咳嗽'
results = db.search_similar("咳嗽", n_results=3)
print("更新后相似病例：")
for r in results:
    print(f"患者 ID: {r['patient_id']}, 症状：{r['metadata']['symptoms']}")

此时，P001 的症状已更新为'咳嗽，少量白痰，无发热'，搜索引擎会基于新的文本向量进行匹配。

6.8 混合过滤查询

有时我们需要在语义搜索的基础上加上结构化字段的筛选。例如，查找症状类似且年龄大于 60 的患者。

# 查询文本：胸闷
query = "胸闷"
# 过滤条件：年龄 > 60
where = {"age": {"$gt": 60}}
results = db.search_similar(query, n_results=5, where=where)
print("年龄>60 且症状类似胸闷的病例：")
for r in results:
    print(f"患者 ID: {r['patient_id']}, 年龄：{r['metadata']['age']}, 症状：{r['metadata']['symptoms']}")

Chroma 支持丰富的过滤语法，例如：

• 精确匹配：{"gender": "男"}
• 比较操作：{"age": {"$gt": 50}}, {"bp_sys": {"$gte": 140}}
• 逻辑组合：{"$and": [{"age": {"$gt": 50}}, {"gender": "男"}]}

更多过滤语法请参考 Chroma 文档。

6.9 删除记录

根据患者 ID 删除记录：

db.delete_patient("P003")

7. 扩展：实时流式更新

在许多医疗场景中，数据不是一次性录入的，而是以流的方式持续到达。例如，ICU 中的监护仪每秒上传一次心率、血压数据，或者可穿戴设备定期上传健康指标。如何处理这种高频、实时的数据流，并及时更新向量数据库？

7.1 架构设计

实时流处理通常涉及以下组件：

• 数据源：医疗设备通过 MQTT、HTTP 或专有协议发送数据。
• 消息队列：如 Kafka、RabbitMQ 或 Redis Stream，用于缓冲数据，削峰填谷。
• 消费者服务：从队列中拉取数据，进行嵌入计算并更新数据库。
• 向量数据库：作为最终存储。

如果数据量不大，也可以直接使用异步处理（如 asyncio）接收 HTTP 请求并立即更新，但需要确保高并发下的稳定性。

7.2 使用 Redis Stream 实现简单流处理

这里我们用一个简化的例子，使用 Redis 的 Stream 数据结构作为消息队列，通过 Python 的 redis-py 和 asyncio 实现消费者。

首先安装依赖：

pip install redis aioredis

生产者（模拟设备）不断发送患者更新：

import redis
import json
import time
import random

r = redis.Redis(host='localhost', port=6379, decode_responses=True)
while True:
    # 模拟患者 ID 和数据
    patient_id = random.choice(["P001", "P002", "P003"])
    data = {
        "patient_id": patient_id,
        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
        "lab_results": {
            "heart_rate": random.randint(60, 120),
            "bp_sys": random.randint(110, 160),
            "bp_dia": random.randint(70, 100)
        }
    }
    # 发送到 Redis Stream "patient_updates"
    r.xadd("patient_updates", {"data": json.dumps(data)})
    time.sleep(0.5)  # 每 0.5 秒发送一次

消费者：持续监听 Stream，处理每条消息。

import asyncio
import aioredis
import json
from your_implementation import db, embedder, Patient  # 假设已导入之前的模块

async def process_message(data_json: str):
    """处理单条消息，更新对应患者"""
    data = json.loads(data_json)
    patient_id = data["patient_id"]
    # 从数据库获取该患者的现有信息（假设我们存储了部分静态信息，如 name, age, gender）
    # 为了简化，我们假设通过 get_patient 能获取最近一次存储的完整信息
    existing = db.get_patient(patient_id)
    if not existing:
        print(f"患者 {patient_id} 不存在，无法更新")
        return
    # 更新 lab_results 和时间戳
    # 注意：existing 中包含之前的所有元数据，但可能缺少某些字段，我们需要重构一个 Patient 对象
    # 在实际中，可能需要额外的存储来保留完整信息，此处仅作示例
    updated_lab = existing.copy()
    # 更新数值字段
    for k, v in data["lab_results"].items():
        updated_lab[k] = v
    # 创建新的 Patient 对象
    patient = Patient(
        patient_id=patient_id,
        name=existing.get("name", ""),
        age=existing.get("age", 0),
        gender=existing.get("gender", ""),
        symptoms=existing.get("symptoms", ""),  # 症状可能不变
        lab_results={k: v for k, v in updated_lab.items() if k in ["heart_rate", "bp_sys", "bp_dia", "blood_sugar", "temperature"]},
        timestamp=data["timestamp"]
    )
    # 重新嵌入并更新数据库
    db.upsert_patient(patient)
    print(f"已更新患者 {patient_id}")

async def consumer():
    redis_conn = await aioredis.from_url("redis://localhost")
    stream = "patient_updates"
    last_id = "$"  # 从最新消息开始消费
    while True:
        # 阻塞读取新消息
        messages = await redis_conn.xread({stream: last_id}, block=1000)
        for msg_stream, msg_list in messages:
            for msg_id, msg_data in msg_list:
                data_json = msg_data[b'data'].decode()
                await process_message(data_json)
                last_id = msg_id  # 更新最后消费的 ID

if __name__ == "__main__":
    asyncio.run(consumer())

这个例子展示了如何将流式数据转换为向量数据库的更新操作。在实际应用中，还需要考虑消息确认、失败重试、幂等性等问题。

7.3 性能优化

对于高频流式更新，每次更新都重新计算整个文本的嵌入可能成本较高。如果只是数值字段变化（如心率），文本描述可能不变，那么向量的变化微乎其微，但数值字段的更新会影响过滤查询。我们可以优化：

• 仅更新数值字段：如果文本部分未变，可以保留原向量，仅更新元数据。Chroma 的 upsert 需要提供整个向量，但我们可以先获取原向量再更新元数据，或者使用 update 方法（Chroma 提供 update 但必须提供 embedding 或 document）。更好的做法是分离存储：将静态文本和动态数值分开，但这样查询时需要联合，复杂度增加。
• 批量更新：多条更新合并为一次批量操作，减少网络开销。
• 异步嵌入：嵌入计算可能成为瓶颈，可使用多线程或 GPU 加速。

8. 优化与性能调优

8.1 索引选择

Chroma 底层使用 HNSW 索引，该索引有几个可调参数，影响检索速度和召回率：

• hnsw:space：距离度量，可选 'cosine'（默认）、'l2'、'ip'（内积）。对于文本嵌入，通常使用余弦相似度。
• hnsw:construction_ef：构建索引时的动态列表大小，越大索引质量越高，但构建时间越长。默认 100。
• hnsw:M：每个节点的最大连接数，越大索引更精确，但内存占用高。默认 16。

可以在创建集合时指定这些参数：

collection = client.create_collection(
    name="patients",
    metadata={"hnsw:space": "cosine", "hnsw:construction_ef": 200, "hnsw:M": 32}
)

8.2 批量插入

当需要插入大量历史数据时，逐条插入非常慢。Chroma 支持批量操作：

# 假设有 patients 列表
ids = [p.patient_id for p in patients]
embeddings = [embedder.encode_one(p.to_embedding_text()) for p in patients]
metadatas = [p.to_metadata() for p in patients]
documents = [p.to_embedding_text() for p in patients]
collection.add(
    ids=ids,
    embeddings=embeddings,
    metadatas=metadatas,
    documents=documents
)

批量操作大幅减少网络往返和事务开销。

8.3 缓存策略

对于频繁查询的热门患者数据，可以在应用层加缓存（如 Redis），减少对向量数据库的访问。但需要注意缓存的失效策略，确保实时性。

8.4 分布式部署

当数据量达到百万级以上，单机 Chroma 可能无法满足性能要求。此时可以考虑：

• Milvus：支持分布式部署，提供云原生架构。
• Elasticsearch：最新版本也支持向量搜索，可以结合已有的 ELK 栈。
• PGvector：PostgreSQL 的扩展，允许在关系数据库中存储和查询向量。

选择哪种方案取决于团队的运维能力和数据规模。

9. 安全与隐私保护

9.1 数据加密

• 传输加密：所有 API 调用应使用 HTTPS/TLS。
• 存储加密：Chroma 的持久化文件位于磁盘，应对整个数据库目录进行加密（如使用 LUKS 或 BitLocker）。敏感字段如姓名可单独加密存储。

9.2 访问控制

• 认证：使用 API 密钥、JWT 或 OAuth2 对请求进行认证。
• 授权：确保用户只能访问其权限范围内的数据。例如，医生只能查看自己科室的患者。

9.3 审计日志

记录所有对患者数据的操作，包括谁、什么时间、做了什么操作（查询、修改、删除）。Chroma 本身不提供审计功能，需要在应用层实现。

9.4 合规性建议

• HIPAA：要求对电子受保护健康信息（ePHI）进行加密，实施访问控制，并进行审计跟踪。
• GDPR：用户有权被遗忘，应实现删除功能；数据处理需获得用户同意。

在使用向量数据库时，需要注意嵌入模型可能无意中记忆训练数据中的敏感信息，但使用通用预训练模型的风险较小。另外，向量本身无法直接还原为原始文本，但通过相似性搜索仍可能推断出敏感信息，因此对查询结果也应进行权限控制。

10. 实际应用场景案例

10.1 辅助诊断

医生在接诊新患者时，输入患者的症状描述，系统返回历史上症状相似的患者及其诊断结果、治疗方案，为医生提供参考。

10.2 临床研究

研究人员希望筛选符合特定条件的患者群体，例如'年龄 50-70 岁、有高血压史、最近一次心电图显示 ST 段抬高'。通过混合查询，可以快速定位符合条件的患者，并提取其匿名化数据进行统计分析。

10.3 实时监控与预警

对于 ICU 患者，实时监测生命体征，当发现某个患者的体征序列与历史上发生心脏骤停的病例高度相似时，系统自动向医护人员发出预警。

11. 总结与展望

本文详细介绍了如何使用 Python 和 Chroma 向量数据库构建一个能够实时管理患者信息、支持语义搜索和结构化过滤的系统。我们实现了从数据模型设计、嵌入生成、增删改查到实时流式更新的完整流程，并讨论了性能优化和安全隐私方面的考量。

向量数据库为医疗信息管理带来了新的可能性，它突破了传统关键词搜索的局限，让计算机能够理解临床描述的语义，从而更智能地辅助决策。未来，随着多模态大模型的发展，我们可以将影像、基因序列等也转换为向量，实现跨模态的相似性检索，为精准医疗提供更强有力的工具。

当然，本文的示例只是一个原型，实际生产环境还需要考虑高可用、容灾、监控、版本升级等工程问题。但希望这篇文章能为您的项目起步提供坚实的基础。

12. 附录：完整代码清单

为了方便读者直接运行，这里提供所有代码的整合，分为几个文件：

• models.py：数据模型定义
• embedder.py：嵌入器封装
• db.py：数据库操作封装
• main.py：示例主程序
• stream_consumer.py：流式消费者示例

（篇幅所限，此处不重复粘贴，但建议读者按章节组织代码。）

参考资料：

1. Chroma 官方文档：https://docs.trychroma.com/
2. sentence-transformers 文档：https://www.sbert.net/
3. HNSW 算法论文：https://arxiv.org/abs/1603.09320
4. HIPAA 合规指南：https://www.hhs.gov/hipaa/index.html
5. GDPR 官网：https://gdpr-info.eu/