PostgreSQL笔记51: 基于 pgvector 构建企业级智能问答系统

PostgreSQL+pgvector+Valkey构建AI推理内存层 向量数据库并非单纯存储系统,而是AI推理工作负载下的新型数据平面。其核心在于将向量相似度计算、索引优化与缓存调度深度耦合,形成具备低延迟、高并发特性的推理加速中间件。pgvector作为SQL原生向量运算引擎,支持SIMD指令编译与查询计划下推;Valkey则超越传统缓存角色,承担布隆过滤、候选路由与置信度分级等L7网关职能。二者协同依赖共享内存、事件总线与零拷贝传输等底层IPC机制,共同构成面向RAG、语义检索等场景的Inference Cloud Memory Layer——这正是当前开发者高频搜索‘p 阅读详情

纲要

  • RAG (Retrieval-Augmented Generation) 系统架构
    • 用户查询输入
    • 文本向量化 (Embedding)
    • 向量相似度检索 (Vector Similarity Search)
    • 大模型答案生成 (LLM Generation)
  • PostgreSQL + pgvector 的技术选型优势
    • 一库多用:关系型数据与向量数据融合
    • 扩展生态:pgvector, pgcrypto, pgAudit
    • 企业级特性:Row Level Security (RLS), 事务一致性, 权限控制
  • 数据库层设计
    • 表结构设计:知识片段存储与元数据管理
    • 向量索引:IVFFlat 与 HNSW 的选择与创建
    • 相似度检索:距离函数 (<->, <=>, <#>) 与 TOP-K 查询
  • 系统集成
    • 应用层通过 PostgreSQL 客户端直连
    • 与 LLM 服务协同完成 RAG 闭环

项目背景与业务场景

企业在运营过程中积累了大量分散的知识资产,包括技术文档、产品手册、FAQ、白皮书以及各类案例。当员工或客户提出问题时,如何从这些海量文档中快速、准确地定位答案,是一个普遍存在的痛点。

传统的解决方案依赖于关系型数据库的全文检索或关键词匹配(如 LIKE 查询)。这类方法的效果有限,因为它无法理解语义。例如,用户搜索“如何提升数据库写入性能”,系统可能无法匹配到内容为“优化插入速度”、“减少索引维护”或“降低外键约束”的文档,尽管这些内容在语义上高度相关。

向量数据库技术的引入改变了这一局面。它将文本转换为高维向量,通过计算向量间的距离来衡量语义相似度,从而实现基于语义的检索,而非简单的关键词匹配。PostgreSQL 通过 pgvector 扩展,原生支持了这种语义检索能力。

本项目旨在构建一个面向特定知识库的智能问答系统,即 RAG (Retrieval-Augmented Generation) 系统。RAG 是一种架构模式,它将大语言模型(LLM)与外部知识检索系统相结合。系统根据用户查询从知识库中检索相关信息,并将这些信息作为上下文提供给 LLM,从而生成更准确、更具时效性的答案。

系统架构与核心链路

一个完整的 RAG 问答系统遵循以下核心链路:

大语言模型 PostgreSQL (pgvector) 应用服务 用户 大语言模型 PostgreSQL (pgvector) 应用服务 用户 输入问题 文本向量化 (Embedding) 执行向量相似度检索 返回 TOP-K 相关知识片段 将问题与知识片段作为上下文发送 生成最终答案 返回答案

在上述流程中,PostgreSQL 与 pgvector 承担了核心的向量存储与检索职责:

  1. 向量化:应用层将用户问题转换为向量表示。
  2. 语义检索:PostgreSQL 在数据库中执行向量相似度搜索,返回最相似的 TOP-K 个知识片段。
  3. 答案生成:应用层将检索到的知识片段与原始问题组合,构造 Prompt 发送给 LLM,生成最终答案。

数据库层的质量(召回率与响应速度)直接决定了整个系统的最终表现。

PostgreSQL + pgvector 的技术优势

选择 PostgreSQL 与 pgvector 作为 RAG 系统的知识库底座,基于以下核心优势:

一库多用,消除数据库孤岛

PostgreSQL 本身是一个功能强大的关系型数据库。通过 pgvector 扩展,它获得了向量存储与检索能力,成为一个融合型数据平台。这意味着在同一个数据库中,可以同时存储:

  • 结构化数据(如用户信息、文档元数据)
  • 向量数据(如文本嵌入向量)
  • 半结构化数据(如 JSON/JSONB)

这种设计减少了系统组件的数量,降低了架构复杂度与维护成本。

丰富的扩展生态

在向量检索领域,pgvector 是 PostgreSQL 社区最主流的扩展之一。它支持:

  • 多种向量数据类型(vector, halfvec, sparsevec)
  • 多种距离函数:欧几里得距离(<->)、余弦相似度(<=>)、内积(<#>)
  • 近似最近邻(ANN)索引:IVFFlat 与 HNSW

PostgreSQL 庞大的扩展生态(如 pgcrypto 用于加密、pgAudit 用于审计)可以与 pgvector 无缝协同,满足企业级应用的各种需求。

企业级特性

  • 事务一致性:向量数据的插入与更新遵循 ACID 事务原则,确保数据一致性。
  • 权限控制:依托 PostgreSQL 成熟的角色与权限管理体系。
  • 行级安全(RLS):可以针对不同用户或角色,控制其对表中特定行的可见性。例如,高权限用户可以看到完整的文档内容,而普通用户只能看到脱敏后的版本。
  • 集成简单:应用层只需使用标准的 PostgreSQL 客户端驱动即可完成所有操作,无需引入额外的向量数据库组件。

数据库层设计

表结构设计

以下是一个用于存储知识片段及其向量的核心表结构设计:

-- 启用 pgvector 扩展 (注意:扩展名是 vector,不是 pgvector)
CREATE EXTENSION IF NOT EXISTS vector;

-- 创建知识片段表
CREATE TABLE knowledge_chunks (
    id BIGSERIAL PRIMARY KEY,
    -- 知识片段的原始文本内容
    content TEXT NOT NULL,
    -- 内容的向量表示,维度取决于所使用的 Embedding 模型(例如 768 或 1536)
    embedding VECTOR(1536),
    -- 元数据字段
    source VARCHAR(255),          -- 来源,如 "技术手册"、"FAQ"
    title VARCHAR(255),           -- 所属文档标题
    document_id VARCHAR(64),      -- 所属文档 ID
    created_at TIMESTAMPTZ DEFAULT NOW(),
    updated_at TIMESTAMPTZ DEFAULT NOW()
);

-- 为元数据创建普通索引,用于过滤查询
CREATE INDEX idx_knowledge_chunks_source ON knowledge_chunks (source);
CREATE INDEX idx_knowledge_chunks_document_id ON knowledge_chunks (document_id);

向量索引的选择与创建

pgvector 提供了两种近似最近邻(ANN)索引:

索引类型特点适用场景
IVFFlat将向量划分为多个聚类桶。查询时先定位最近的桶,再在桶内搜索。数据集较大且数据分布相对稳定。索引创建后,建议在数据积累到一定规模后再构建,以获得更好的分区效果。
HNSW构建多层图结构。查询时从顶层开始逐层向下搜索。追求极致的查询速度,且数据会频繁增量插入。HNSW 索引可以在空表上创建,并随着数据插入动态更新。

根据实际需求选择索引类型并创建:

-- 创建 IVFFlat 索引 (需指定 lists 参数,即聚类数量)
-- 建议在表中已有一定量数据后创建
CREATE INDEX idx_knowledge_chunks_embedding_ivfflat 
ON knowledge_chunks 
USING ivfflat (embedding vector_cosine_ops) 
WITH (lists = 100);

-- 创建 HNSW 索引 (需指定 m 和 ef_construction 参数)
-- 可以在空表上直接创建
CREATE INDEX idx_knowledge_chunks_embedding_hnsw 
ON knowledge_chunks 
USING hnsw (embedding vector_cosine_ops) 
WITH (m = 16, ef_construction = 64);

向量相似度检索

执行 TOP-K 语义检索的典型查询语句:

-- 假设已通过应用层生成查询向量 (嵌入向量)
-- 使用余弦距离 (<=>) 进行相似度排序,返回最相似的 5 条记录
SELECT 
    id,
    content,
    source,
    title,
    1 - (embedding <=> '[0.1, 0.2, ...]'::vector) AS similarity
FROM knowledge_chunks
ORDER BY embedding <=> '[0.1, 0.2, ...]'::vector
LIMIT 5;

-- 结合元数据过滤的查询
SELECT 
    id,
    content,
    source,
    title,
    1 - (embedding <=> '[0.1, 0.2, ...]'::vector) AS similarity
FROM knowledge_chunks
WHERE source = '技术手册' AND document_id = 'DOC-001'
ORDER BY embedding <=> '[0.1, 0.2, ...]'::vector
LIMIT 5;

系统集成与应用层实现

应用层集成模式

应用层只需使用标准的 PostgreSQL 客户端驱动(如 node-postgres、psycopg2、JDBC 等),即可完成所有数据库操作,包括向量的插入与检索。这大大降低了系统集成的复杂度。

完整的 RAG 交互流程(Node.js 示例)

以下是一个使用 Node.js + pg 驱动 + openai 嵌入模型的完整 RAG 查询示例:

const { Client } = require('pg');
const { OpenAI } = require('openai');

// 初始化 PostgreSQL 客户端
const pgClient = new Client({
    host: 'localhost',
    port: 5432,
    database: 'rag_db',
    user: 'app_user',
    password: 'secure_password'
});
await pgClient.connect();

// 初始化 OpenAI 客户端(用于生成嵌入向量)
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// 用户查询
const userQuery = '如何提升数据库写入性能?';

// 1. 将用户问题向量化
const embeddingResponse = await openai.embeddings.create({
    model: 'text-embedding-ada-002',
    input: userQuery,
});
const queryVector = embeddingResponse.data[0].embedding;

// 2. 在 PostgreSQL 中执行向量相似度检索
const topK = 5;
const sql = `
    SELECT 
        id,
        content,
        source,
        title,
        1 - (embedding <=> $1::vector) AS similarity
    FROM knowledge_chunks
    ORDER BY embedding <=> $1::vector
    LIMIT $2
`;
const result = await pgClient.query(sql, [JSON.stringify(queryVector), topK]);
const retrievedChunks = result.rows;

// 3. 构造 Prompt 并调用 LLM 生成答案
const context = retrievedChunks.map(row => row.content).join('\n\n');
const prompt = `
基于以下参考资料回答用户的问题。如果参考资料中没有相关信息,请明确告知用户。

参考资料:
${context}

用户问题:${userQuery}

请给出准确、简洁的回答。
`;

const completion = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [{ role: 'user', content: prompt }],
});
const answer = completion.choices[0].message.content;

