PostgreSQL笔记52: 智能问答系统核心表结构设计与向量检索实践

PostgreSQL 上的向量搜索实践 向量搜索的核心,是将文本、图像或音频等信息转化为向量化的数字表示,并在高维空间中通过计算“距离”来衡量相似度。例如,当一句文本被模型转化为向量后,它可以被表示为一个点,落在三维或更高维的坐标空间中。类似语义的词语(如 student 和 school)会自然地分布在相互接近的位置,当输入一个新词(如 elementary),就可以通过计算向量间的距离,快速找到与之语义相似的词语。数据向量化:无论是文本还是查询请求,都会经过 Embedding Model 转化 Vector Embedding。 阅读详情

纲要

  • 智能问答系统数据模型概述
    • 知识库表 (knowledge_base)
    • 用户问题表 (qa_questions)
    • 问答历史表 (qa_answers)
  • 向量数据存储与检索
    • pgvector 扩展与嵌入向量
    • 向量维度选择与索引
  • JSONB 灵活元数据管理
  • 表关系与数据闭环
  • 适用版本与环境准备
  • API 速览
    • pgvector 向量操作函数
    • 相似度检索查询
  • Demo 简单示例
    • Node.js + pg 完整可运行示例
  • 项目难点与解决方案
  • 官方文档与参考链接
  • 总结

智能问答系统(RAG 系统)的核心在于将知识库向量化存储,并在用户提问时通过向量相似度检索最相关的知识片段,再交由大语言模型生成最终回答。PostgreSQL 凭借其强大的扩展能力(尤其是 pgvector)和 JSONB 的灵活性,成为此类系统的理想数据底座。

本文基于实际设计经验,深入剖析智能问答系统的三张核心表结构,详细解读字段含义、向量存储策略、索引优化,并提供可运行的 Node.js 示例,帮助读者快速落地一套高效、可追溯的问答数据层。

表结构设计

整个系统围绕“知识存储 – 问题记录 – 回答溯源”三个维度设计,对应的三张表如下:

  • knowledge_base:存储经过切分的知识片段及其向量表示。
  • qa_questions:记录每次用户提问的问题原文及其向量。
  • qa_answers:保存系统生成的回答,并关联所引用的知识片段(用于溯源和反馈)。

这三张表共同形成数据闭环,支持后续的检索优化、效果分析和模型微调。

知识库表(knowledge_base)

该表是整个系统的核心,每一行代表一个最小知识片段(通常是一段话或一个段落)。设计此表时需平衡检索精度与上下文理解能力:片段越细,检索越精准,但过细可能丢失上下文;反之则可能引入噪声。

CREATE EXTENSION IF NOT EXISTS vector;

CREATE TABLE knowledge_base (
    id BIGSERIAL PRIMARY KEY,
    content TEXT NOT NULL,                     -- 知识片段原文
    embedding vector(768) NOT NULL,            -- 向量表示(768维)
    metadata JSONB NOT NULL DEFAULT '{}',      -- 灵活元数据(来源、章节、作者等)
    created_at TIMESTAMPTZ DEFAULT now(),
    updated_at TIMESTAMPTZ DEFAULT now()
);

-- 为后续加速检索创建向量索引(建议使用 IVFFlat 或 HNSW)
CREATE INDEX idx_knowledge_base_embedding ON knowledge_base 
    USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);

字段说明:

  • content:知识片段的纯文本,供模型生成回答时引用。
  • embedding:通过 embedding 模型(如 text-embedding-3-small)生成的浮点数向量,维度通常为 768 或 1536,PostgreSQL 的 vector 类型支持最多 2000 维。
  • metadata:JSONB 类型,可存储来源文件名、章节标题、页码、文档分类等任意键值对,方便返回答案时附带引用来源。
  • created_at / updated_at:记录时间戳,可用于分析知识的新鲜度。

向量索引:当数据量超过万级时,必须创建索引以加速相似度检索。pgvector 支持两种索引算法:

  • IVFFlat:适合百万级数据,构建速度快,需先有数据再进行聚类。
  • HNSW:适合更高精度和并发场景,构建较慢但查询更快。

适用版本:PostgreSQL 14+ 配合 pgvector 0.5.0+。若使用 IVFFlat,建议在表中插入一定量数据后再创建索引,以获得更好的聚类效果。

用户问题表(qa_questions)

每次用户提问时,系统将问题文本转换为向量,并存储于此,便于后续分析用户行为模式。

CREATE TABLE qa_questions (
    id BIGSERIAL PRIMARY KEY,
    question TEXT NOT NULL,
    embedding vector(768) NOT NULL,
    asked_at TIMESTAMPTZ DEFAULT now()
);

字段说明:

  • question:用户原始提问文本。
  • embedding:问题对应的向量,用于与知识库向量进行相似度计算。

问答历史表(qa_answers)

该表记录系统生成的回答、引用的知识片段及用户反馈,是进行质量评估和模型优化的关键数据来源。

CREATE TABLE qa_answers (
    id BIGSERIAL PRIMARY KEY,
    question_id BIGINT NOT NULL REFERENCES qa_questions(id),
    answer TEXT NOT NULL,
    related_docs JSONB NOT NULL,                -- 检索到的相关知识片段(如 id 和 content)
    top_k INT NOT NULL,                         -- 实际召回的数量(通常 3~5)
    response_time_ms INT,                       -- 响应耗时(毫秒)
    recall_rate FLOAT,                          -- 召回率(可用于评估)
    feedback_score INT CHECK (feedback_score BETWEEN 1 AND 5), -- 用户评分(1~5)
    created_at TIMESTAMPTZ DEFAULT now()
);

-- 可选的索引:按问题 ID 和时间查询
CREATE INDEX idx_qa_answers_question_id ON qa_answers(question_id);

字段说明:

  • question_id:关联到 qa_questions 表的主键,形成一对一或一对多的问答关系(一个问题可多次生成回答,便于 A/B 测试)。
  • answer:系统最终给出的回答文本。
  • related_docs:JSONB 数组,存储本次检索命中的知识片段(如 [{id: 1, content: "..."}, ...]),用于溯源和调试。
  • top_k:实际返回给模型的知识片段数量。
  • response_time_ms:记录耗时,用于性能监控。
  • recall_rate:可根据标注数据计算,用于评估检索效果。
  • feedback_score:用户满意度打分,为优化提供方向。

表关系与数据闭环

引用

对应

knowledge_base

bigint

id

PK

text

content

vector

embedding

jsonb

metadata

qa_answers

bigint

id

PK

bigint

question_id

FK

text

answer

jsonb

related_docs

int

top_k

int

response_time_ms

float

recall_rate

int

feedback_score

qa_questions

bigint

id

PK

text

question

vector

embedding

流程说明:

  1. 用户提问 → 插入 qa_questions 并生成向量。
  2. 使用该向量在 knowledge_base 中执行相似度检索(余弦距离),得到 Top-K 片段。
  3. 将这些片段与问题拼装成 prompt 提交给 LLM,生成回答。
  4. 将回答、引用的片段、耗时等信息写入 qa_answers。
  5. 用户反馈评分存入 feedback_score,形成闭环。

API 速览

本节聚焦于 pgvector 扩展提供的核心向量操作 API,以及基于这些 API 的典型检索查询。

向量类型与操作符

