1
# 精确匹配：找到 title 包含 "Python" 的 Todo
2
db.query(DBTodo).filter(DBTodo.title.like("%Python%")).all()

1
用户搜索: "编程语言入门"
2
数据库内容: "Python 基础教程"
3
SQL 查询: LIKE '%编程语言入门%' → ❌ 找不到！

1
用户搜索: "编程语言入门"
2
数据库内容: "Python 基础教程"
3
语义分析: "编程语言" ≈ "Python"，"入门" ≈ "基础"
4
结果: ✅ 找到！相似度 85%

1
文本: "猫在睡觉"
2
    ↓ Embedding 模型
3
向量: [0.23, -0.56, 0.89, 0.12, -0.34, ...]  # 1536 个数字
4

5
文本: "小猫在休息"
6
    ↓ Embedding 模型
7
向量: [0.25, -0.54, 0.87, 0.15, -0.31, ...]  # 相似度很高！

1
# 三句话
2
A = "如何提升代码质量"
3
B = "提高程序可维护性的方法"
4
C = "今天天气真好"
5

6
# 转成向量后
7
向量A 和 向量B 的距离: 0.2  # 很近！语义相关
8
向量A 和 向量C 的距离: 0.9  # 很远！语义无关

1
高维空间中的向量分布（简化到2D）
2

3
                    ↑
4
    "天气很好"      |      "代码重构"
5
         ●          |          ●
6
                   |
7
    "今天晴天" ────┼──── "提升质量"
8
         ●         |          ●
9
                   |
10
    "适合散步"     |      "程序维护"
11
         ●         |          ●
12
                   └──────────────→
13

14
左下角 = 天气相关（向量聚集）
15
右下角 = 代码相关（向量聚集）

1
import numpy as np
2

3
def cosine_similarity(a, b):
4
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
5

6
# 相似度范围: -1（完全相反）到 1（完全相同）
7
# 实际应用: 0.7 以上就算很相似了

1
# ❌ SQL LIKE：字面匹配
2
# 搜索 "编程语言" → 找不到 "Python 是一种高级编程语言"
3
# 因为 "编程语言" 这几个字没有连续出现
4

5
# ✅ 向量检索：语义匹配
6
# 搜索 "编程语言" → 找到 "Python 是一种高级编程语言"
7
# 因为语义相近，即使文字不同

1
┌─────────────────┐     ┌─────────────────┐
2
│   关系型数据库   │     │   向量数据库     │
3
│  (PostgreSQL)   │     │    (Chroma)     │
4
├─────────────────┤     ├─────────────────┤
5
│ • 用户管理      │     │ • 语义检索      │
6
│ • 权限控制      │     │ • 相似度搜索    │
7
│ • 事务处理      │     │ • 向量存储      │
8
│ • 复杂关联查询  │     │ • 快速 ANN 搜索 │
9
└─────────────────┘     └─────────────────┘
10
         ↑                       ↑
11
         └──────────┬────────────┘
12
                    ↓
13
              FastAPI 后端

1
from pydantic import BaseModel
2
from typing import List
3

4
class ChunkVector(BaseModel):
5
    """生产级向量记录结构"""
6
    id: str               # 主键，桥接关系库
7
    content: str          # 原文内容（省去回查关系库）
8
    # vector: List[float] # Chroma 自动生成，通常不显式存储
9

10
    # 标量过滤字段（检索前预过滤）
11
    knowledge_base_id: str  # 知识库分区键
12
    document_id: str        # 所属文档 ID
13
    enabled: bool = True    # 是否启用

1
import chromadb
2
from fastapi import FastAPI, HTTPException
3
from pydantic import BaseModel
4

5
app = FastAPI()
6

7
# 1. 初始化向量数据库（类似 Engine）
8
client = chromadb.PersistentClient(path="./db")
9

10
# 2. 创建集合（类似 Table）
11
collection = client.get_or_create_collection(name="tech_docs")
12

13

14
class IngestRequest(BaseModel):
15
    text: str
16
    doc_id: str
17

18

19
@app.post("/ingest")
20
async def ingest_document(req: IngestRequest):
21
    """将文档存入向量库"""
22
    try:
23
        collection.add(
24
            documents=[req.text],
25
            ids=[req.doc_id],
26
            metadatas=[{"source": "manual"}]
27
        )
28
        return {"status": "success", "id": req.doc_id}
29
    except Exception as e:
30
        raise HTTPException(status_code=500, detail=str(e))
31

32

33
@app.get("/search")
34
async def search_knowledge(query: str):
35
    """语义检索"""
36
    # 关键区别：不是 LIKE 查询，而是 ANN 搜索
37
    results = collection.query(
38
        query_texts=[query],
39
        n_results=3
40
    )
41
    return {
42
        "query": query,
43
        "matches": results['documents'][0]
44
    }

1
from openai import OpenAI
2
import numpy as np
3

4
client = OpenAI(
5
    base_url='https://api-inference.modelscope.cn/v1',
6
    api_key='your-token',
7
)
8

9
def get_embedding(text: str) -> list[float]:
10
    """获取文本的向量表示"""
11
    response = client.embeddings.create(
12
        model='BAAI/bge-large-zh-v1.5',  # 中文 Embedding 模型
13
        input=text,
14
    )
15
    return response.data[0].embedding
16

17
# 测试
18
vec1 = get_embedding("如何提升代码质量")
19
vec2 = get_embedding("提高程序可维护性的方法")
20
vec3 = get_embedding("今天天气真好")
21

22
print(f"vec1 维度: {len(vec1)}")  # 1024 维
23

24
# 计算相似度
25
def cosine_similarity(a, b):
26
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
27

28
print(f"A-B 相似度: {cosine_similarity(vec1, vec2):.3f}")  # 0.85+（很相似）
29
print(f"A-C 相似度: {cosine_similarity(vec1, vec3):.3f}")  # 0.30-（不相似）

1
# 虽然向量是 1024 维，但我们可以理解为：
2
# 每句话在高维空间中有一个"坐标"
3
# 语义相近的句子，坐标距离也近
4

5
句子空间分布（想象图）:
6

7
    "代码重构" ●
8
              ╲
9
               ╲  距离近
10
                ╲
11
    "提升质量" ●──● "程序维护"
12
                ╱
13
               ╱  距离远
14
              ╱
15
    "天气很好" ●

1
你已学的知识 → 本章新知
2

3
SQLAlchemy ORM → Chroma Collection
4
SQL 查询      → 向量相似度搜索
5
Pydantic 模型  → ChunkVector 设计
6
FastAPI 路由   → /ingest + /search
7
OpenAI API     → Embedding API

1
import chromadb
2

3
# 创建客户端
4
client = chromadb.PersistentClient(path="./db")
5

6
# 创建/获取集合
7
collection = client.get_or_create_collection(name="my_collection")
8

9
# 添加数据
10
collection.add(
11
    documents=["文本1", "文本2"],
12
    ids=["id1", "id2"],
13
    metadatas=[{"key": "val1"}, {"key": "val2"}]
14
)
15

16
# 查询
17
collection.query(
18
    query_texts=["查询文本"],
19
    n_results=3,
20
    where={"key": "val1"}  # 元数据过滤
21
)
22

23
# 删除
24
collection.delete(ids=["id1"])

1
response = client.embeddings.create(
2
    model='BAAI/bge-large-zh-v1.5',
3
    input='要转换的文本',
4
)
5
vector = response.data[0].embedding