console.log('最终答案:', answer);

// 关闭连接
await pgClient.end();

API 速览

本方案涉及的核心 API 包括:

pgvector 操作符与函数

API类型说明示例
<->操作符欧几里得距离(L2)embedding <-> '[1,2,3]'
<=>操作符余弦距离(1 - 余弦相似度)embedding <=> '[1,2,3]'
<#>操作符负内积(适用于内积相似度)embedding <#> '[1,2,3]'
vector_cosine_ops操作符类用于创建余弦距离索引USING ivfflat (embedding vector_cosine_ops)
vector_l2_ops操作符类用于创建欧几里得距离索引USING ivfflat (embedding vector_l2_ops)
vector_ip_ops操作符类用于创建内积索引USING ivfflat (embedding vector_ip_ops)

OpenAI Embeddings API

  • 方法:openai.embeddings.create()
  • 参数:model (字符串),input (字符串或字符串数组)
  • 返回值:包含 data 数组,每个元素有 embedding 向量(浮点数数组)

OpenAI Chat Completions API

  • 方法:openai.chat.completions.create()
  • 参数:model (字符串),messages (消息对象数组)
  • 返回值:包含 choices 数组,每个元素有 message.content(生成的文本)

完整 Demo 示例

本 Demo 基于 Node.js,演示了从知识库插入向量数据到执行 RAG 查询的完整流程。