函数/操作符说明示例
vector向量数据类型'[0.1, 0.2, ...]'::vector
<=>余弦距离(余弦相似度的补数)embedding <=> '[0.3, ...]'
<#>负内积用于内积相似度
<+>L2 欧氏距离距离越小越相似
cosine_distance余弦距离函数(与 <=> 等价)cosine_distance(embedding, query_vec)

相似度检索查询

基础查询(无索引加速,适合小数据集):

SELECT id, content, metadata,
       1 - (embedding <=> '[0.1, 0.2, ...]'::vector) AS similarity
FROM knowledge_base
ORDER BY embedding <=> '[0.1, 0.2, ...]'::vector
LIMIT 5;

使用索引的查询(推荐):

SELECT id, content, metadata,
       1 - (embedding <=> query_vec) AS similarity
FROM knowledge_base
WHERE embedding <=> query_vec < 0.5   -- 可选阈值过滤
ORDER BY embedding <=> query_vec
LIMIT 5;

索引 ivfflat 或 hnsw 会自动加速 ORDER BY 和 < 比较。

获取向量距离:

SELECT embedding <=> '[0.1, ...]' AS distance
FROM knowledge_base
WHERE id = 1;

Demo 简单示例

以下是一个基于 Node.js 和 pg 驱动实现的完整 RAG 数据层 Demo,演示了建表、插入知识、向量检索及问答记录的完整流程。

运行说明

1. 环境准备

# 安装 PostgreSQL 14+ 并启用 pgvector 扩展
# 使用 Docker 快速启动
docker run -e POSTGRES_PASSWORD=password -p 5432:5432 -d ankane/pgvector

2. 项目初始化

mkdir rag-postgres-demo && cd rag-postgres-demo
npm init -y
npm install pg dotenv

3. 环境变量

创建 .env 文件:

DATABASE_URL=postgresql://postgres:password@localhost:5432/rag_demo

4. 运行 Demo

node index.js

代码说明

// index.ts
import { Pool } from 'pg';
import dotenv from 'dotenv';

dotenv.config();

const pool = new Pool({
    connectionString: process.env.DATABASE_URL,
});

// 模拟 Embedding 模型输出(实际应调用 OpenAI / 本地模型)
function generateMockEmbedding(dim: number = 768): number[] {
    return Array.from({ length: dim }, () => Math.random() * 2 - 1);
}

async function setupDatabase() {
    const client = await pool.connect();
    try {
        // 1. 启用 pgvector 扩展
        await client.query(`CREATE EXTENSION IF NOT EXISTS vector;`);

        // 2. 创建三张核心表
        await client.query(`
            CREATE TABLE IF NOT EXISTS knowledge_base (
                id BIGSERIAL PRIMARY KEY,
                content TEXT NOT NULL,
                embedding VECTOR(768) NOT NULL,
                metadata JSONB NOT NULL DEFAULT '{}'::JSONB,
                created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
                updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
            );
        `);

        await client.query(`
            CREATE TABLE IF NOT EXISTS qa_questions (
                id BIGSERIAL PRIMARY KEY,
                question TEXT NOT NULL,
                embedding VECTOR(768) NOT NULL,
                context JSONB DEFAULT '{}'::JSONB,
                created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
            );
        `);

        await client.query(`
            CREATE TABLE IF NOT EXISTS qa_answers (
                id BIGSERIAL PRIMARY KEY,
                question_id BIGINT NOT NULL REFERENCES qa_questions(id) ON DELETE CASCADE,
                answer TEXT NOT NULL,
                referenced_docs JSONB NOT NULL DEFAULT '[]'::JSONB,
                topk INT DEFAULT 5,
                response_time_ms INT,
                recall_rate FLOAT,
                feedback_score INT CHECK (feedback_score >= 1 AND feedback_score <= 5),
                created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
            );
        `);

        // 3. 创建索引
        await client.query(`
            CREATE INDEX IF NOT EXISTS idx_kb_metadata ON knowledge_base USING GIN (metadata);
            CREATE INDEX IF NOT EXISTS idx_kb_embedding_hnsw 
            ON knowledge_base USING HNSW (embedding vector_cosine_ops)
            WITH (m = 16, ef_construction = 64);
        `);

        console.log('✅ 数据库表与索引创建完成');
    } finally {
        client.release();
    }
}

// 插入知识片段
async function insertKnowledge(content: string, metadata: object) {
    const embedding = generateMockEmbedding(768);
    const result = await pool.query(
        `INSERT INTO knowledge_base (content, embedding, metadata)
         VALUES ($1, $2::VECTOR(768), $3::JSONB)
         RETURNING id`,
        [content, JSON.stringify(embedding), JSON.stringify(metadata)]
    );
    return result.rows[0].id;
}

// 向量检索
async function vectorSearch(queryEmbedding: number[], topK: number = 5) {
    const result = await pool.query(
        `SELECT id, content, metadata, 1 - (embedding <=> $1::VECTOR(768)) AS similarity
         FROM knowledge_base
         ORDER BY embedding <=> $1::VECTOR(768)
         LIMIT $2`,
        [JSON.stringify(queryEmbedding), topK]
    );
    return result.rows;
}

// 记录用户提问
async function recordQuestion(question: string) {
    const embedding = generateMockEmbedding(768);
    const result = await pool.query(
        `INSERT INTO qa_questions (question, embedding)
         VALUES ($1, $2::VECTOR(768))
         RETURNING id`,
        [question, JSON.stringify(embedding)]
    );
    return result.rows[0].id;
}

// 记录问答历史
async function recordAnswer(
    questionId: number,
    answer: string,
    referencedDocs: object[],
    topK: number,
    responseTimeMs: number,
    recallRate?: number
) {
    await pool.query(
        `INSERT INTO qa_answers (question_id, answer, referenced_docs, topk, response_time_ms, recall_rate)
         VALUES ($1, $2, $3::JSONB, $4, $5, $6)`,
        [questionId, answer, JSON.stringify(referencedDocs), topK, responseTimeMs, recallRate ?? null]
    );
}

async function main() {
    await setupDatabase();

    // 插入示例知识
    const knowledgeDocs = [
        { content: 'PostgreSQL 是一款先进的开源关系型数据库管理系统,支持 ACID 事务。', 
          metadata: { source: 'docs/intro.md', topic: 'database' } },
        { content: 'pgvector 是 PostgreSQL 的向量相似度搜索扩展,支持 L2、内积和余弦距离。',
          metadata: { source: 'docs/pgvector.md', topic: 'vector' } },
        { content: 'RAG(检索增强生成)结合了信息检索与 LLM 生成能力,可有效减少幻觉。',
          metadata: { source: 'docs/rag.md', topic: 'ai' } },
    ];

    for (const doc of knowledgeDocs) {
        await insertKnowledge(doc.content, doc.metadata);
    }
    console.log(`✅ 已插入 ${knowledgeDocs.length} 条知识片段`);

    // 模拟用户提问
    const userQuestion = '什么是 RAG?';
    const questionEmbedding = generateMockEmbedding(768);

    // 向量检索
    const searchResults = await vectorSearch(questionEmbedding, 3);
    console.log('🔍 检索结果:', searchResults.map(r => ({ id: r.id, similarity: r.similarity })));

    // 记录提问
    const questionId = await recordQuestion(userQuestion);

    // 模拟生成回答
    const mockAnswer = 'RAG(检索增强生成)是一种结合信息检索与 LLM 生成的技术框架...';
    const referencedDocs = searchResults.map(r => ({
        id: r.id,
        content: r.content,
        source: r.metadata?.source || 'unknown',
        similarity: r.similarity,
    }));

    await recordAnswer(questionId, mockAnswer, referencedDocs, 3, 450, 0.92);
    console.log('✅ 问答记录已保存');

    // 查询完整问答链路
    const fullChain = await pool.query(
        `SELECT 
            q.id AS question_id,
            q.question,
            a.answer,
            a.referenced_docs,
            a.response_time_ms,
            a.feedback_score
         FROM qa_questions q
         LEFT JOIN qa_answers a ON q.id = a.question_id
         WHERE q.id = $1`,
        [questionId]
    );
    console.log('📝 完整问答链路:', JSON.stringify(fullChain.rows, null, 2));

    await pool.end();
}

