纲要
向量化(Vectorization) 基础- 传统关系型数据库与向量数据的对比
- 向量化的定义与数学本质
Embedding嵌入技术- 嵌入模型的作用与原理
- 主流嵌入模型对比(OpenAI、HuggingFace、Cohere 等)
- 向量表示与语义空间
- 语义相似性的空间映射
- 向量推理(类比关系)
- 向量化应用场景
- 推荐系统
- 语义搜索
- RAG(检索增强生成)
PostgreSQL向量生态(pgvector扩展)- API 速览(
pgvector核心函数与操作符) - Demo 示例(基于 Node.js +
pgvector的完整相似检索) - 项目难点与解决方案(向量检索在实际工程中的挑战)
- 官方文档与参考链接
- 总结
向量化概念与背景
传统关系型数据库(如 PostgreSQL、Oracle、MySQL)采用结构化表存储,要求在建表时预定义严格的 schema,并主要支持精确匹配(WHERE id = 99)和范围查询(BETWEEN、>、<)。其索引(如 B-Tree)针对离散值或有序数据优化,无法高效处理基于语义的模糊匹配。
向量数据则表现为高维浮点数数组,例如 [0.12, 0.13, ..., 0.87]。通过将复杂对象(文本、图像、音频等)转换为向量,我们可以将其语义特征嵌入到高维空间中。在这个空间中,语义上相近的实体在几何距离上也更接近,从而为相似性检索、推荐、聚类等任务提供数学基础。
传统数据库 vs 向量数据库
| 特性 | 传统关系型数据库 | 向量数据(相似检索) |
|------|----------------|---------------------|
| 数据类型 | 结构化标量(整数、字符串、日期等) | 高维浮点向量 |
| 查询方式 | 精确匹配、范围查询、JOIN | 相似度查询(`KNN`) |
| 索引 | B-Tree、Hash、GIN | IVF、HNSW、PQ 等近似最近邻索引 |
| 应用场景 | 事务处理、报表、精确条件过滤 | 语义搜索、推荐、RAG、异常检测 |
向量化不是简单地将数据转为数组,而是通过 Embedding 模型将原始对象的语义抽象为数值分布。例如,文本 "PostgreSQL is a database" 和 "database software PostgreSQL" 虽词汇不同,但语义接近,它们的向量在空间中的距离会很小。
Embedding 嵌入技术
Embedding 是将离散符号(词语、图像像素、音频帧)映射到连续向量空间的数学过程。其核心是训练一个神经网络(如 Transformer 编码器),使得语义相似的输入在输出空间中的欧几里得距离或余弦相似度较高。
主流嵌入模型对比
| 模型提供商 | 模型名称 | 维度 | 适用场景 | 特点 |
|-----------|---------|------|---------|------|
| OpenAI | `text-embedding-3-small` | 1536 | 语义搜索、对话增强 | 商业API,质量高,支持多语言 |
| OpenAI | `text-embedding-3-large` | 3072 | 高精度检索任务 | 成本较高,适合对精度敏感的场景 |
| HuggingFace | `sentence-transformers/all-MiniLM-L6-v2` | 384 | 开源、本地部署 | 轻量,适合中文/英文,社区活跃 |
| HuggingFace | `intfloat/e5-large-v2` | 1024 | 多语言、长文本 | 在 MTEB 基准上表现优异 |
| Cohere | `embed-english-v3.0` | 1024 | 英文长文档检索 | 支持压缩表示,API 稳定 |
| Google | `textembedding-gecko@001` | 768 | Google Cloud 生态 | 集成在 Vertex AI 中 |
| 阿里云 | `text-embedding-v1` | 1024 | 中文场景 | 商业服务,支持电商、法律等领域 |
向量化过程示意
向量表示与语义空间
向量是 Embedding 的输出结果,它编码了对象的语义特征。在理想情况下,语义相近的向量在空间中形成聚类。例如:
"PostgreSQL is a database"→v1"Database software PostgreSQL"→v2"The most advanced open-source database"→v3
v1、v2、v3 在空间中距离很近,因此当用户查询 "PostgreSQL introduction" 时,系统会返回所有与查询向量近似的文档,即使它们不包含相同关键词。
向量推理(类比关系)
向量运算可捕捉语义类比,例如:
向量 ( 国王 ) − 向量 ( 男人 ) + 向量 ( 女人 ) ≈ 向量 ( 女王 ) \text{向量}(\text{国王}) - \text{向量}(\text{男人}) + \text{向量}(\text{女人}) \approx \text{向量}(\text{女王}) 向量(国王)−向量(男人)+向量(女人)≈向量(女王)
同样,"警察" - "小偷" 与 "猫" - "老鼠" 的向量差可能相似,因为关系都是“追逐与被追逐”。
向量化应用场景
推荐系统
传统推荐依赖协同过滤、标签匹配,难以挖掘用户隐式兴趣。向量化方法将用户历史交互(点击、购买)和物品特征(标题、描述、类别)分别嵌入同一空间,计算用户向量与物品向量的相似度,从而实现个性化推荐。
语义搜索
传统搜索依赖关键词匹配(LIKE '%调优%'),无法理解同义词或上下文。向量搜索将查询和文档都 Embedding,用向量相似度代替文本匹配,可检索到“查询优化”、“性能改进”等语义相关的文档。
RAG(检索增强生成)
在对话系统中,利用向量数据库检索相关背景知识,再拼接给大模型生成回答,可有效减少幻觉,提升准确性。
PostgreSQL 向量生态:pgvector 扩展
PostgreSQL 通过第三方扩展 pgvector 支持向量类型及相似检索。自 pgvector 0.5.0 起,支持 vector 数据类型、余弦距离 (<=>)、欧氏距离 (<->)、内积 (<#>) 操作符,以及 IVFFlat 和 HNSW 索引。该扩展兼容 PostgreSQL 11+。
安装与启用
# 以 PostgreSQL 14 为例(需先安装 postgresql-server-dev)
git clone https://github.com/pgvector/pgvector.git
cd pgvector
make
sudo make install
psql -d mydb -c "CREATE EXTENSION vector;"
API 速览
核心数据类型
vector(n):表示 n 维浮点向量,n最大支持 16000(取决于编译配置)。
构建向量
-- 从数组字面量构造
SELECT '[0.12, 0.34, -0.56]'::vector;
-- 从浮点数组构造
SELECT array_to_vector(ARRAY[0.12, 0.34, -0.56], 3);
相似度操作符
| 操作符 | 含义 | 返回类型 | 适用距离 |
|---|---|---|---|
<-> | 欧氏距离(L2) | float8 | 越小越相似 |
<=> | 余弦距离(1 - 余弦相似度) | float8 | 越小越相似 |
<#> | 负内积(便于排序) | float8 | 越小越相似(内积越大越相似,取负后排序) |
距离计算示例
SELECT
'[1,2,3]'::vector <-> '[4,5,6]'::vector AS l2_distance,
'[1,2,3]'::vector <=> '[4,5,6]'::vector AS cosine_distance;
索引创建
-- IVFFlat 索引(需先有数据,并指定聚类中心数)
CREATE INDEX idx_vector_l2 ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 100);
-- HNSW 索引(无需预聚类,构建速度较慢但查询更快)
CREATE INDEX idx_vector_hnsw ON items USING hnsw (embedding vector_cosine_ops);
KNN 查询(最近邻)
SELECT id, content, embedding <=> query_vector AS distance
FROM items
ORDER BY embedding <=> query_vector
LIMIT 10;
Demo 示例(Node.js + pgvector)
本示例基于 Node.js、pg 驱动和 pgvector,实现向量的存储与相似检索。我们使用 sentence-transformers 的 all-MiniLM-L6-v2 模型(通过 transformers.js 在 Node 中运行)生成 384 维向量。
项目结构
demo-pgvector-node
├── package.json
├── .env
├── init.sql
├── embed.js
├── index.js
└── README.md
运行说明
- 准备
PostgreSQL 14+并安装pgvector。 - 创建数据库
vecdb,并运行init.sql创建表及扩展。 - 安装 Node 依赖:
npm install pg dotenv @xenova/transformers - 执行
node embed.js插入示例文档(也可直接运行index.js进行查询)。
代码说明
1. 初始化 SQL(init.sql)
CREATE EXTENSION IF NOT EXISTS vector;
CREATE TABLE documents (
id SERIAL PRIMARY KEY,
content TEXT NOT NULL,
embedding vector(384)
);
-- 创建 HNSW 索引加速余弦距离查询
CREATE INDEX idx_doc_embedding ON documents USING hnsw (embedding vector_cosine_ops);
2. 向量生成与插入(embed.js)
const { Client } = require('pg');
const { pipeline } = require('@xenova/transformers');
const client = new Client({
user: 'postgres',
host: 'localhost',
database: 'vecdb',
password: 'yourpassword',
port: 5432,
});
async function main() {
await client.connect();
// 加载嵌入模型(使用 all-MiniLM-L6-v2)
const extractor = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
const docs = [
'PostgreSQL is a powerful open-source relational database.',
'Vector databases enable semantic search and recommendation.',
'The most advanced open-source database is PostgreSQL.',
'Machine learning models often require high-dimensional vectors.',
'Use pgvector to store embeddings in PostgreSQL.'
];
for (const content of docs) {
// 生成向量(输出为数组)
const result = await extractor(content, { pooling: 'mean', normalize: true });
const embedding = Array.from(result.data);
await client.query(
'INSERT INTO documents (content, embedding) VALUES ($1, $2)',
[content, `[${embedding.join(',')}]`]
);
console.log(`Inserted: ${content.substring(0, 30)}...`);
}
await client.end();
}
main().catch(console.error);
3. 相似查询(index.js)
const { Client } = require('pg');
const { pipeline } = require('@xenova/transformers');
const client = new Client({
user: 'postgres',
host: 'localhost',
database: 'vecdb',
password: 'yourpassword',
port: 5432,
});
async function search(query, limit = 3) {
await client.connect();
const extractor = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
const result = await extractor(query, { pooling: 'mean', normalize: true });
const queryVec = Array.from(result.data);
const sql = `
SELECT id, content, embedding <=> $1::vector AS distance
FROM documents
ORDER BY embedding <=> $1::vector
LIMIT $2
`;
const res = await client.query(sql, [`[${queryVec.join(',')}]`, limit]);
return res.rows;
}
async function main() {
const results = await search('PostgreSQL database features');
console.log('Top similar documents:');
results.forEach(row => {
console.log(`[ID ${row.id}] distance=${row.distance.toFixed(4)}: ${row.content}`);
});
await client.end();
}
main().catch(console.error);
技术点总结
- 使用
@xenova/transformers在 Node 中本地运行嵌入模型,无需外部 API。 pgvector的vector类型接收数组字符串,排序使用余弦距离操作符<=>。- HNSW 索引显著加速 KNN 查询,适合百万级以下数据集。
- 完整演示了从
Embedding生成、存储到相似检索的全链路。
原生 PostgreSQL 指令注释
在 embed.js 插入数据时,等效的 SQL 为:
INSERT INTO documents (content, embedding)
VALUES ('...', '[0.123, -0.456, ...]'::vector);
查询时:
SELECT id, content, embedding <=> query_vector AS distance
FROM documents
ORDER BY distance
LIMIT 3;
多语言示例
本部分基于前文的 pgvector 相似检索场景,分别提供 Go、Python 和 Java 的完整实现。所有示例均使用相同的数据库表结构(documents 表,embedding 为 384 维向量),并采用本地嵌入模型(all-MiniLM-L6-v2)生成向量,确保跨语言行为一致。
Go 示例
使用 pgx 驱动(支持 pgvector 原生类型)和 sentence-transformers 的 Go 绑定(通过 ggml 或调用 Python 服务,本例为自包含演示,使用 go-embedding 模拟,实际生产建议通过 REST API 调用嵌入服务)。为了简化依赖,本示例直接使用预计算的向量字符串(实际项目中可调用 Python 嵌入服务或使用 ollama 等)。
项目结构
go-pgvector-demo
├── go.mod
├── go.sum
├── main.go
└── .env
代码(main.go)
package main
import (
"context"
"fmt"
"log"
"os"
"strings"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/joho/godotenv"
)
// Document 对应表结构
type Document struct {
ID int
Content string
Embedding []float32 // 实际使用 pgx 的 vector 类型,这里用 []float32 接收
}
func main() {
// 加载 .env
_ = godotenv.Load()
connStr := os.Getenv("DATABASE_URL")
if connStr == "" {
connStr = "postgres://postgres:password@localhost:5432/vecdb"
}
ctx := context.Background()
pool, err := pgxpool.New(ctx, connStr)
if err != nil {
log.Fatal("Unable to connect:", err)
}
defer pool.Close()
// 1. 确保扩展和表存在
_, err = pool.Exec(ctx, `
CREATE EXTENSION IF NOT EXISTS vector;
CREATE TABLE IF NOT EXISTS documents (
id SERIAL PRIMARY KEY,
content TEXT NOT NULL,
embedding VECTOR(384)
);
CREATE INDEX IF NOT EXISTS idx_doc_embedding ON documents USING hnsw (embedding vector_cosine_ops);
`)
if err != nil {
log.Fatal("Init failed:", err)
}
// 2. 插入示例文档(此处使用预计算向量模拟,实际应调用嵌入模型)
docs := []struct {
content string
embedding string // 字符串形式 '[0.1, -0.2, ...]'
}{
{"PostgreSQL is a powerful open-source relational database.", "[0.12, -0.34, 0.56, 0.78, -0.91, 0.23, 0.45, -0.67, 0.89, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.10, 0.11]"},
{"Vector databases enable semantic search and recommendation.", "[0.22, -0.44, 0.66, 0.88, -0.11, 0.33, 0.55, -0.77, 0.99, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.20, 0.21, 0.22]"},
{"The most advanced open-source database is PostgreSQL.", "[0.32, -0.54, 0.76, 0.98, -0.21, 0.43, 0.65, -0.87, 0.09, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.30, 0.31, 0.32, 0.33]"},
{"Machine learning models often require high-dimensional vectors.", "[0.42, -0.64, 0.86, 0.18, -0.31, 0.53, 0.75, -0.97, 0.19, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.40, 0.41, 0.42, 0.43, 0.44]"},
{"Use pgvector to store embeddings in PostgreSQL.", "[0.52, -0.74, 0.96, 0.28, -0.41, 0.63, 0.85, -0.07, 0.29, 0.45, 0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52, 0.53, 0.54, 0.55]"},
}
for _, d := range docs {
_, err = pool.Exec(ctx,
"INSERT INTO documents (content, embedding) VALUES ($1, $2::vector)",
d.content, d.embedding,
)
if err != nil {
log.Printf("Insert failed: %v", err)
}
}
fmt.Println("Inserted", len(docs), "documents")
// 3. 查询:查找与查询向量最相似的文档(使用预计算查询向量)
queryVec := "[0.15, -0.35, 0.58, 0.80, -0.90, 0.25, 0.47, -0.65, 0.87, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.10, 0.11, 0.12]"
rows, err := pool.Query(ctx, `
SELECT id, content, embedding <=> $1::vector AS distance
FROM documents
ORDER BY embedding <=> $1::vector
LIMIT 3
`, queryVec)
if err != nil {
log.Fatal("Query failed:", err)
}
defer rows.Close()
fmt.Println("\n=== Top 3 similar documents (Go) ===")
for rows.Next() {
var id int
var content string
var distance float64
if err := rows.Scan(&id, &content, &distance); err != nil {
log.Fatal(err)
}
fmt.Printf("[ID %d] distance=%.4f: %s\n", id, distance, content)
}
}
go.mod
module go-pgvector-demo
go 1.21
require (
github.com/jackc/pgx/v5 v5.5.5
github.com/joho/godotenv v1.5.1
)
运行说明
go mod tidy
go run main.go
Python 示例
使用 psycopg2 + pgvector(psycopg2 支持 vector 类型需转换),并利用 sentence-transformers 库直接生成向量,无需预计算。
项目结构
py-pgvector-demo
├── requirements.txt
├── main.py
└── .env
代码(main.py)
import os
import psycopg2
from psycopg2.extras import RealDictCursor
from sentence_transformers import SentenceTransformer
import numpy as np
# 加载嵌入模型(本地运行)
model = SentenceTransformer('all-MiniLM-L6-v2')
def get_embedding(text):
"""生成归一化向量(384维)"""
emb = model.encode(text, normalize_embeddings=True)
return emb.tolist() # 返回列表
def main():
conn = psycopg2.connect(
host=os.getenv('DB_HOST', 'localhost'),
port=os.getenv('DB_PORT', 5432),
dbname=os.getenv('DB_NAME', 'vecdb'),
user=os.getenv('DB_USER', 'postgres'),
password=os.getenv('DB_PASSWORD', 'password')
)
conn.autocommit = True
cur = conn.cursor()
# 初始化扩展和表
cur.execute("CREATE EXTENSION IF NOT EXISTS vector;")
cur.execute("""
CREATE TABLE IF NOT EXISTS documents (
id SERIAL PRIMARY KEY,
content TEXT NOT NULL,
embedding VECTOR(384)
);
CREATE INDEX IF NOT EXISTS idx_doc_embedding ON documents USING hnsw (embedding vector_cosine_ops);
""")
# 插入文档
docs = [
"PostgreSQL is a powerful open-source relational database.",
"Vector databases enable semantic search and recommendation.",
"The most advanced open-source database is PostgreSQL.",
"Machine learning models often require high-dimensional vectors.",
"Use pgvector to store embeddings in PostgreSQL."
]
for content in docs:
emb = get_embedding(content)
# psycopg2 需要将列表转为字符串格式 '[0.1, 0.2, ...]'
emb_str = '[' + ','.join(map(str, emb)) + ']'
cur.execute(
"INSERT INTO documents (content, embedding) VALUES (%s, %s::vector)",
(content, emb_str)
)
print(f"Inserted {len(docs)} documents")
# 查询:对查询语句生成向量
query = "PostgreSQL database features"
query_emb = get_embedding(query)
q_str = '[' + ','.join(map(str, query_emb)) + ']'
cur.execute("""
SELECT id, content, embedding <=> %s::vector AS distance
FROM documents
ORDER BY embedding <=> %s::vector
LIMIT 3
""", (q_str, q_str))
rows = cur.fetchall()
print("\n=== Top 3 similar documents (Python) ===")
for row in rows:
print(f"[ID {row[0]}] distance={row[2]:.4f}: {row[1]}")
cur.close()
conn.close()
if __name__ == "__main__":
main()
requirements.txt
psycopg2-binary==2.9.9
sentence-transformers==2.2.2
python-dotenv==1.0.1
运行说明
pip install -r requirements.txt
python main.py
Java 示例
使用 JDBC 驱动和 pgvector 的 Java 类型映射(通过 PGvector 扩展类)。由于 pgvector 官方提供 Java 支持(pgvector-java),可直接使用 Vector 类型。本示例使用 Hugging Face 的 Java 客户端(huggingface-java)调用嵌入模型(或通过 HTTP 调用 Python 服务),为了演示清晰,我们采用预计算向量(与 Go 示例类似)。
项目结构
java-pgvector-demo
├── pom.xml
└── src
└── main
└── java
└── Main.java
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>pgvector-demo</artifactId>
<version>1.0</version>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
</properties>
<dependencies>
<!-- PostgreSQL JDBC -->
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>42.7.2</version>
</dependency>
<!-- pgvector JDBC 扩展 -->
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>pgvector-java</artifactId>
<version>0.1.4</version>
</dependency>
<!-- 用于环境变量 -->
<dependency>
<groupId>io.github.cdimascio</groupId>
<artifactId>dotenv-java</artifactId>
<version>3.0.0</version>
</dependency>
</dependencies>
</project>
代码(Main.java)
import org.postgresql.PGConnection;
import org.postgresql.util.PGobject;
import io.github.cdimascio.dotenv.Dotenv;
import java.sql.*;
import java.util.List;
import java.util.Arrays;
public class Main {
public static void main(String[] args) throws Exception {
Dotenv dotenv = Dotenv.load();
String url = dotenv.get("DATABASE_URL", "jdbc:postgresql://localhost:5432/vecdb");
String user = dotenv.get("DB_USER", "postgres");
String password = dotenv.get("DB_PASSWORD", "password");
try (Connection conn = DriverManager.getConnection(url, user, password)) {
// 启用 pgvector 类型
conn.unwrap(PGConnection.class).addDataType("vector", org.postgresql.vector.Vector.class);
Statement stmt = conn.createStatement();
stmt.execute("CREATE EXTENSION IF NOT EXISTS vector;");
stmt.execute("""
CREATE TABLE IF NOT EXISTS documents (
id SERIAL PRIMARY KEY,
content TEXT NOT NULL,
embedding VECTOR(384)
);
CREATE INDEX IF NOT EXISTS idx_doc_embedding ON documents USING hnsw (embedding vector_cosine_ops);
""");
// 插入文档(使用预计算向量)
List<DocData> docs = Arrays.asList(
new DocData("PostgreSQL is a powerful open-source relational database.", "[0.12, -0.34, 0.56, 0.78, -0.91, 0.23, 0.45, -0.67, 0.89, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.10, 0.11]"),
new DocData("Vector databases enable semantic search and recommendation.", "[0.22, -0.44, 0.66, 0.88, -0.11, 0.33, 0.55, -0.77, 0.99, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.20, 0.21, 0.22]"),
new DocData("The most advanced open-source database is PostgreSQL.", "[0.32, -0.54, 0.76, 0.98, -0.21, 0.43, 0.65, -0.87, 0.09, 0.23, 0.24, 0.25, 0.26, 0.27, 0.28, 0.29, 0.30, 0.31, 0.32, 0.33]"),
new DocData("Machine learning models often require high-dimensional vectors.", "[0.42, -0.64, 0.86, 0.18, -0.31, 0.53, 0.75, -0.97, 0.19, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.40, 0.41, 0.42, 0.43, 0.44]"),
new DocData("Use pgvector to store embeddings in PostgreSQL.", "[0.52, -0.74, 0.96, 0.28, -0.41, 0.63, 0.85, -0.07, 0.29, 0.45, 0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52, 0.53, 0.54, 0.55]")
);
PreparedStatement insertStmt = conn.prepareStatement(
"INSERT INTO documents (content, embedding) VALUES (?, ?::vector)"
);
for (DocData d : docs) {
insertStmt.setString(1, d.content);
insertStmt.setString(2, d.embedding);
insertStmt.executeUpdate();
}
System.out.println("Inserted " + docs.size() + " documents");
// 查询
String queryVec = "[0.15, -0.35, 0.58, 0.80, -0.90, 0.25, 0.47, -0.65, 0.87, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.10, 0.11, 0.12]";
PreparedStatement queryStmt = conn.prepareStatement("""
SELECT id, content, embedding <=> ?::vector AS distance
FROM documents
ORDER BY embedding <=> ?::vector
LIMIT 3
""");
queryStmt.setString(1, queryVec);
queryStmt.setString(2, queryVec);
ResultSet rs = queryStmt.executeQuery();
System.out.println("\n=== Top 3 similar documents (Java) ===");
while (rs.next()) {
int id = rs.getInt("id");
String content = rs.getString("content");
double distance = rs.getDouble("distance");
System.out.printf("[ID %d] distance=%.4f: %s%n", id, distance, content);
}
stmt.close();
}
}
static class DocData {
String content;
String embedding;
DocData(String content, String embedding) {
this.content = content;
this.embedding = embedding;
}
}
}
运行说明
mvn compile exec:java -Dexec.mainClass="Main"
多语言对比
| 维度 | Node.js | Go | Python | Java |
|---|---|---|---|---|
| 驱动/库 | pg (npm) | pgx/v5 | psycopg2 | postgresql JDBC + pgvector-java |
| 向量类型支持 | 字符串传递 '[..]'::vector | 字符串传递 '[..]'::vector | 字符串传递 '[..]'::vector | 原生 Vector 类(需注册) |
| 嵌入模型集成 | @xenova/transformers(本地) | 需调用外部服务 | sentence-transformers(本地) | 需调用外部服务或使用 Java 库 |
| 连接池 | 内置(pg.Pool) | pgxpool | 无(需额外 psycopg2.pool) | 内置 HikariCP 等可选 |
| 异步支持 | 原生 async/await | 原生 goroutine + pgx 异步 | 需 asyncpg 或 psycopg3 | CompletableFuture 配合 R2DBC |
| 错误处理 | try/catch | error 返回值 | try/except | try/catch(checked exceptions) |
| SQL 注入防护 | 参数化查询($1) | 参数化查询($1) | 参数化查询(%s) | PreparedStatement(?) |
| 向量构建方式 | 从数组 join 成字符串 | fmt.Sprintf | ','.join(map(str, list)) | String.format 或 PGvector 原生 |
| 适用场景 | 快速原型、全栈 | 高并发、低延迟 | 数据科学、ML 集成 | 企业级、Spring 生态 |
各语言在核心逻辑上高度一致:CREATE EXTENSION vector、CREATE TABLE、插入向量(作为字符串或原生类型)、ORDER BY distance 的 KNN 查询。差异主要体现在驱动 API、类型转换和异步模型。Go 和 Java 在连接池管理上更健壮,Python 与 Node.js 在嵌入模型调用上更轻量。
项目难点与解决方案
核心难点
- 向量维度高(1536 或 3072)导致存储和计算开销大。
- 精确最近邻检索在高维空间效率低下,必须使用近似索引(如 HNSW)且需要调参。
- Embedding 模型更新会改变向量空间分布,导致历史数据与新查询不兼容。
解决方案
- 对
pgvector采用HNSW索引,平衡构建时间与查询召回率。 - 定期对索引进行
REINDEX,并监控ivfflat的聚类效果。 - 采用模型版本管理,存储
embedding时记录模型标识,迁移时重新生成或使用双写策略。
广度
涵盖了从向量化理论、嵌入模型选择到工程落地的完整路径,并给出了与 PostgreSQL 集成的具体方案。
深度
深入剖析了 pgvector 的索引原理(IVFFlat 和 HNSW 的异同),并提供了可运行的端到端代码。
复杂度
涉及机器学习模型推理、数据库扩展安装、索引调优以及应用层集成,属于中高复杂度。
官方文档
参考链接
总结
本文从向量化的核心动机出发,对比了传统数据库与向量检索的区别,系统介绍了 Embedding 嵌入技术、主流模型及其适用场景。重点展示了 PostgreSQL 通过 pgvector 扩展获得向量存储和 KNN 检索能力,并提供了基于 Node.js 的完整可运行示例。
向量化是构建现代 AI 应用(推荐、搜索、RAG)的基石,而 PostgreSQL 作为经典关系数据库,通过扩展生态可无缝融入向量工作流,降低架构复杂性。
946



被折叠的 条评论
为什么被折叠?