运行说明

  1. 安装依赖:

    npm init -y
    npm install pg openai dotenv
    
  2. 准备 PostgreSQL 数据库(版本 14+),并安装 pgvector 扩展:

    psql -U postgres -c "CREATE DATABASE rag_db;"
    psql -U postgres -d rag_db -c "CREATE EXTENSION IF NOT EXISTS vector;"
    
  3. 执行表结构创建脚本(见上文 CREATE TABLE 语句)。

  4. 设置环境变量(.env 文件):

    OPENAI_API_KEY=your_openai_api_key
    PG_HOST=localhost
    PG_PORT=5432
    PG_DATABASE=rag_db
    PG_USER=app_user
    PG_PASSWORD=your_password
    
  5. 运行以下 Demo 脚本(demo.js):

代码说明

// demo.js - 完整 RAG 示例:插入 + 检索 + 生成
require('dotenv').config();
const { Client } = require('pg');
const { OpenAI } = require('openai');

async function runRAG() {
    // 1. 初始化客户端
    const pgClient = new Client({
        host: process.env.PG_HOST,
        port: process.env.PG_PORT,
        database: process.env.PG_DATABASE,
        user: process.env.PG_USER,
        password: process.env.PG_PASSWORD,
    });
    await pgClient.connect();
    const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

    // 2. 准备示例知识片段并插入(向量化后存储)
    const knowledgeDocs = [
        { content: '使用批量插入(COPY)可以显著提升 PostgreSQL 的写入性能。', source: '性能优化手册', title: '批量插入技巧' },
        { content: '减少索引数量并合理使用覆盖索引有助于加快 INSERT 操作。', source: '性能优化手册', title: '索引策略' },
        { content: '降低外键约束的检查频率(例如延迟约束)可以提高批量写入速度。', source: 'DBA 经验集', title: '约束管理' },
    ];

    for (const doc of knowledgeDocs) {
        const emb = await openai.embeddings.create({
            model: 'text-embedding-ada-002',
            input: doc.content,
        });
        const vector = emb.data[0].embedding;
        await pgClient.query(
            `INSERT INTO knowledge_chunks (content, embedding, source, title) 
             VALUES ($1, $2::vector, $3, $4)`,
            [doc.content, JSON.stringify(vector), doc.source, doc.title]
        );
    }
    console.log('知识片段插入完成。');

    // 3. 用户查询
    const userQuery = '如何加快数据库的写入速度?';

    // 4. 向量化查询
    const qEmb = await openai.embeddings.create({
        model: 'text-embedding-ada-002',
        input: userQuery,
    });
    const queryVec = qEmb.data[0].embedding;

    // 5. 检索 TOP-2 相关片段
    const topK = 2;
    const sql = `
        SELECT content, source, title
        FROM knowledge_chunks
        ORDER BY embedding <=> $1::vector
        LIMIT $2
    `;
    const res = await pgClient.query(sql, [JSON.stringify(queryVec), topK]);
    const chunks = res.rows;

    // 6. 生成答案
    const context = chunks.map(r => r.content).join('\n');
    const prompt = `基于以下资料回答问题:\n${context}\n问题:${userQuery}`;
    const completion = await openai.chat.completions.create({
        model: 'gpt-3.5-turbo',
        messages: [{ role: 'user', content: prompt }],
    });
    const answer = completion.choices[0].message.content;

    console.log('检索到的知识片段:', chunks);
    console.log('生成的答案:', answer);

    await pgClient.end();
}

runRAG().catch(console.error);

技术点总结

  • 演示了 pgvector 扩展的启用与向量列的创建。
  • 展示了 IVFFlat / HNSW 索引的创建语法。
  • 实现了基于余弦距离的 TOP-K 向量相似度检索。
  • 集成了外部嵌入模型(OpenAI)与 LLM 生成,完成完整的 RAG 链路。
  • 演示了应用层通过标准 PostgreSQL 驱动进行所有向量操作,无需额外组件。

多语言示例

Go 语言示例

运行说明
  1. 安装 Go 1.18+ 和 PostgreSQL 14+(已安装 pgvector 扩展)。

  2. 创建数据库并启用扩展(参考前文)。

  3. 初始化 Go 模块并安装依赖:

    go mod init rag-demo
    go get github.com/lib/pq
    go get github.com/sashabaranov/go-openai
    
  4. 设置环境变量(或直接修改代码):

    export OPENAI_API_KEY=your_openai_api_key
    export PG_HOST=localhost
    export PG_PORT=5432
    export PG_DATABASE=rag_db
    export PG_USER=app_user
    export PG_PASSWORD=your_password
    
  5. 运行示例:

    go run main.go
    
代码说明

以下 Go 程序完成完整的 RAG 流程:插入知识片段(向量化存储)、执行向量检索、调用 LLM 生成答案。使用标准库 database/sql 配合 lib/pq 驱动连接 PostgreSQL,使用 go-openai 客户端调用 OpenAI API。

// main.go
package main

import (
    "database/sql"
    "encoding/json"
    "fmt"
    "log"
    "os"

    "github.com/lib/pq"
    "github.com/sashabaranov/go-openai"
)