main().catch(console.error);

技术点总结

该 Demo 演示了以下核心技术:

  • pgvector 扩展的启用与向量列定义。
  • 三张核心表的创建与关联关系。
  • 使用 HNSW 索引加速向量相似度检索。
  • 模拟向量生成与向量检索(余弦距离)。
  • 完整的问答数据闭环:提问 → 检索 → 回答 → 存储溯源。

多语言示例

以下分别提供 Go、Python 和 Java 三种语言实现的完整 Demo,均基于同一套表结构设计(knowledge_base、qa_questions、qa_answers),实现知识插入、向量检索、问答记录等核心功能。每个示例均包含运行说明、代码说明及技术点总结,便于横向对比。

Go 实现

运行说明

1. 环境准备

  • Go 1.21+
  • PostgreSQL 14+ 且安装 pgvector 扩展
  • 推荐使用 Docker 启动 PostgreSQL:docker run -e POSTGRES_PASSWORD=password -p 5432:5432 -d ankane/pgvector

2. 项目初始化

mkdir rag-demo-go && cd rag-demo-go
go mod init rag-demo-go
go get github.com/jackc/pgx/v5

3. 环境变量

创建 .env 文件(或直接使用系统环境变量):

DATABASE_URL=postgresql://postgres:password@localhost:5432/rag_demo

4. 运行

go run main.go
代码说明
// main.go
package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "math/rand"
    "os"
    "time"

    "github.com/jackc/pgx/v5"
    "github.com/jackc/pgx/v5/pgxpool"
)

// 模拟 embedding 生成(768维)
func generateMockEmbedding(dim int) []float32 {
    vec := make([]float32, dim)
    for i := range vec {
        vec[i] = rand.Float32()*2 - 1
    }
    return vec
}

// 将 []float32 转为 pgvector 可接受的字符串格式
func vecToString(vec []float32) string {
    b, _ := json.Marshal(vec)
    return string(b)
}

func main() {
    ctx := context.Background()

    dbURL := os.Getenv("DATABASE_URL")
    if dbURL == "" {
        dbURL = "postgresql://postgres:password@localhost:5432/rag_demo"
    }

    config, err := pgxpool.ParseConfig(dbURL)
    if err != nil {
        log.Fatal("Parse config error:", err)
    }
    pool, err := pgxpool.NewWithConfig(ctx, config)
    if err != nil {
        log.Fatal("Connect error:", err)
    }
    defer pool.Close()

    // 1. 启用扩展并建表
    _, err = pool.Exec(ctx, `CREATE EXTENSION IF NOT EXISTS vector;`)
    if err != nil {
        log.Fatal("Create extension error:", err)
    }

    // 建表语句(与 Node.js 保持一致)
    createTables := `
    CREATE TABLE IF NOT EXISTS knowledge_base (
        id BIGSERIAL PRIMARY KEY,
        content TEXT NOT NULL,
        embedding VECTOR(768) NOT NULL,
        metadata JSONB NOT NULL DEFAULT '{}'::JSONB,
        created_at TIMESTAMPTZ DEFAULT NOW(),
        updated_at TIMESTAMPTZ DEFAULT NOW()
    );
    CREATE TABLE IF NOT EXISTS qa_questions (
        id BIGSERIAL PRIMARY KEY,
        question TEXT NOT NULL,
        embedding VECTOR(768) NOT NULL,
        context JSONB DEFAULT '{}'::JSONB,
        created_at TIMESTAMPTZ DEFAULT NOW()
    );
    CREATE TABLE IF NOT EXISTS qa_answers (
        id BIGSERIAL PRIMARY KEY,
        question_id BIGINT NOT NULL REFERENCES qa_questions(id) ON DELETE CASCADE,
        answer TEXT NOT NULL,
        referenced_docs JSONB NOT NULL DEFAULT '[]'::JSONB,
        topk INT DEFAULT 5,
        response_time_ms INT,
        recall_rate FLOAT,
        feedback_score INT CHECK (feedback_score >= 1 AND feedback_score <= 5),
        created_at TIMESTAMPTZ DEFAULT NOW()
    );
    CREATE INDEX IF NOT EXISTS idx_kb_metadata ON knowledge_base USING GIN (metadata);
    CREATE INDEX IF NOT EXISTS idx_kb_embedding_hnsw 
        ON knowledge_base USING HNSW (embedding vector_cosine_ops)
        WITH (m = 16, ef_construction = 64);
    `
    _, err = pool.Exec(ctx, createTables)
    if err != nil {
        log.Fatal("Create tables error:", err)
    }
    fmt.Println("✅ 数据库表与索引创建完成")

    // 2. 插入知识片段
    knowledgeDocs := []struct {
        content  string
        metadata map[string]interface{}
    }{
        {"PostgreSQL 是一款先进的开源关系型数据库管理系统,支持 ACID 事务。",
            map[string]interface{}{"source": "docs/intro.md", "topic": "database"}},
        {"pgvector 是 PostgreSQL 的向量相似度搜索扩展,支持 L2、内积和余弦距离。",
            map[string]interface{}{"source": "docs/pgvector.md", "topic": "vector"}},
        {"RAG(检索增强生成)结合了信息检索与 LLM 生成能力,可有效减少幻觉。",
            map[string]interface{}{"source": "docs/rag.md", "topic": "ai"}},
    }

    for _, doc := range knowledgeDocs {
        emb := generateMockEmbedding(768)
        embStr := vecToString(emb)
        metadataJSON, _ := json.Marshal(doc.metadata)
        _, err := pool.Exec(ctx,
            `INSERT INTO knowledge_base (content, embedding, metadata) VALUES ($1, $2::VECTOR(768), $3::JSONB)`,
            doc.content, embStr, metadataJSON)
        if err != nil {
            log.Fatal("Insert knowledge error:", err)
        }
    }
    fmt.Printf("✅ 已插入 %d 条知识片段\n", len(knowledgeDocs))

    // 3. 模拟用户提问:向量检索 + 记录问答
    userQuestion := "什么是 RAG?"
    queryEmb := generateMockEmbedding(768)
    queryEmbStr := vecToString(queryEmb)

    // 向量检索
    rows, err := pool.Query(ctx,
        `SELECT id, content, metadata, 1 - (embedding <=> $1::VECTOR(768)) AS similarity
         FROM knowledge_base
         ORDER BY embedding <=> $1::VECTOR(768)
         LIMIT 3`,
        queryEmbStr)
    if err != nil {
        log.Fatal("Search error:", err)
    }
    var searchResults []map[string]interface{}
    for rows.Next() {
        var id int64
        var content string
        var metadataJSON []byte
        var similarity float32
        if err := rows.Scan(&id, &content, &metadataJSON, &similarity); err != nil {
            log.Fatal("Scan error:", err)
        }
        var metadata map[string]interface{}
        json.Unmarshal(metadataJSON, &metadata)
        searchResults = append(searchResults, map[string]interface{}{
            "id":         id,
            "content":    content,
            "metadata":   metadata,
            "similarity": similarity,
        })
    }
    rows.Close()
    fmt.Println("🔍 检索结果:", searchResults)

    // 记录问题
    var questionID int64
    err = pool.QueryRow(ctx,
        `INSERT INTO qa_questions (question, embedding) VALUES ($1, $2::VECTOR(768)) RETURNING id`,
        userQuestion, queryEmbStr).Scan(&questionID)
    if err != nil {
        log.Fatal("Insert question error:", err)
    }

    // 模拟回答
    mockAnswer := "RAG(检索增强生成)是一种结合信息检索与 LLM 生成的技术框架..."
    referencedDocs := make([]map[string]interface{}, len(searchResults))
    for i, r := range searchResults {
        referencedDocs[i] = map[string]interface{}{
            "id":         r["id"],
            "content":    r["content"],
            "source":     r["metadata"].(map[string]interface{})["source"],
            "similarity": r["similarity"],
        }
    }
    refDocsJSON, _ := json.Marshal(referencedDocs)

    _, err = pool.Exec(ctx,
        `INSERT INTO qa_answers (question_id, answer, referenced_docs, topk, response_time_ms, recall_rate)
         VALUES ($1, $2, $3::JSONB, $4, $5, $6)`,
        questionID, mockAnswer, refDocsJSON, 3, 450, 0.92)
    if err != nil {
        log.Fatal("Insert answer error:", err)
    }
    fmt.Println("✅ 问答记录已保存")

    // 查询完整链路
    var fullChain struct {
        QuestionID    int64
        Question      string
        Answer        string
        ReferencedDocs json.RawMessage
        ResponseTimeMs int
        FeedbackScore  *int
    }
    err = pool.QueryRow(ctx,
        `SELECT q.id, q.question, a.answer, a.referenced_docs, a.response_time_ms, a.feedback_score
         FROM qa_questions q
         LEFT JOIN qa_answers a ON q.id = a.question_id
         WHERE q.id = $1`,
        questionID).Scan(
        &fullChain.QuestionID, &fullChain.Question, &fullChain.Answer,
        &fullChain.ReferencedDocs, &fullChain.ResponseTimeMs, &fullChain.FeedbackScore,
    )
    if err != nil {
        log.Fatal("Query chain error:", err)
    }
    fmt.Printf("📝 完整问答链路: ID=%d, Question=%s, Answer=%s, ResponseTime=%dms\n",
        fullChain.QuestionID, fullChain.Question, fullChain.Answer, fullChain.ResponseTimeMs)
}
技术点总结
  • 使用 pgxpool 连接池管理 PostgreSQL 连接。
  • 通过 VECTOR 类型和 JSONB 与 pgx 的集成,支持向量和 JSON 数据的直接绑定。
  • 采用 HNSW 索引加速余弦相似度检索。
  • 完整实现知识入库、向量检索、问答记录和链路查询。

Python 实现

运行说明

1. 环境准备

  • Python 3.9+
  • PostgreSQL 14+ 且安装 pgvector 扩展
  • 推荐使用 Docker 启动 PostgreSQL:docker run -e POSTGRES_PASSWORD=password -p 5432:5432 -d ankane/pgvector

2. 项目初始化

mkdir rag-demo-py && cd rag-demo-py
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate
pip install psycopg2-binary python-dotenv

3. 环境变量

创建 .env 文件:

DATABASE_URL=postgresql://postgres:password@localhost:5432/rag_demo

4. 运行

python main.py
代码说明
# main.py
import os
import json
import random
import psycopg2
from psycopg2.extras import Json
from dotenv import load_dotenv

load_dotenv()

DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://postgres:password@localhost:5432/rag_demo")

def generate_mock_embedding(dim=768):
    return [random.uniform(-1, 1) for _ in range(dim)]

def vec_to_string(vec):
    return json.dumps(vec)

def main():
    conn = psycopg2.connect(DATABASE_URL)
    conn.autocommit = True
    cur = conn.cursor()

    # 1. 启用扩展并建表
    cur.execute("CREATE EXTENSION IF NOT EXISTS vector;")
    cur.execute("""
    CREATE TABLE IF NOT EXISTS knowledge_base (
        id BIGSERIAL PRIMARY KEY,
        content TEXT NOT NULL,
        embedding VECTOR(768) NOT NULL,
        metadata JSONB NOT NULL DEFAULT '{}'::JSONB,
        created_at TIMESTAMPTZ DEFAULT NOW(),
        updated_at TIMESTAMPTZ DEFAULT NOW()
    );
    CREATE TABLE IF NOT EXISTS qa_questions (
        id BIGSERIAL PRIMARY KEY,
        question TEXT NOT NULL,
        embedding VECTOR(768) NOT NULL,
        context JSONB DEFAULT '{}'::JSONB,
        created_at TIMESTAMPTZ DEFAULT NOW()
    );
    CREATE TABLE IF NOT EXISTS qa_answers (
        id BIGSERIAL PRIMARY KEY,
        question_id BIGINT NOT NULL REFERENCES qa_questions(id) ON DELETE CASCADE,
        answer TEXT NOT NULL,
        referenced_docs JSONB NOT NULL DEFAULT '[]'::JSONB,
        topk INT DEFAULT 5,
        response_time_ms INT,
        recall_rate FLOAT,
        feedback_score INT CHECK (feedback_score >= 1 AND feedback_score <= 5),
        created_at TIMESTAMPTZ DEFAULT NOW()
    );
    CREATE INDEX IF NOT EXISTS idx_kb_metadata ON knowledge_base USING GIN (metadata);
    CREATE INDEX IF NOT EXISTS idx_kb_embedding_hnsw 
        ON knowledge_base USING HNSW (embedding vector_cosine_ops)
        WITH (m = 16, ef_construction = 64);
    """)
    print("✅ 数据库表与索引创建完成")

    # 2. 插入知识片段
    knowledge_docs = [
        ("PostgreSQL 是一款先进的开源关系型数据库管理系统,支持 ACID 事务。",
         {"source": "docs/intro.md", "topic": "database"}),
        ("pgvector 是 PostgreSQL 的向量相似度搜索扩展,支持 L2、内积和余弦距离。",
         {"source": "docs/pgvector.md", "topic": "vector"}),
        ("RAG(检索增强生成)结合了信息检索与 LLM 生成能力,可有效减少幻觉。",
         {"source": "docs/rag.md", "topic": "ai"}),
    ]
    for content, metadata in knowledge_docs:
        emb = generate_mock_embedding(768)
        emb_str = vec_to_string(emb)
        cur.execute(
            "INSERT INTO knowledge_base (content, embedding, metadata) VALUES (%s, %s::VECTOR(768), %s::JSONB)",
            (content, emb_str, Json(metadata))
        )
    print(f"✅ 已插入 {len(knowledge_docs)} 条知识片段")

    # 3. 模拟用户提问
    user_question = "什么是 RAG?"
    query_emb = generate_mock_embedding(768)
    query_emb_str = vec_to_string(query_emb)

    # 向量检索
    cur.execute(
        """SELECT id, content, metadata, 1 - (embedding <=> %s::VECTOR(768)) AS similarity
           FROM knowledge_base
           ORDER BY embedding <=> %s::VECTOR(768)
           LIMIT 3""",
        (query_emb_str, query_emb_str)
    )
    search_results = []
    for id, content, metadata, similarity in cur.fetchall():
        search_results.append({
            "id": id,
            "content": content,
            "metadata": metadata,
            "similarity": similarity
        })
    print("🔍 检索结果:", search_results)

    # 记录问题
    cur.execute(
        "INSERT INTO qa_questions (question, embedding) VALUES (%s, %s::VECTOR(768)) RETURNING id",
        (user_question, query_emb_str)
    )
    question_id = cur.fetchone()[0]

    # 模拟回答
    mock_answer = "RAG(检索增强生成)是一种结合信息检索与 LLM 生成的技术框架..."
    referenced_docs = []
    for r in search_results:
        referenced_docs.append({
            "id": r["id"],
            "content": r["content"],
            "source": r["metadata"].get("source", "unknown"),
            "similarity": r["similarity"]
        })
    cur.execute(
        """INSERT INTO qa_answers (question_id, answer, referenced_docs, topk, response_time_ms, recall_rate)
           VALUES (%s, %s, %s::JSONB, %s, %s, %s)""",
        (question_id, mock_answer, Json(referenced_docs), 3, 450, 0.92)
    )
    print("✅ 问答记录已保存")

    # 查询完整链路
    cur.execute(
        """SELECT q.id, q.question, a.answer, a.referenced_docs, a.response_time_ms, a.feedback_score
           FROM qa_questions q
           LEFT JOIN qa_answers a ON q.id = a.question_id
           WHERE q.id = %s""",
        (question_id,)
    )
    row = cur.fetchone()
    print(f"📝 完整问答链路: ID={row[0]}, Question={row[1]}, Answer={row[2]}, ResponseTime={row[4]}ms")

    cur.close()
    conn.close()