func main() {
    // 1. 初始化 PostgreSQL 连接
    connStr := fmt.Sprintf(
        "host=%s port=%s user=%s password=%s dbname=%s sslmode=disable",
        os.Getenv("PG_HOST"), os.Getenv("PG_PORT"),
        os.Getenv("PG_USER"), os.Getenv("PG_PASSWORD"),
        os.Getenv("PG_DATABASE"),
    )
    db, err := sql.Open("postgres", connStr)
    if err != nil {
        log.Fatal("连接数据库失败:", err)
    }
    defer db.Close()
    if err := db.Ping(); err != nil {
        log.Fatal("Ping 失败:", err)
    }

    // 2. 初始化 OpenAI 客户端
    openaiClient := openai.NewClient(os.Getenv("OPENAI_API_KEY"))

    // 3. 准备并插入知识片段(向量化)
    docs := []struct {
        content string
        source  string
        title   string
    }{
        {"使用批量插入(COPY)可以显著提升 PostgreSQL 的写入性能。", "性能优化手册", "批量插入技巧"},
        {"减少索引数量并合理使用覆盖索引有助于加快 INSERT 操作。", "性能优化手册", "索引策略"},
        {"降低外键约束的检查频率(例如延迟约束)可以提高批量写入速度。", "DBA 经验集", "约束管理"},
    }

    for _, doc := range docs {
        // 生成嵌入向量
        resp, err := openaiClient.CreateEmbeddings(
            openai.EmbeddingRequest{
                Model: openai.AdaEmbeddingV2,
                Input: []string{doc.content},
            },
        )
        if err != nil {
            log.Fatal("嵌入生成失败:", err)
        }
        vector := resp.Data[0].Embedding
        // 将 []float32 转换为 pgvector 可接受的字符串格式
        vecStr, _ := json.Marshal(vector) // pgvector 接受 JSON 数组字符串
        _, err = db.Exec(
            `INSERT INTO knowledge_chunks (content, embedding, source, title) 
             VALUES ($1, $2::vector, $3, $4)`,
            doc.content, string(vecStr), doc.source, doc.title,
        )
        if err != nil {
            log.Fatal("插入失败:", err)
        }
    }
    fmt.Println("知识片段插入完成。")

    // 4. 用户查询
    userQuery := "如何加快数据库的写入速度?"

    // 5. 生成查询向量
    qResp, err := openaiClient.CreateEmbeddings(
        openai.EmbeddingRequest{
            Model: openai.AdaEmbeddingV2,
            Input: []string{userQuery},
        },
    )
    if err != nil {
        log.Fatal("查询嵌入生成失败:", err)
    }
    queryVec := qResp.Data[0].Embedding
    queryVecStr, _ := json.Marshal(queryVec)

    // 6. 执行 TOP-2 相似度检索
    rows, err := db.Query(
        `SELECT content, source, title 
         FROM knowledge_chunks 
         ORDER BY embedding <=> $1::vector 
         LIMIT $2`,
        string(queryVecStr), 2,
    )
    if err != nil {
        log.Fatal("检索失败:", err)
    }
    defer rows.Close()

    var chunks []string
    for rows.Next() {
        var content, source, title string
        if err := rows.Scan(&content, &source, &title); err != nil {
            log.Fatal("扫描行失败:", err)
        }
        chunks = append(chunks, content)
        fmt.Printf("检索到: [%s] %s - %s\n", source, title, content)
    }

    // 7. 构造 Prompt 并调用 LLM 生成答案
    context := ""
    for _, c := range chunks {
        context += c + "\n"
    }
    prompt := fmt.Sprintf("基于以下资料回答问题:\n%s\n问题:%s", context, userQuery)
    chatResp, err := openaiClient.CreateChatCompletion(
        openai.ChatCompletionRequest{
            Model: openai.GPT3Dot5Turbo,
            Messages: []openai.ChatCompletionMessage{
                {Role: openai.ChatMessageRoleUser, Content: prompt},
            },
        },
    )
    if err != nil {
        log.Fatal("LLM 调用失败:", err)
    }
    answer := chatResp.Choices[0].Message.Content
    fmt.Println("生成的答案:", answer)
}
技术点总结
  • 使用 lib/pq 作为 PostgreSQL 驱动,支持 pgvector 的向量类型(通过字符串转换)。
  • 使用 go-openai 库调用嵌入和聊天补全 API。
  • 通过 json.Marshal 将 []float32 转换为 pgvector 可接受的数组字符串格式。
  • 在 SQL 中使用 <=> 操作符计算余弦距离,通过 ORDER BY ... LIMIT 实现 TOP-K 检索。
  • 完整演示了数据插入、向量检索与 LLM 生成的闭环。

Python 语言示例

运行说明
  1. 安装 Python 3.9+ 和 PostgreSQL 14+(已安装 pgvector 扩展)。

  2. 安装依赖:

    pip install psycopg2-binary openai python-dotenv
    
  3. 设置环境变量(.env 文件或系统环境):

    OPENAI_API_KEY=your_openai_api_key
    PG_HOST=localhost
    PG_PORT=5432
    PG_DATABASE=rag_db
    PG_USER=app_user
    PG_PASSWORD=your_password
    
  4. 运行示例:

    python demo.py
    
代码说明

Python 示例使用 psycopg2(支持 pgvector 的向量适配器)和 OpenAI 官方 SDK。代码清晰简洁,适合快速原型开发。

# demo.py
import os
import json
import psycopg2
from psycopg2.extras import Json
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