if __name__ == "__main__":
    main()
技术点总结
  • 使用 psycopg2 驱动,通过 Json 适配器处理 JSONB 数据。
  • 向量类型 VECTOR 通过字符串传递(json.dumps 序列化)。
  • 利用 psycopg2 的参数化查询防止 SQL 注入。
  • 完整实现知识入库、向量检索、问答记录和链路查询。

Java 实现

运行说明

1. 环境准备

  • JDK 17+
  • Maven 3.8+
  • PostgreSQL 14+ 且安装 pgvector 扩展
  • 推荐使用 Docker 启动 PostgreSQL:docker run -e POSTGRES_PASSWORD=password -p 5432:5432 -d ankane/pgvector

2. 项目初始化

mkdir rag-demo-java && cd rag-demo-java
mvn archetype:generate -DgroupId=com.example -DartifactId=rag-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
cd rag-demo

修改 pom.xml 添加依赖:

<dependencies>
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.7.2</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.16.1</version>
    </dependency>
    <dependency>
        <groupId>io.github.cdimascio</groupId>
        <artifactId>dotenv-java</artifactId>
        <version>3.0.0</version>
    </dependency>
</dependencies>

3. 环境变量

在项目根目录创建 .env 文件:

DATABASE_URL=postgresql://postgres:password@localhost:5432/rag_demo

4. 运行

mvn compile exec:java -Dexec.mainClass="com.example.App"
代码说明
// src/main/java/com/example/App.java
package com.example;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import io.github.cdimascio.dotenv.Dotenv;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Random;

public class App {
    private static final int DIM = 768;
    private static final Random random = new Random();
    private static final ObjectMapper mapper = new ObjectMapper();

    private static float[] generateMockEmbedding() {
        float[] vec = new float[DIM];
        for (int i = 0; i < DIM; i++) {
            vec[i] = random.nextFloat() * 2 - 1;
        }
        return vec;
    }

    private static String vecToString(float[] vec) throws Exception {
        return mapper.writeValueAsString(vec);
    }