def main():
    # 1. 初始化 PostgreSQL 连接
    conn = psycopg2.connect(
        host=os.getenv("PG_HOST"),
        port=os.getenv("PG_PORT"),
        dbname=os.getenv("PG_DATABASE"),
        user=os.getenv("PG_USER"),
        password=os.getenv("PG_PASSWORD")
    )
    conn.autocommit = True
    cur = conn.cursor()

    # 2. 初始化 OpenAI 客户端
    openai_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

    # 3. 准备并插入知识片段
    docs = [
        ("使用批量插入(COPY)可以显著提升 PostgreSQL 的写入性能。", "性能优化手册", "批量插入技巧"),
        ("减少索引数量并合理使用覆盖索引有助于加快 INSERT 操作。", "性能优化手册", "索引策略"),
        ("降低外键约束的检查频率(例如延迟约束)可以提高批量写入速度。", "DBA 经验集", "约束管理"),
    ]

    for content, source, title in docs:
        # 生成嵌入向量
        resp = openai_client.embeddings.create(
            model="text-embedding-ada-002",
            input=content
        )
        vector = resp.data[0].embedding
        # psycopg2 可自动适配列表为 vector 类型(需使用 Json 或直接传递列表)
        cur.execute(
            """INSERT INTO knowledge_chunks (content, embedding, source, title)
               VALUES (%s, %s::vector, %s, %s)""",
            (content, json.dumps(vector), source, title)
        )
    print("知识片段插入完成。")

    # 4. 用户查询
    user_query = "如何加快数据库的写入速度?"

    # 5. 生成查询向量
    q_resp = openai_client.embeddings.create(
        model="text-embedding-ada-002",
        input=user_query
    )
    query_vec = q_resp.data[0].embedding

    # 6. 执行 TOP-2 相似度检索
    cur.execute(
        """SELECT content, source, title
           FROM knowledge_chunks
           ORDER BY embedding <=> %s::vector
           LIMIT %s""",
        (json.dumps(query_vec), 2)
    )
    rows = cur.fetchall()
    chunks = [row[0] for row in rows]
    for content, source, title in rows:
        print(f"检索到: [{source}] {title} - {content}")

    # 7. 构造 Prompt 并调用 LLM
    context = "\n".join(chunks)
    prompt = f"基于以下资料回答问题:\n{context}\n问题:{user_query}"
    chat_resp = openai_client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}]
    )
    answer = chat_resp.choices[0].message.content
    print("生成的答案:", answer)

    cur.close()
    conn.close()

if __name__ == "__main__":
    main()
技术点总结
  • 使用 psycopg2 连接 PostgreSQL,支持将 Python 列表通过 json.dumps 转换为向量文本。
  • 使用 OpenAI 官方 Python SDK 调用嵌入和聊天补全接口。
  • 利用 %s 占位符和 ::vector 类型转换完成向量参数传递。
  • 演示了完整的 RAG 流程,代码简洁且易于扩展。

Java 语言示例

运行说明
  1. 安装 JDK 17+ 和 PostgreSQL 14+(已安装 pgvector 扩展)。

  2. 使用 Maven 或 Gradle 管理依赖,添加以下核心依赖:

    • org.postgresql:postgresql (42.6+)
    • com.openai:openai-java (或使用 OkHttp 自行封装,此处使用官方 beta 库)
    • com.google.code.gson:gson (用于 JSON 处理)
  3. Maven pom.xml 关键依赖片段:

    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.6.0</version>
    </dependency>
    <dependency>
        <groupId>com.openai</groupId>
        <artifactId>openai-java</artifactId>
        <version>0.12.0</version>
    </dependency>
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.10.1</version>
    </dependency>
    
  4. 设置环境变量(可通过 IDE 或命令行):

    export OPENAI_API_KEY=your_openai_api_key
    export PG_HOST=localhost
    export PG_PORT=5432
    export PG_DATABASE=rag_db
    export PG_USER=app_user
    export PG_PASSWORD=your_password
    
  5. 编译并运行:

    mvn compile exec:java -Dexec.mainClass="com.example.RagDemo"
    
代码说明

Java 示例使用官方 PostgreSQL JDBC 驱动,结合 OpenAI Java SDK(beta)实现嵌入生成和聊天补全。由于 pgvector 在 JDBC 中没有原生向量类型,采用字符串传递 JSON 数组的方式。

// RagDemo.java
package com.example;

import com.google.gson.Gson;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.*;
import java.sql.*;
import java.util.*;

public class RagDemo {
    public static void main(String[] args) throws Exception {
        // 1. 初始化 PostgreSQL 连接
        String url = String.format("jdbc:postgresql://%s:%s/%s",
                System.getenv("PG_HOST"), System.getenv("PG_PORT"), System.getenv("PG_DATABASE"));
        Properties props = new Properties();
        props.setProperty("user", System.getenv("PG_USER"));
        props.setProperty("password", System.getenv("PG_PASSWORD"));
        Connection conn = DriverManager.getConnection(url, props);

        // 2. 初始化 OpenAI 客户端
        OpenAIClient openai = OpenAIOkHttpClient.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .build();
        Gson gson = new Gson();

        // 3. 准备并插入知识片段
        String[][] docs = {
            {"使用批量插入(COPY)可以显著提升 PostgreSQL 的写入性能。", "性能优化手册", "批量插入技巧"},
            {"减少索引数量并合理使用覆盖索引有助于加快 INSERT 操作。", "性能优化手册", "索引策略"},
            {"降低外键约束的检查频率(例如延迟约束)可以提高批量写入速度。", "DBA 经验集", "约束管理"}
        };

        for (String[] doc : docs) {
            // 生成嵌入
            EmbeddingCreateParams params = EmbeddingCreateParams.builder()
                    .model(EmbeddingModel.TEXT_EMBEDDING_ADA_002)
                    .input(Collections.singletonList(doc[0]))
                    .build();
            EmbeddingCreateResponse resp = openai.embeddings().create(params);
            List<Double> vector = resp.data().get(0).embedding();
            String vecJson = gson.toJson(vector); // 转换为 [0.1, 0.2, ...] 字符串

            PreparedStatement stmt = conn.prepareStatement(
                "INSERT INTO knowledge_chunks (content, embedding, source, title) VALUES (?, ?::vector, ?, ?)"
            );
            stmt.setString(1, doc[0]);
            stmt.setString(2, vecJson);
            stmt.setString(3, doc[1]);
            stmt.setString(4, doc[2]);
            stmt.executeUpdate();
        }
        System.out.println("知识片段插入完成。");

        // 4. 用户查询
        String userQuery = "如何加快数据库的写入速度?";

        // 5. 生成查询向量
        EmbeddingCreateParams qParams = EmbeddingCreateParams.builder()
                .model(EmbeddingModel.TEXT_EMBEDDING_ADA_002)
                .input(Collections.singletonList(userQuery))
                .build();
        EmbeddingCreateResponse qResp = openai.embeddings().create(qParams);
        List<Double> qVec = qResp.data().get(0).embedding();
        String qVecJson = gson.toJson(qVec);

        // 6. 执行 TOP-2 检索
        PreparedStatement queryStmt = conn.prepareStatement(
            "SELECT content, source, title FROM knowledge_chunks ORDER BY embedding <=> ?::vector LIMIT ?"
        );
        queryStmt.setString(1, qVecJson);
        queryStmt.setInt(2, 2);
        ResultSet rs = queryStmt.executeQuery();

        List<String> chunks = new ArrayList<>();
        while (rs.next()) {
            String content = rs.getString("content");
            String source = rs.getString("source");
            String title = rs.getString("title");
            chunks.add(content);
            System.out.printf("检索到: [%s] %s - %s\n", source, title, content);
        }

        // 7. 构造 Prompt 并调用 LLM
        String context = String.join("\n", chunks);
        String prompt = "基于以下资料回答问题:\n" + context + "\n问题:" + userQuery;

        ChatCompletionCreateParams chatParams = ChatCompletionCreateParams.builder()
                .model(ChatCompletionModel.GPT_3_5_TURBO)
                .addMessage(ChatCompletionMessage.builder()
                    .role(ChatCompletionMessage.Role.USER)
                    .content(prompt)
                    .build())
                .build();
        ChatCompletionCreateResponse chatResp = openai.chat().completions().create(chatParams);
        String answer = chatResp.choices().get(0).message().content().orElse("");
        System.out.println("生成的答案:" + answer);

        conn.close();
    }
}
技术点总结
  • 使用 JDBC 驱动,通过字符串 JSON 数组传递向量数据,配合 ::vector 类型转换。
  • 使用 OpenAI Java SDK(beta)调用嵌入和聊天补全接口。
  • 使用 Gson 将 Java List<Double> 序列化为 JSON 数组字符串。
  • 完整实现了 RAG 链路,代码结构清晰,适合企业级 Java 应用集成。

多语言实现对比

维度GoPythonJava
PostgreSQL 驱动github.com/lib/pqpsycopg2-binaryorg.postgresql:postgresql
向量传递方式json.Marshal → 字符串,使用 ::vectorjson.dumps → 字符串,使用 ::vectorGson.toJson → 字符串,使用 ::vector
OpenAI SDKgo-openaiopenai 官方库com.openai:openai-java (beta)
依赖管理Go Modulespip / requirements.txtMaven / Gradle
编译/运行go runpythonmvn exec:java
代码行数(核心逻辑)~100 行~75 行~120 行
错误处理显式 if err != nil异常捕获(可改进)抛出 Exception
类型安全强类型,结构体清晰动态类型,灵活强类型,冗长但严谨
环境变量读取os.Getenvos.getenvSystem.getenv
适用场景高性能微服务、云原生快速原型、数据科学企业级后端、大型系统

以上三种语言示例均基于相同的 RAG 逻辑,仅在语法、驱动和 SDK 使用方式上有所差异。开发者可根据自身技术栈选择合适的实现参考。

官方文档

参考链接

总结

本文围绕使用 PostgreSQL 与 pgvector 构建企业级 RAG 智能问答系统,详细阐述了系统架构、核心链路、技术选型优势以及数据库层的具体设计。pgvector 扩展使 PostgreSQL 成为一个融合型数据平台,能够同时处理结构化数据与向量数据,消除数据库孤岛,降低系统复杂度和维护成本。通过创建合理的表结构和向量索引(IVFFlat 或 HNSW),可以高效地执行基于语义的相似度检索。

结合应用层的嵌入模型与大语言模型,即可快速搭建一个完整的 RAG 系统,为企业知识库赋能智能问答能力。此外,PostgreSQL 原生的事务一致性、行级安全(RLS)及丰富的扩展生态,使得该系统天然具备企业级的数据安全与合规特性。本文提供的完整 Node.js 示例演示了从向量化存储到检索生成的全流程,可作为实际项目落地的参考起点。

80、编程学习资源与x86知识全解析 本文详细介绍了编程学习中多个领域的优秀书籍和博客资源,涵盖逆向工程、C/C++、x86/x86-64架构、ARM、汇编语言、Java、UNIX、密码学等多个方向。同时,深入解析了x86架构的核心知识,包括术语、通用寄存器、FPU寄存器、SIMD寄存器、调试寄存器以及常用指令的使用方法和操作步骤。通过本文,读者可以系统地掌握底层编程知识,并应用于逆向工程、系统开发和性能优化等领域。 阅读详情

相关推荐

全球、中国各省市县等行政区划(含十段线)shape及geosjon数据免费下载

免费下载全球、中国各省市县等行政区划(含十段线)shape及geosjon数据

mhf403445651的博客 3461

PostgreSQL笔记54: 基于PGVector的语义检索与RAG智能问答系统构建

使用pgvector的VECTOR类型存储高维向量通过余弦距离操作符<=>计算语义相似度通过动态调整召回率使用LIMIT实现 Top-K 语义检索完整演示了从数据入库到查询的全流程使用lib/pq驱动连接 PostgreSQL,支持VECTOR类型参数传递通过$1::VECTOR显式类型转换传递向量参数动态设置会话级参数使用标准接口,便于迁移或测试psycopg2原生支持VECTOR类型传递,使用%s占位符显式类型转换%s::VECTOR确保参数类型正确通过。

Wang的专栏 696

基于FPGA的示波器设计

ADC 、DAC、FPGA、LCD液晶、示波器

FDL_AQ的博客 1万+

LangChain智能客服实战:如何基于直属库构建高效问答系统

LangChain智能客服实战:如何基于直属库构建高效问答系统。

2600_94959788的博客 254

鸿蒙设备部署轻量级Web服务器NexServer实践

Web服务器作为互联网基础设施的核心组件,其轻量化部署在移动终端领域具有重要实践价值。本文以鸿蒙操作系统为技术载体,深入解析微内核架构如何通过资源隔离和分布式软总线实现服务高可用。重点探讨NexServer这一专为嵌入式场景设计的轻量级服务器,其ARM原生支持特性与15MB级内存占用,在HTTP/2协议处理与WebSocket通信中展现出独特优势。在智能家居控制面板、边缘计算节点等物联网典型场景中,鸿蒙设备结合NexServer的方案相比传统Nginx部署可降低60%资源消耗。通过实测数据对比,该组合在50