    public static void main(String[] args) throws Exception {
        Dotenv dotenv = Dotenv.load();
        String dbUrl = dotenv.get("DATABASE_URL");
        if (dbUrl == null) dbUrl = "postgresql://postgres:password@localhost:5432/rag_demo";

        try (Connection conn = DriverManager.getConnection(dbUrl);
             Statement stmt = conn.createStatement()) {

            // 1. 启用扩展并建表
            stmt.execute("CREATE EXTENSION IF NOT EXISTS vector;");
            stmt.execute("""
                CREATE TABLE IF NOT EXISTS knowledge_base (
                    id BIGSERIAL PRIMARY KEY,
                    content TEXT NOT NULL,
                    embedding VECTOR(768) NOT NULL,
                    metadata JSONB NOT NULL DEFAULT '{}'::JSONB,
                    created_at TIMESTAMPTZ DEFAULT NOW(),
                    updated_at TIMESTAMPTZ DEFAULT NOW()
                );
                CREATE TABLE IF NOT EXISTS qa_questions (
                    id BIGSERIAL PRIMARY KEY,
                    question TEXT NOT NULL,
                    embedding VECTOR(768) NOT NULL,
                    context JSONB DEFAULT '{}'::JSONB,
                    created_at TIMESTAMPTZ DEFAULT NOW()
                );
                CREATE TABLE IF NOT EXISTS qa_answers (
                    id BIGSERIAL PRIMARY KEY,
                    question_id BIGINT NOT NULL REFERENCES qa_questions(id) ON DELETE CASCADE,
                    answer TEXT NOT NULL,
                    referenced_docs JSONB NOT NULL DEFAULT '[]'::JSONB,
                    topk INT DEFAULT 5,
                    response_time_ms INT,
                    recall_rate FLOAT,
                    feedback_score INT CHECK (feedback_score >= 1 AND feedback_score <= 5),
                    created_at TIMESTAMPTZ DEFAULT NOW()
                );
                CREATE INDEX IF NOT EXISTS idx_kb_metadata ON knowledge_base USING GIN (metadata);
                CREATE INDEX IF NOT EXISTS idx_kb_embedding_hnsw 
                    ON knowledge_base USING HNSW (embedding vector_cosine_ops)
                    WITH (m = 16, ef_construction = 64);
            """);
            System.out.println("✅ 数据库表与索引创建完成");

            // 2. 插入知识片段
            List<Map.Entry<String, Map<String, String>>> knowledgeDocs = List.of(
                    Map.entry("PostgreSQL 是一款先进的开源关系型数据库管理系统,支持 ACID 事务。",
                            Map.of("source", "docs/intro.md", "topic", "database")),
                    Map.entry("pgvector 是 PostgreSQL 的向量相似度搜索扩展,支持 L2、内积和余弦距离。",
                            Map.of("source", "docs/pgvector.md", "topic", "vector")),
                    Map.entry("RAG(检索增强生成)结合了信息检索与 LLM 生成能力,可有效减少幻觉。",
                            Map.of("source", "docs/rag.md", "topic", "ai"))
            );

            for (var doc : knowledgeDocs) {
                float[] emb = generateMockEmbedding();
                String embStr = vecToString(emb);
                String metadataJson = mapper.writeValueAsString(doc.getValue());
                try (PreparedStatement ps = conn.prepareStatement(
                        "INSERT INTO knowledge_base (content, embedding, metadata) VALUES (?, ?::VECTOR(768), ?::JSONB)")) {
                    ps.setString(1, doc.getKey());
                    ps.setString(2, embStr);
                    ps.setString(3, metadataJson);
                    ps.executeUpdate();
                }
            }
            System.out.println("✅ 已插入 " + knowledgeDocs.size() + " 条知识片段");

            // 3. 模拟用户提问
            String userQuestion = "什么是 RAG?";
            float[] queryEmb = generateMockEmbedding();
            String queryEmbStr = vecToString(queryEmb);

            // 向量检索
            List<ObjectNode> searchResults = new ArrayList<>();
            try (PreparedStatement ps = conn.prepareStatement(
                    "SELECT id, content, metadata, 1 - (embedding <=> ?::VECTOR(768)) AS similarity " +
                    "FROM knowledge_base ORDER BY embedding <=> ?::VECTOR(768) LIMIT 3")) {
                ps.setString(1, queryEmbStr);
                ps.setString(2, queryEmbStr);
                ResultSet rs = ps.executeQuery();
                while (rs.next()) {
                    ObjectNode node = mapper.createObjectNode();
                    node.put("id", rs.getLong("id"));
                    node.put("content", rs.getString("content"));
                    node.put("similarity", rs.getFloat("similarity"));
                    // 解析 metadata JSON
                    String meta = rs.getString("metadata");
                    node.set("metadata", mapper.readTree(meta));
                    searchResults.add(node);
                }
            }
            System.out.println("🔍 检索结果: " + mapper.writeValueAsString(searchResults));

            // 记录问题
            long questionId;
            try (PreparedStatement ps = conn.prepareStatement(
                    "INSERT INTO qa_questions (question, embedding) VALUES (?, ?::VECTOR(768)) RETURNING id")) {
                ps.setString(1, userQuestion);
                ps.setString(2, queryEmbStr);
                ResultSet rs = ps.executeQuery();
                rs.next();
                questionId = rs.getLong(1);
            }

            // 模拟回答
            String mockAnswer = "RAG(检索增强生成)是一种结合信息检索与 LLM 生成的技术框架...";
            ArrayNode refDocs = mapper.createArrayNode();
            for (ObjectNode r : searchResults) {
                ObjectNode doc = mapper.createObjectNode();
                doc.put("id", r.get("id").asLong());
                doc.put("content", r.get("content").asText());
                doc.put("source", r.get("metadata").get("source").asText("unknown"));
                doc.put("similarity", r.get("similarity").asDouble());
                refDocs.add(doc);
            }
            String refDocsJson = mapper.writeValueAsString(refDocs);

            try (PreparedStatement ps = conn.prepareStatement(
                    "INSERT INTO qa_answers (question_id, answer, referenced_docs, topk, response_time_ms, recall_rate) " +
                    "VALUES (?, ?, ?::JSONB, ?, ?, ?)")) {
                ps.setLong(1, questionId);
                ps.setString(2, mockAnswer);
                ps.setString(3, refDocsJson);
                ps.setInt(4, 3);
                ps.setInt(5, 450);
                ps.setDouble(6, 0.92);
                ps.executeUpdate();
            }
            System.out.println("✅ 问答记录已保存");

            // 查询完整链路
            try (PreparedStatement ps = conn.prepareStatement(
                    "SELECT q.id, q.question, a.answer, a.referenced_docs, a.response_time_ms, a.feedback_score " +
                    "FROM qa_questions q LEFT JOIN qa_answers a ON q.id = a.question_id WHERE q.id = ?")) {
                ps.setLong(1, questionId);
                ResultSet rs = ps.executeQuery();
                if (rs.next()) {
                    System.out.printf("📝 完整问答链路: ID=%d, Question=%s, Answer=%s, ResponseTime=%dms%n",
                            rs.getLong(1), rs.getString(2), rs.getString(3), rs.getInt(5));
                }
            }
        }
    }
}
技术点总结
  • 使用 JDBC 驱动 postgresql 配合 VECTOR 类型字符串传递。
  • 借助 Jackson 处理 JSONB 的序列化与反序列化。
  • 采用 try-with-resources 确保连接和语句正确释放。
  • 完整实现知识入库、向量检索、问答记录和链路查询。

多语言对比

维度Node.jsGoPythonJava
驱动/ORMpgpgx/v5psycopg2postgresql JDBC
向量传递方式JSON.stringify 后转 ::VECTORjson.Marshal 后转 ::VECTORjson.dumps 后转 ::VECTORObjectMapper.writeValueAsString 后转 ::VECTOR
JSONB 处理原生对象 + JSON.stringifyjson.Marshal + JSONB 强制转换psycopg2.extras.JsonObjectMapper + ::JSONB
连接管理Pool 连接池pgxpool 连接池普通 Connection(可搭配 psycopg2.pool)DriverManager(可搭配 HikariCP)
异步支持原生 async/await原生 goroutine + context同步(可使用 asyncio + asyncpg)同步(可使用 CompletableFuture)
错误处理try/catchif err != niltry/excepttry/catch
依赖管理npmgo modpipMaven
代码简洁性中等(异步直观)中等(显式错误处理)简洁(动态类型)较冗长(类型声明 + 序列化)
典型应用场景快速原型、中小规模高并发、微服务数据分析、快速开发企业级应用、大型团队

各语言实现均遵循相同的表结构和业务逻辑,开发者可根据项目技术栈和性能要求灵活选择。

项目难点与解决方案

核心难点

  • 如何在海量知识片段中快速检索出与用户问题最相关的 Top-K 片段。
  • 如何兼顾元数据的灵活性与查询性能。
  • 如何设计表结构以便于后续的问答效果分析和模型优化。

解决方案

  • 采用 pgvector 的 IVFFlat 或 HNSW 索引,将向量检索时间复杂度从 O(n) 降至 O(log n) 级别。
  • 使用 JSONB 存储元数据,并结合 GIN 索引实现高效过滤。
  • 通过 qa_answers 表记录 recall_rate、feedback_score 和 response_time_ms,形成可量化的评估闭环。

广度

  • 涵盖知识入库、向量检索、问答记录、用户反馈全链路。
  • 兼容多种向量索引算法,适应不同数据规模。

深度

  • 深入探讨向量维度的选择依据(模型输出维度与索引支持上限)。
  • 提供完整的 Node.js 示例,覆盖从建表到查询的全流程。

复杂度

  • 涉及数据库扩展、向量索引、JSONB 查询优化,属于中等偏上的复杂度,适合有一定 PostgreSQL 基础的开发者。

官方文档

参考链接

总结

本文围绕 RAG 智能问答系统的数据层设计,系统阐述了基于 PostgreSQL 的三张核心表结构及其向量检索能力。通过合理使用 pgvector 扩展和 JSONB 数据类型,既实现了高效的知识检索,又保留了元数据的灵活性。

表结构设计中,knowledge_base 作为知识底座存储向量片段,qa_questions 记录用户问题,qa_answers 保存回答及溯源信息,三者共同构成了完整的数据闭环。同时,通过示例代码展示了从建表、插入、检索到记录的全流程,帮助读者快速上手实践。

基于PostgreSQL向量检索与WebSocket的RAG智能法律咨询系统实战 检索增强生成(RAG)是一种将外部知识库与大语言模型(LLM)相结合的技术范式,其核心原理是通过向量化检索从权威知识源中获取精准上下文,再交由大模型生成可靠回答,从而有效解决LLM的“幻觉”和知识陈旧问题。这一技术在专业咨询、智能客服等领域具有重要价值,能够确保回答的准确性和可追溯性。在具体应用场景中,例如法律、医疗等专业领域,结合PostgreSQL的pgvector扩展进行高效的向量相似度搜索,并通过WebSocket实现流式响应,可以构建出实时、精准的智能问答系统。本文以法律援助平台为例,详细阐述了如 阅读详情