weixin_30411239的博客 484

基因家族扩张收缩分析可视化(CAFE5)

CafePlotter 是一个用于可视化 CAFE5 基因家族扩张收缩分析结果的 Python 工具

xuzhougeng blog 3646

AI-Native数据库构建指南:从向量检索到RAG应用实战

向量数据库和语义搜索是处理非结构化数据、实现智能检索的核心技术。其原理是通过Embedding模型将文本、图像等数据转化为高维向量,并利用相似度计算(如余弦相似度)在海量向量中快速找到相关内容。这项技术的价值在于让计算机能够理解数据语义,而不仅仅是匹配关键词,从而大幅提升搜索质量与自动化水平。在工程实践中,它广泛应用于RAG(检索增强生成)系统、智能推荐、内容去重等场景,成为构建AI应用的关键基础设施。本文以PostgreSQL的pgvector扩展为例,演示如何为传统数据库注入AI-Native能力,快速

weixin_33924312的博客 299

LDPC码译码原理——概率公式推导

怎么说呢,一直以来都想写一下博客。近半年多来我一直在学习LDPC码译码上的东西,主要是在FPGA实现上的,所以这次想写一些关于这方面的内容,包括译码的原理、仿真以及实现。(当然是基于准循环LDPC码上实现的)不过呢,我写这个的初衷是为了让初学者理解入门用的,而不是在大牛面前班门弄斧,有错误之处欢迎大家批评指正。不知道会不会有人一开始像我一样,为了学好LDPC码,先去好好了解其它的诸如RS码或者是卷...

stand_by_me123的博客 2万+

Qwen3-Reranker-0.6B与PostgreSQL集成:结构化数据检索

本文介绍了如何在星图GPU平台上自动化部署Qwen3-Reranker-0.6B镜像,实现结构化数据的语义增强检索。该镜像与PostgreSQL深度集成,可对合同、技术文档等企业文本进行精准重排序,显著提升法务条款检索、故障报告查找等典型场景的准确率与效率。

weixin_42576467的博客 341

NXP S32K-144开发环境搭建与Keil MDK 5调试实战

嵌入式开发中,Cortex-M系列微控制器凭借其高性能和低功耗特性广泛应用于汽车电子和工业控制领域。以NXP S32K-144为例,该芯片采用Cortex-M4内核,支持SWD两线制调试协议,通过CoreSight调试系统可实现硬件断点、实时内存访问等高级功能。开发环境搭建涉及Keil MDK 5工具链配置、RTX5实时系统集成以及CMSIS-DSP算法库调用,其中SWD接口优化和ITM跟踪技术能显著提升调试效率。在汽车电子等对可靠性要求高的场景中,结合MPU内存保护单元和窗口看门狗等安全机制,可构建符合功

weixin_33722405的博客 325

AI工具赋能日常工作的实践指南:以产品经理与程序员为例

AI工具赋能日常工作的实践指南:以产品经理与程序员为例

专注于编程、AI、人工智能等多个领域内容研究和分析 593

Mac下MySQL的配置和修改密码以及忘记密码后的重置密码

1 ) Mac下MySQL的配置和修改密码 2 ) 忘记并重置密码 启动MySQL服务,通过 $ps aux | grep mysql 判断是否启动该服务,若未启动,则到 系统偏好设置/MySQL面板 启动服务 软件默认会安装到:/usr/local/mysql 目录,进入这个目录下的bin目录:$cd /usr/local/mysql/bin 执行 $./mysql -u root -p 通过初始密码登录MySQL 通...

Wang的专栏 6259

【全局路径规划模块运动学算法】无人机Kinodynamic A*算法、Kinodynamic RRT*算法(附C++代码)

认知有限,望大家多多包涵,有什么问题也希望能够与大家多交流,共同成长!本文先对Kinodynamic A*算法做个简单的介绍,具体内容后续再更,其他模块可以参考去我其他文章提示:以下是本篇文章正文内容啃这个Kinodynamic A_star算法,建议先啃一啃高飞fast_planner那篇论文,把理论打好,如果还是比较迷,就先看Dijksta、再看A_star、再看hybrid A_star 三个的流程,因为往上资料比较多,再看这个Kinodynamic A_star算法,流程已经很相像了。如果。

qq_35635374的博客 2604

mysql数据库的一些简单的sql语句 内连接 - 表的关联查询

# 创建一个user表 create table users( id int primary key auto_increment, name varchar(20), dpt_id int ); # 向user表中插入数据 insert into users values (null,'刘备',1), (null,'关羽',2), (null,'赵

Wang的专栏 4264

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

数据库、数据库类型、RDBMS以及MySQL

什么是数据库 数据库 就是按一定的结构来组织、存储和管理数据的仓库 可以很方便的进行crud, 能提供多个用户共享、具有尽可能小的冗余度、与应用程序批次独立的数据集合。 其他持久储存缺点:文件操作(不灵活) 数据库类型 包括 : 关系型 和 非关系型 【关系型】 MySQL MariaDB PostgreSQL Microsoft SQL Server Oracle数据库 Sybase 【...

Wang的专栏 4039

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

Eggjs笔记:Eggjs集成ElasticSearch及CRUD操作

相关文档 https://www.elastic.co/guide/index.html https://www.elastic.co/guide/en/elasticsearch/client https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/configuration.html https://www.elastic.co/guide/en/elasticsearch/client/javascrip

Wang的专栏 3530

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

Redis: 集群高可用之故障转移和集群迁移

若要检查源和目标是否数据统一,还可选择阿里配套工具RedisFullCheck。3.4 使用 RedisFullCheck 工具检查。下载官方编译好的工具包,直接解压后就能使用。故障转移,包括自动故障转移和手动故障转移。运行之后,就给一个反馈结果,如果是。1.2 原集群与目标集群结构不一致。1.1 原集群与目标集群结构一致。2 ) 手动故障转移。