相关推荐

基于RAG与WebSocket构建智能法律咨询平台:PostgreSQL向量检索实战

在构建专业领域智能问答系统时,如何确保回答的准确性与实时性是核心挑战。RAG(检索增强生成)技术通过将外部知识库与大型语言模型(LLM)结合,有效缓解了模型的“幻觉”问题,使其生成内容有据可依。其核心原理是先将非结构化知识(如法律条文)通过嵌入模型转化为向量,存储于向量数据库中;当用户提问时,将问题同样向量化,并检索出最相关的知识片段作为上下文,再交由LLM生成最终回答。这一架构模式在医疗、金融、法律等高要求场景中极具技术价值,能显著提升问答的专业性和可信度。PostgreSQL凭借其成熟的生态,通过pgv

weixin_30301449的博客 444

智能问数系统:SQL生成与JSON格式化提示词设计指南

本文介绍如何设计提示词,让大模型根据用户自然语言问题生成SQL查询语句,并将查询结果格式化为用户友好的形式。

m0_59235245的博客 212

为Dify构建长期记忆模块:基于PostgreSQL与向量检索的智能体记忆增强实践

在构建智能对话系统时,如何让AI助手记住跨会话的用户偏好与历史信息,是提升其实用性与个性化体验的核心挑战。这涉及到对话系统的长期记忆能力,其原理在于将关键信息结构化存储于外部数据库,并通过高效的检索机制在需要时精准调用。该技术能显著增强智能体的连贯性与用户粘性,广泛应用于客服机器人、个人知识助手及行业顾问等场景。本文聚焦于为流行的AI应用开发平台Dify实现一个长期记忆工具,其核心是利用PostgreSQL进行结构化存储,并集成pgvector扩展实现语义检索,从而有效解决对话“健忘症”问题。

weixin_33721344的博客 578

打造企业级智能问答系统的秘密:如何使用云数据库 PostgreSQL 版实现向量检索

本文就如何利用火山引擎云数据库 PostgreSQL 版和大语言模型技术(Large Language Model,简称 LLM),实现企业级智能交互式问答系统进行介绍。通过本文,你将会了解交互式问答系统的原理,学习 PostgreSQL 的向量化存储和检索技术,以及大语言模型交互技术等。背景在大数据的浪潮下,众多企业建立了自己的知识库,以便于信息检索和知识查询。然而,随着知识库内容的膨胀,传统的...

字节跳动技术团队官方博客 2万+

PostgreSQL向量搜索实战:用pgvector构建语义检索系统

向量搜索是现代AI应用的核心能力,本质是将文本、图像等非结构化数据映射为高维空间中的数学向量,通过余弦相似度等度量实现语义匹配。其技术价值在于突破关键词匹配局限,支撑RAG、智能推荐、语义去重等场景。PostgreSQL凭借ACID事务、SQL表达力与成熟运维体系,成为向量检索落地的理想底座;pgvector作为原生扩展,无需更换数据库即可启用向量索引与相似度计算,显著降低架构复杂度与数据一致性风险。本文聚焦pgvector在真实业务中的部署、调优与排障,覆盖HNSW索引选型、向量归一化、混合查询优化等关键

cucanqi9387的博客 476

PGvector与Spring AI:高效向量检索实践指南

向量数据库是现代AI应用中的核心技术,通过将数据转换为高维向量实现语义理解。PGvector作为PostgreSQL的扩展插件,提供了高效的向量存储和检索能力,支持多种相似性搜索算法如IVFFlat和HNSW。与Spring AI结合使用时,开发者可以轻松构建智能推荐系统、语义搜索等应用。这种组合不仅继承了PostgreSQL的可靠性和Spring生态的简洁性,还能通过元数据过滤实现复杂查询。在实际工程中,合理选择索引类型和优化配置参数对性能至关重要,特别是在处理大规模向量数据时。

weixin_33874713的博客 713

LaunchStack核心功能解析:PostgreSQL+pgvector如何实现智能文档检索

LaunchStack是一款基于Next.js、LangChain和PostgreSQL+pgvector构建的AI驱动创业加速引擎,它能够帮助用户上传、组织文档并与文档进行智能对话。本文将深入解析LaunchStack如何利用PostgreSQL和pgvector实现高效的智能文档检索功能,为新手和普通用户提供专业易懂的技术解读。 ## 什么是PostgreSQL+pgvector? Pos

gitblog_00382的博客 815

pgvector:PostgreSQL 原生向量检索实战指南

向量检索是支撑语义搜索、AI推荐与智能问答的核心能力,其本质是通过嵌入向量的相似度计算实现高维空间中的近似最近邻查找。原理上依赖余弦相似度、欧氏距离等度量,并结合IVFFlat或HNSW等索引结构平衡精度与性能。技术价值在于避免多系统协同带来的延迟、一致性与运维负担,显著降低AI应用落地门槛。典型应用场景包括电商对话匹配、内容语义推荐、知识库问答等需融合语义理解与结构化数据的业务。本文聚焦pgvector——PostgreSQL原生向量扩展,详解其零改造集成、VECTOR数据类型、ACID保障下的向量查询及

weixin_34198762的博客 444

MaxKB数据库设计:PostgreSQL表结构深度解析

MaxKB作为一款强大的企业级智能体平台,其底层数据库设计采用了PostgreSQL结合pgvector扩展,为RAG(Retrieval-Augmented Generation,检索增强生成)场景提供了高性能的数据存储和向量检索能力。本文将深入解析MaxKB的核心表结构设计。 ## 核心表结构总览 MaxKB的数据库设计围绕知识管理、用户管理、向量检索等核心功能构建,主要包含以下关键表: ...

gitblog_00620的博客 1001

从零构建中华古诗词数据库:表结构设计、SQL优化与向量检索实战

数据库设计是数据管理的核心基础,而关系型数据库的建模与查询优化直接决定了应用系统的性能与扩展性。从实体关系模型到范式化拆分,再到索引策略与SQL执行计划,每一步都影响着数据存储与检索的效率。在实际工程中,无论是处理CSV导入、解决中文乱码,还是通过连接池提升并发能力,这些技术都构成了数据库运维与开发的必备技能。随着AI时代到来,向量数据库与RAG技术的引入,更让传统文本数据具备了语义检索能力,为知识图谱与智能问答提供了新的可能。本文以中华古诗词数据库的完整构建过程为例,从表结构设计、数据清洗,到SQL实战、

weixin_30800807的博客 421

卸载重装Ubuntu22.04双系统

先说一下写此篇文章的背景吧,我在Windows下配置了三个cornerNet深度学习环境分别是cuda10.3(显卡版本太高不支持),cuda11.3(配置后偶然看到一篇说这个版本win下只能用CPU跑),最后是cuda11.1终究还是没能跑通代码,因为它的代码是在Liunx系统写的,就想着装个Ubuntu试试看,在网上看说一般软件不要装太高版本,我就下载了470版的显卡驱动,跟着步骤升级了系统内核,结果第二天开机Ubuntu就崩了,开机黑屏左上角只有一道横杠显示,只能按ctrl+shift+f5进入命令窗

编程小白的博客 8121

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

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

Wang的专栏 696

CANoe之UDS诊断自动化测试(四):创建诊断自定义Panel发送诊断(替代Session Control窗口)

通过自定义的Panel界面实现诊断发送的功能,并且还可以根据自己的测试需求添加需要的诊断信息,使用非常灵活。

weixin_69677286的博客 1906

LangChain + PostgreSQL 向量化存储与智能RAG检索实战

本文详细介绍了如何利用LangChain框架与PostgreSQL数据库(通过pgvector扩展)构建智能RAG检索系统。通过实战演示,从环境搭建、文档向量化存储到检索链构建,手把手教你打造一个能基于自有知识库进行精准问答的AI助手,有效减少大模型幻觉,提升信息检索的准确性与可靠性。

a2b3c4d5e的博客 413

大模型微调实战:LORA轻量级微调DeepSeek

LORA(Low-Rank Adaptation) 是一种高效的参数高效微调方法,其核心思想是通过在预训练模型的权重矩阵中引入低秩适配矩阵(低秩分解矩阵 A 和 B),仅对这部分新增参数进行训练,从而大幅减少计算和显存开销。与传统全参数微调相比,LORA 通过冻结原始模型参数,仅更新适配层参数,实现了轻量化训练。

dmx123789的博客 2166

KEGG数据库与KAAS工具:基因功能注释的实用指南

本文提供了使用KEGG数据库与KAAS工具进行基因功能注释的完整实用指南。详细阐述了如何从准备基因或蛋白序列开始,通过KAAS服务器获取KEGG Orthology(KO)编号,并解读注释结果。文章进一步介绍了如何利用KOBAS工具进行通路富集分析,将定性观察转化为定量洞察,并分享了提高注释准确率、处理大数据集及使用API等避坑技巧与高阶方法,为基因组学、转录组学研究者奠定坚实的数据分析基础。

weixin_29292535的博客 394

基于Transformer与PostgreSQL的向量检索实战:从原理到应用

向量嵌入(Embedding)作为现代机器学习中的核心概念,是将文本、图像等高维数据映射为低维稠密向量的关键技术。其原理通常基于Transformer架构的自注意力机制,能够捕捉数据的深层语义信息。这项技术的核心价值在于,它使得计算机能够理解并比较非结构化数据的语义相似性,从而为智能搜索、推荐系统、问答机器人等应用场景提供了基础。在实际工程中,如何高效存储和检索这些向量成为关键挑战。PostgreSQL结合pgvector扩展,提供了成熟的关系型数据库向量解决方案,支持近似最近邻搜索,有效解决了海量向量数据

427

【电子通识】TINA-TI怎么使用受控源向导创建受控源

TINA-TI怎么使用受控源向导创建受控源

一点硬件 360

ID-based RAG FastAPI实战案例:构建智能文档问答系统

RAG(检索增强生成)技术正在改变企业处理文档的方式,而**ID-based RAG FastAPI**项目则提供了一个轻量级解决方案,帮助开发者快速构建智能文档问答系统。本文将通过实际案例,展示如何利用该项目集成Langchain与PostgreSQL/pgvector,打造具备高效检索能力的问答应用。 ## 📌 核心功能解析:为什么选择ID-based RAG架构? ID-based R

gitblog_00506的博客 883

大数据架构中的数据治理:元数据管理与数据血缘追踪实践

本文将聚焦大数据架构中数据治理的两大核心支柱——元数据管理与数据血缘追踪元数据管理的目标、类型与实施步骤(从需求分析到工具落地);数据血缘追踪的技术实现(静态解析、动态捕获、混合方案)与应用场景;如何将两者结合,构建完整的数据治理体系,并通过真实案例展示落地效果。元数据管理:定义了业务/技术/操作元数据,讲解了工具选型(如Apache Atlas)、采集(Hook/API)、存储(关系库+图数据库)、应用(数据发现、质量监控);数据血缘追踪。

欢迎来到我的优快云空间!这里聚焦AI大模型应用实战,分享前沿技术、实战案例与开发经验。 870

工业级向量检索核心技术:IVF-PQ原理与全流程解析

在大规模高维向量检索场景中,IVF-PQ(倒排索引结合乘积量化)凭借“粗筛范围+细算距离”的双重加速策略,成为核心解决方案。本文将深入解析其原理与全流程,助力开发者掌握这一关键技术。

进一步有进一步的欢喜~ 1199

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

摘要 本文介绍了基于PostgreSQL和pgvector构建RAG(检索增强生成)系统的技术方案。RAG系统通过将用户查询向量化,检索语义相关的知识片段,再结合大语言模型生成精准答案。PostgreSQL凭借pgvector扩展实现向量存储与检索,同时支持结构化数据管理,形成统一的知识库底座。文章详细阐述了系统架构、技术选型优势、数据库设计(包括表结构、向量索引选择与创建)以及系统集成方法。该方案通过PostgreSQL的事务一致性、权限控制等企业级特性,结合向量检索能力,为企业知识管理提供高效解决方案。

Wang的专栏 309

LoveSQL

LoveSQL(SQL注入详解) 1、根据题目,显然想到的是sql注入漏洞,直接尝试万能密码 2、此时url构造,查看字段数 /check.php?username=admin' order by 3%23&password=1 # 存在 /check.php?username=admin' order by 4%23&password=1 # 报错 因此,得到总共有三个字段数 注意:url中不能用#,应该用url编码%23 3、用union来查询测试注入点,查看回显点

lunan的博客 1562

RAG在PostgreSQL上的实现:使用Azure Container Apps和OpenAI构建智能问答系统

检索增强生成(RAG)是一种结合了检索系统和生成模型的AI技术。它通过从知识库中检索相关信息,然后利用大语言模型生成最终答案,既保证了回答的准确性,又赋予了AI更强的推理和生成能力。使用pgvector扩展对PostgreSQL数据库表进行向量化搜索结合全文搜索,通过RRF(Reciprocal Rank Fusion)算法融合搜索结果利用OpenAI的function calling将用户查询转换为SQL过滤条件使用OpenAI的嵌入API将用户查询转换为向量。

Nifc666的博客 1293

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

[实战复盘] 性能提升 400 倍:我们为何放弃 Milvus 选择 PostgreSQL 做向量检索?

本文记录了一次从MySQL+Milvus到PostgreSQL(pgvector)的架构升级实践。针对AIoT业务中"结构化过滤+向量检索"的混合场景,原方案存在跨系统I/O瓶颈,导致查询耗时高达27秒。通过迁移1300万+数据至PostgreSQL并采用HNSW索引,实现了96%+召回率下0.03秒的查询响应,性能提升超400倍。测试表明,在1亿数据量级内,单机PostgreSQL优于分布式方案,同时大幅降低了内存消耗(从750GB降至26GB)。文章详细分析了HNSW算法原理和pgv

数据与算法架构提升之路专栏 1604

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

gbrain搜索技术解密:如何实现PostgreSQL级别的本地智能检索

gbrain是一款基于OpenClaw/Hermes架构的本地智能检索工具,它通过创新性地融合PostgreSQL级别的数据库技术与现代检索算法,实现了无需复杂配置即可在本地运行的高性能智能搜索系统。无论是开发者、研究人员还是普通用户,都能通过gbrain体验到企业级的检索能力,同时享受本地数据处理带来的隐私安全与速度优势。 ## 核心引擎架构:PostgreSQL技术的本地革命 gbrain

gitblog_00299的博客 1150
上一篇: PostgreSQL笔记51: 基于 pgvector 构建企业级智能问答系统
下一篇: PostgreSQL笔记53:向量索引创建与性能对比及常见陷阱解析
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、付费专栏及课程。

余额充值