Wang的专栏 2918

Python笔记:基于Django框架的数据库设计

概述 需要根据《项目建议书》、《需求说明书》、界面原型、各种标准规范对数据库进行设计, 我们目前先参考这一设计图 结构设计 1 ) 找实体 实体是实体-关系模型的基本对象, 是现实世界中各种事物的抽象。 凡是可以相互区 开并可以被识 的事、物、概念等对象均可认为是实体。 基本的实体列表如下: 会员 类别 商品 订单 订单详情 收货地址 商品评论 商品图片 友情链接 站内公告 … ...

Wang的专栏 2772

Elastic Stack梳理:集群搭建指南之高可用架构与实战部署

本文介绍了Elasticsearch分布式架构和Cerebro监控工具的部署策略。主要内容包括: ES集群角色划分(主节点、数据节点、协调节点)及功能说明 Cerebro监控工具的独立部署方法和访问方式 集群拓扑规划示例,包含节点IP分配和架构拓扑图 各类型节点的配置原则和数量计算公式 高可用主节点配置要点及示例配置 生产环境优化建议,包括分片规划、硬件配置和安全措施 文章提供了完整的集群部署方案,涵盖从基础概念到具体实施的各个环节,适用于不同规模的ES集群建设。

Wang的专栏 2550

Redis: 集群环境搭建,集群状态检查,分析主从日志,查看集群信息

当从节点获得足够多的选票时,它就会成为新的主节点,并增加自己的configEpoch来更新槽位配置。在Redis集群中,纪元的更新通常是由节点间的通信和状态变更触发的。例如,当某个节点接收到来自其他节点的状态变更通知时,它会比较通知中的纪元与自己的纪元。如果通知中的纪元更大,则更新自己的纪元。确保集群状态的一致性:通过递增的纪元,集群中的节点可以确保它们对集群状态的认知是一致的。通过递增的纪元版本号,集群中的节点可以确保它们对集群状态的认知是一致的,并解决可能出现的配置冲突问题。4 )纪元的更新机制。

Wang的专栏 2466

MySQL: 数据库性能的决定性因素之从双十一大促高并发场景看系统瓶颈与优化路径

电商大促期间,数据库面临高并发写入、连接数暴增、慢查询积压等核心挑战。本文分析了锁竞争、主从延迟等关键性能瓶颈,并提出多种优化方案:1)使用乐观锁通过版本号控制库存超卖;2)CAS机制实现无锁并发;3)分布式锁协调多节点操作。这些方案在保证数据一致性的同时提升吞吐量,适用于库存扣减、订单创建等典型场景,有效解决数据库扩展难题。

Wang的专栏 2426

Redis: Sentinel哨兵监控架构及环境搭建

在主从模式下,我们通过从节点只读模式提高了系统的并发能力并发不断增加,只需要扩展从节点即可,只要主从服务器之间,网络连接正常主服务器就会将写入自己的数据同步更新给从服务器,从而保证主从服务器的数据相同在这种架构下,它仍然是有一些缺点的,比如说它的可靠性保证不是很好,因为主从模式下,主节点故障了便无法提供写入的服务现在,我们通过哨兵来解决这个问题然后,主节点其实写的压力也是并没有被释放的包括主从之间的数据是相同的,它还有数据冗余一个问题后面集群也会解决这个问题。

Wang的专栏 2181

MongoDB小课堂: 高级查询操作符与游标管理综合指南之深度整合逻辑操作符、字段处理、数组查询与游标控制的最佳实践

MongoDB查询操作符与游标管理摘要 本文整合了MongoDB常用查询操作符和游标管理的关键知识点: 比较操作符: $in和$nin用于多值匹配,注意$nin会包含字段缺失文档 结合$exists可处理字段缺失问题 逻辑操作符: $and可简写为逗号分隔条件 $or可用$in优化等值查询性能 $not和$nor需谨慎处理字段缺失 字段操作符: $exists检查字段存在性 $type支持按BSON类型筛选 数组操作符: $all要求包含所有指定元素 $elemMatch匹配满足条件的数组元素 正则表达式:

Wang的专栏 2145

Redis: 集群测试和集群原理

Redis Cluster 没有单机那种 16个数据库 (0 - 15) 数据库的概念了,就是我们已经看不到数据库了。而是分成了 16384 个 slots (槽位) ,每个节点负责其中一部分槽位,槽位的信息存储于每个节点中。2 ) 16384 个 slots (槽位)那我们客户端这边是怎么来操作集群的呢?1 ) SET/GET 命令。2 ) 开启从节点只读模式。

Wang的专栏 2102

MySQL: 数据库监控核心要素与实施策略

数据库监控是确保系统稳定的关键,涵盖服务可用性、性能、主从复制和资源使用等方面。核心监控包括:通过真实连接和查询验证数据库可用性;跟踪QPS、TPS和并发线程数等性能指标;监控主从复制的链路状态和延迟;以及关注磁盘空间等服务器资源。实现方案包括网络连接验证、读写测试和连接数阈值监控。性能监控需持续记录数据趋势,并采用精准方法检测阻塞事务和复制延迟。全面的数据库监控能有效预防故障,保障系统稳定运行。

Wang的专栏 2096

Eggjs笔记:详解Mongoose的聚合管道以及populate实现关联查询

基于mongodb的聚合管道 此处忽略之前mongodb在eggjs中需要配置的步骤,前文已有说明,现在开始在controller中调用(应该封装到service中的,仅作为示例) const result = await this.app.mongo.aggregate('order', { pipeline: [ { $lookup: {...

Wang的专栏 2096
上一篇: PostgreSQL笔记50: 基于PGVECTOR的实时推荐与搜索系统构建
下一篇: PostgreSQL笔记52: 智能问答系统核心表结构设计与向量检索实践
Wang's Blog
博客等级 码龄12年 7438粉丝 2422原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值