PostgreSQL笔记50: 基于PGVECTOR的实时推荐与搜索系统构建

别急着上Milvus!用PostgreSQL+pgvector低成本搭建推荐系统的5个实战技巧 本文分享了使用PostgreSQL结合pgvector扩展低成本搭建推荐系统的5个实战技巧。针对百万级数据量场景,文章重点介绍了如何利用pgvector实现高维向量相似性搜索,并结合pg_trgm进行混合搜索、利用PostgreSQL原生事务保证数据一致性、基于余弦相似度进行用户画像匹配、百万元数据下的参数调优以及与LangChain的深度集成方案,为中小团队提供了高性价比的向量搜索解决方案。 阅读详情

纲要

本文档梳理了基于 PostgreSQL 与 pgvector 扩展构建实时推荐与搜索系统的核心概念、技术流程与代码实现。

  • 核心概念
    • 实时推荐与搜索
    • 向量相似性检索
    • 全文检索
    • 混合检索
    • 个性化推荐
  • 技术栈与组件
    • PostgreSQL (数据库核心)
    • pgvector (向量存储与检索扩展)
    • tsvector / tsquery (全文检索)
    • GIN 索引 (全文检索加速)
    • HNSW / IVFFlat 索引 (向量检索加速)
    • 距离操作符: <-> (L2距离), <=> (余弦距离)
    • 排序与评分函数: ts_rank(), 自定义热度与时序衰减函数
  • 系统架构流程
    • 数据层: 商品表, 用户画像表, 用户行为表
    • 计算层: SQL 动态查询, 向量计算, 业务过滤, 排序逻辑
    • 加速层: 多类型索引, 可选的缓存层与连接池 (PgBouncer)
  • 核心查询场景
    • 业务过滤 + 向量 Top-K 检索
    • 全文检索 + 语义检索混合排序
    • 引入热度与时效性的复合排序
    • 基于用户画像的个性化推荐

实时推荐与搜索概述

在现代电商、内容平台和资讯应用中,实时推荐与搜索已成为核心用户体验组件。其关键在于系统能够在极短时间内(毫秒级),基于用户当前的输入、历史行为和实时上下文,动态计算并返回最相关的结果。

传统实现通常依赖复杂的组件栈,如 Elasticsearch 用于全文检索,Faiss 用于向量检索,再辅以独立的特征服务和排序服务。这种架构带来了显著的运维复杂度和性能开销。

PostgreSQL 结合 pgvector 扩展提供了一种极具吸引力的替代方案。它将全文检索、向量语义检索、业务数据过滤和复杂排序能力整合在同一个数据库中,极大地简化了技术栈,降低了数据一致性和运维的复杂性。

系统核心流程

一个典型的实时推荐或搜索请求,其核心处理流程可在数据库单次查询中完成:

数据存储

用户发起请求

应用层构建SQL

PostgreSQL 执行引擎

业务过滤 WHERE

向量相似度检索 ORDER BY dist

全文检索匹配 tsvector AND tsquery

结果排序与打分 ts_rank 自定义评分

返回Top-K结果

商品表 Products

用户画像 Profiles

用户行为 Events

环境准备与数据模型

为演示实时推荐与搜索,我们构建一个电商商品库示例。该示例包含数万条商品数据,每条记录包含基本属性、文本描述以及对应的文本嵌入向量。

启用扩展

首先,确保数据库已安装并启用 pgvector 扩展:

CREATE EXTENSION IF NOT EXISTS vector;

核心表结构设计

数据模型主要围绕三张表构建:products (商品表), user_profiles (用户画像表), user_events (用户行为表)。

-- 商品表
CREATE TABLE products (
    id SERIAL PRIMARY KEY,
    title TEXT NOT NULL,
    category VARCHAR(100),
    price NUMERIC(10, 2),
    description TEXT,
    -- 存储文本嵌入向量,维度为8,实际场景如384, 768, 1536等
    embedding VECTOR(8),
    -- 使用生成列自动维护全文检索向量,避免手动更新
    tsv TSVECTOR GENERATED ALWAYS AS (to_tsvector('simple', title || ' ' || COALESCE(description, ''))) STORED
);

-- 用户画像表
CREATE TABLE user_profiles (
    user_id VARCHAR(50) PRIMARY KEY,
    preference_vector VECTOR(8),
    user_segment VARCHAR(20) -- 如:'高端用户', '普通用户'
);

-- 用户行为表
CREATE TABLE user_events (
    id SERIAL PRIMARY KEY,
    user_id VARCHAR(50) REFERENCES user_profiles(user_id),
    product_id INTEGER REFERENCES products(id),
    event_type VARCHAR(20), -- 'view', 'click', 'purchase'
    event_time TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

辅助函数与数据填充

为了演示,我们创建辅助函数生成随机向量,并插入示例数据。

-- 创建生成随机向量的函数
CREATE OR REPLACE FUNCTION random_vector(dim INTEGER) RETURNS VECTOR AS $$
BEGIN
    RETURN (SELECT array_agg(random() * 100)::VECTOR FROM generate_series(1, dim));
END;
$$ LANGUAGE plpgsql;

-- 插入商品示例数据 (5万条)
INSERT INTO products (title, category, price, description, embedding)
SELECT
    '商品-' || generate_series,
    (ARRAY['手机', '电脑', '家居', '相机', '耳机'])[floor(random() * 5 + 1)],
    round((random() * 5000 + 100)::numeric, 2),
    '这是描述信息-' || generate_series,
    random_vector(8)
FROM generate_series(1, 50000);

-- 模拟特定品牌商品
INSERT INTO products (title, category, price, description, embedding)
VALUES
    ('Apple iPhone 15 Pro', '手机', 799.00, '高端智能手机', random_vector(8)),
    ('Samsung Galaxy S24 Ultra', '手机', 999.00, '安卓旗舰手机', random_vector(8)),
    ('Xiaomi 14 Pro', '手机', 599.00, '高性价比旗舰手机', random_vector(8));

-- 插入用户画像
INSERT INTO user_profiles (user_id, preference_vector, user_segment)
VALUES
    ('user_tech', random_vector(8), '高端用户'),
    ('user_budget', random_vector(8), '普通用户');

-- 插入用户行为
INSERT INTO user_events (user_id, product_id, event_type)
VALUES
    ('user_tech', 1, 'view'),
    ('user_tech', 2, 'click'),
    ('user_budget', 3, 'view');

索引创建

为保障查询性能,需为全文检索和向量检索分别创建索引。

-- 为全文检索创建 GIN 索引
CREATE INDEX idx_products_tsv ON products USING GIN (tsv);

-- 为向量检索创建索引 (此处创建 IVFFlat 和 HNSW 两种以供对比)
-- IVFFlat 索引: 构建速度快,适合大数据集
CREATE INDEX idx_products_embedding_ivfflat ON products USING IVFFLAT (embedding vector_l2_ops) WITH (lists = 100);

-- HNSW 索引: 查询速度极快,但构建和内存消耗较大
-- 可根据实际情况选择其一或同时创建
CREATE INDEX idx_products_embedding_hnsw ON products USING HNSW (embedding vector_l2_ops);

核心查询场景详解

以下通过四个典型查询场景,展示 PostgreSQL + pgvector 在实时推荐与搜索中的强大能力。

场景一: 业务过滤与向量Top-K检索

需求: 用户搜索“价格在500-1500元之间的高端手机”,返回最匹配的10款商品。
逻辑: 先通过业务字段(分类、价格)进行过滤,再与目标向量计算相似度,按距离升序排列。

-- 使用 L2 距离操作符 <->,按距离升序排列
SELECT
    id,
    title,
    category,
    price,
    embedding <-> '[1, 2, 3, 4, 5, 6, 7, 8]'::VECTOR AS distance
FROM
    products
WHERE
    category = '手机'
    AND price BETWEEN 500 AND 1500
ORDER BY
    embedding <-> '[1, 2, 3, 4, 5, 6, 7, 8]'::VECTOR
LIMIT 10;

性能分析:
默认情况下,优化器可能因代价估算选择全表扫描。通过 EXPLAIN 可查看执行计划。若需强制使用向量索引,可调整查询或通过 enable_seqscan 等参数进行调优(生产环境不推荐随意更改全局设置)。此场景为经典的 Top-K 查询,在毫秒级即可完成。

场景二: 全文检索与语义检索的混合排序

需求: 搜索标题或描述中包含“iPhone”或“Camera”的商品,并结合向量语义相似度进行综合排序。
逻辑: 使用 tsvector 进行关键词匹配,并使用 ts_rank 计算文本相关度。同时,计算向量相似度(距离越小,相似度越高),最后加权整合为最终得分 hybrid_score。

WITH search_query AS (
    SELECT
        to_tsquery('simple', 'iphone | camera') AS query_vector,
        '[1, 2, 3, 4, 5, 6, 7, 8]'::VECTOR AS target_embedding
)
SELECT
    p.id,
    p.title,
    p.category,
    p.price,
    -- 计算最终混合得分:文本相关度 + 向量相似度
    (COALESCE(ts_rank(p.tsv, sq.query_vector), 0) * 2 +
     (1 - (p.embedding <-> sq.target_embedding)) * 3) AS hybrid_score
FROM
    products p,
    search_query sq
WHERE
    p.tsv @@ sq.query_vector -- 全文检索匹配条件
    AND p.embedding <-> sq.target_embedding < 2 -- 向量距离过滤条件
ORDER BY
    hybrid_score DESC
LIMIT 10;

场景三: 引入热度和时效性的复合排序

需求: 在相关性的基础上,考虑商品的流行度(如点击量)和时效性(如发布时间),推荐“爆款”和“新品”。
逻辑: 构建一个综合评分函数,包含语义相似度、热度(对数函数压缩)和时效性(指数衰减)三个因子。

-- 假设 products 表中增加了 popularity (整数) 和 created_at (时间) 字段
-- ALTER TABLE products ADD COLUMN popularity INTEGER DEFAULT 0;
-- ALTER TABLE products ADD COLUMN created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP;

WITH search_context AS (
    SELECT
        '[1, 2, 3, 4, 5, 6, 7, 8]'::VECTOR AS target_embedding,
        NOW() AS query_time
)
SELECT
    p.id,
    p.title,
    p.price,
    -- 复合评分逻辑:语义相似度(权重0.5) + 热度(权重0.25) + 时效性(权重0.25)
    ((1 - (p.embedding <-> sc.target_embedding)) * 0.5 +
     LOG(GREATEST(p.popularity, 1) + 1) / LOG(10) * 0.25 +
     EXP(-EXTRACT(EPOCH FROM (sc.query_time - p.created_at)) / 86400) * 0.25) AS final_score
FROM
    products p,
    search_context sc
ORDER BY
    final_score DESC
LIMIT 20;

场景四: 基于用户画像的个性化推荐

需求: 根据用户画像向量和行为数据,为用户推荐其可能感兴趣的商品。
逻辑: 首先,基于用户行为(如浏览、点击)召回候选商品类别;然后,根据用户画像向量与商品向量相似度进行精排。

WITH user_context AS (
    SELECT
        up.user_id,
        up.preference_vector,
        -- 聚合用户行为,找出最常浏览的类别
        (SELECT p.category
         FROM user_events ue
         JOIN products p ON ue.product_id = p.id
         WHERE ue.user_id = 'user_tech'
         GROUP BY p.category
         ORDER BY COUNT(*) DESC
         LIMIT 1) AS preferred_category
    FROM user_profiles up
    WHERE up.user_id = 'user_tech'
)
SELECT
    p.id,
    p.title,
    p.category,
    p.price,
    (p.embedding <-> uc.preference_vector) AS similarity_distance
FROM
    products p,
    user_context uc
WHERE
    p.category = uc.preferred_category -- 第一阶段: 行为召回
ORDER BY
    p.embedding <-> uc.preference_vector -- 第二阶段: 向量精排
LIMIT 10;

API 速览

本部分汇总了上述示例中涉及的核心 PostgreSQL API。

1. pgvector 向量操作

  • 类型: VECTOR(n)
    • 用于定义向量列。n 为维度。
  • 距离操作符:
    • <-> : L2 距离(欧几里得距离),值越小越相似。
    • <=> : 余弦距离,值越小越相似。
    • <#> : 负内积,值越小越相似。
  • 索引加速:
    • IVFFLAT : 基于倒排索引的近似最近邻搜索,构建速度快。
    • HNSW : 基于分层可导航小世界图的索引,查询速度极快,但构建成本高。

代码示例:

-- 创建向量列
ALTER TABLE products ADD COLUMN embedding VECTOR(384);

-- 使用 L2 距离查询
SELECT * FROM products ORDER BY embedding <-> '[0.1, 0.2, ...]'::VECTOR LIMIT 10;

-- 创建 IVFFlat 索引
CREATE INDEX ON products USING IVFFLAT (embedding vector_l2_ops) WITH (lists = 100);

2. 全文检索

  • 类型: TSVECTOR, TSQUERY
    • to_tsvector() : 将文本转换为 TSVECTOR 类型。
    • to_tsquery() : 将查询词转换为 TSQUERY 类型。
  • 操作符:
    • @@ : 匹配操作符,用于判断 TSVECTOR 是否满足 TSQUERY。
  • 函数:
    • ts_rank() : 计算文本查询的相关度分数。

代码示例:

-- 使用生成列自动创建 TSVECTOR
ALTER TABLE products ADD COLUMN tsv TSVECTOR GENERATED ALWAYS AS (to_tsvector('english', title || ' ' || description)) STORED;

-- 创建 GIN 索引加速
CREATE INDEX ON products USING GIN (tsv);

-- 执行全文检索查询
SELECT title, ts_rank(tsv, to_tsquery('english', 'smartphone & camera')) AS rank
FROM products
WHERE tsv @@ to_tsquery('english', 'smartphone & camera')
ORDER BY rank DESC;

3. 通用函数

  • LOG() : 计算自然对数,常用于压缩大数值范围。
  • EXP() : 指数函数,常用于实现时间衰减。
  • EXTRACT(EPOCH FROM ...) : 从时间戳中提取秒数,便于进行时间差计算。

Demo 完整示例

本示例提供一个基于 Node.js 和 pg 客户端的完整演示程序,模拟上述实时推荐与搜索的核心流程。

运行说明

  1. 环境准备:
    • 安装 Node.js (v16+) 和 npm。
    • 准备一个运行中的 PostgreSQL 数据库实例,并已安装 pgvector 扩展。
  2. 配置数据库:
    • 执行前文“环境准备”章节中的 SQL 脚本,创建表结构、函数并插入演示数据。
  3. 安装依赖:
    • 创建项目目录,并执行 npm init -y。
    • 安装必要依赖: npm install pg
  4. 运行脚本:
    • 将以下代码保存为 demo.js,根据实际情况修改数据库连接配置,然后执行 node demo.js。

代码说明

以下 demo.js 脚本依次执行场景一、场景二和场景四的查询,并输出结果。

// demo.js
const { Client } = require('pg');

// 数据库连接配置
const config = {
    user: 'your_user',
    host: '127.0.0.1',
    database: 'your_db',
    password: 'your_password',
    port: 5432,
};

const client = new Client(config);

// 辅助函数: 生成随机向量 (模拟)
function generateRandomVector(dim) {
    const arr = [];
    for (let i = 0; i < dim; i++) {
        arr.push(Math.random() * 100);
    }
    return `[${arr.join(',')}]`;
}

async function runDemo() {
    try {
        await client.connect();
        console.log('数据库连接成功');

        // 1. 场景一: 业务过滤 + 向量 Top-K
        console.log('\n--- 场景一: 业务过滤 + 向量 Top-K ---');
        const targetVector = generateRandomVector(8);
        const query1 = `
            SELECT id, title, price, embedding <-> $1::VECTOR AS distance
            FROM products
            WHERE category = '手机' AND price BETWEEN 500 AND 1500
            ORDER BY embedding <-> $1::VECTOR
            LIMIT 10;
        `;
        const res1 = await client.query(query1, [targetVector]);
        console.log('查询结果:', res1.rows.map(r => ({ id: r.id, title: r.title, price: r.price, distance: r.distance })));

        // 2. 场景二: 全文检索 + 语义检索混合排序
        console.log('\n--- 场景二: 全文检索 + 语义检索混合排序 ---');
        const query2 = `
            WITH search_query AS (
                SELECT to_tsquery('simple', 'iphone | camera') AS query_vector,
                       $1::VECTOR AS target_embedding
            )
            SELECT id, title, price,
                   (ts_rank(p.tsv, sq.query_vector) * 2 + (1 - (p.embedding <-> sq.target_embedding)) * 3) AS hybrid_score
            FROM products p, search_query sq
            WHERE p.tsv @@ sq.query_vector
            ORDER BY hybrid_score DESC
            LIMIT 10;
        `;
        const res2 = await client.query(query2, [targetVector]);
        console.log('混合查询结果:', res2.rows.map(r => ({ id: r.id, title: r.title, price: r.price, score: r.hybrid_score })));

        // 3. 场景四: 个性化推荐 (基于用户画像)
        console.log('\n--- 场景四: 个性化推荐 ---');
        const userId = 'user_tech';
        const query4 = `
            WITH user_context AS (
                SELECT up.preference_vector, p.category
                FROM user_profiles up
                JOIN user_events ue ON up.user_id = ue.user_id
                JOIN products p ON ue.product_id = p.id
                WHERE up.user_id = $1
                GROUP BY up.preference_vector, p.category
                ORDER BY COUNT(*) DESC
                LIMIT 1
            )
            SELECT p.id, p.title, p.category, p.price,
                   (p.embedding <-> uc.preference_vector) AS similarity_distance
            FROM products p, user_context uc
            WHERE p.category = uc.category
            ORDER BY p.embedding <-> uc.preference_vector
            LIMIT 10;
        `;
        const res4 = await client.query(query4, [userId]);
        console.log('个性化推荐结果:', res4.rows.map(r => ({ id: r.id, title: r.title, category: r.category, price: r.price })));

    } catch (err) {
        console.error('执行出错:', err);
    } finally {
        await client.end();
    }
}

runDemo();

技术点总结

  • 单库多模: 演示了如何在同一个 PostgreSQL 数据库中同时处理结构化数据、全文检索和向量检索。
  • 查询简化: 通过 SQL 将复杂的多阶段推荐逻辑(召回、过滤、排序)整合为单一数据库操作,减少了应用层代码量和数据往返。
  • 索引加速: 通过创建 GIN 和 IVFFLAT/HNSW 索引,保障了查询在万级数据量下的毫秒级响应。
  • 灵活排序: 展示了如何使用 SQL 函数自由组合向量距离、文本相关度、热度和时效性因子,实现高度定制化的排序策略。

多语言示例

Go 语言示例

本示例使用 Go 语言和 pgx 驱动(pgx/v5),实现与 Node.js 版本相同的实时推荐与搜索演示。

运行说明
  1. 环境准备:
    • 安装 Go 1.21+。
    • 准备 PostgreSQL 数据库实例,已安装 pgvector 扩展,并完成前文“环境准备”章节中的表结构与数据初始化。
  2. 项目初始化:
    • 创建项目目录,执行 go mod init demo。
    • 安装依赖:go get github.com/jackc/pgx/v5
  3. 运行脚本:
    • 将以下代码保存为 main.go,修改数据库连接字符串,执行 go run main.go。
代码说明
// main.go
package main

import (
    "context"
    "fmt"
    "log"
    "math/rand"
    "strconv"
    "strings"
    "time"

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

func main() {
    // 数据库连接配置
    connStr := "postgresql://your_user:your_password@127.0.0.1:5432/your_db"
    ctx := context.Background()

    conn, err := pgx.Connect(ctx, connStr)
    if err != nil {
        log.Fatal("数据库连接失败:", err)
    }
    defer conn.Close(ctx)
    fmt.Println("数据库连接成功")

    // 辅助函数:生成随机向量字符串
    generateVector := func(dim int) string {
        vals := make([]string, dim)
        for i := 0; i < dim; i++ {
            vals[i] = strconv.FormatFloat(rand.Float64()*100, 'f', 4, 64)
        }
        return "[" + strings.Join(vals, ",") + "]"
    }

    targetVec := generateVector(8)

    // 场景一:业务过滤 + 向量 Top-K
    fmt.Println("\n--- 场景一: 业务过滤 + 向量 Top-K ---")
    query1 := `
        SELECT id, title, price, embedding <-> $1::VECTOR AS distance
        FROM products
        WHERE category = '手机' AND price BETWEEN 500 AND 1500
        ORDER BY embedding <-> $1::VECTOR
        LIMIT 10;
    `
    rows, err := conn.Query(ctx, query1, targetVec)
    if err != nil {
        log.Fatal("查询失败:", err)
    }
    defer rows.Close()
    fmt.Println("查询结果:")
    for rows.Next() {
        var id int
        var title string
        var price float64
        var distance float64
        rows.Scan(&id, &title, &price, &distance)
        fmt.Printf("ID: %d, Title: %s, Price: %.2f, Distance: %.4f\n", id, title, price, distance)
    }

    // 场景二:全文检索 + 语义检索混合排序
    fmt.Println("\n--- 场景二: 全文检索 + 语义检索混合排序 ---")
    query2 := `
        WITH search_query AS (
            SELECT to_tsquery('simple', 'iphone | camera') AS query_vector,
                   $1::VECTOR AS target_embedding
        )
        SELECT id, title, price,
               (ts_rank(p.tsv, sq.query_vector) * 2 + (1 - (p.embedding <-> sq.target_embedding)) * 3) AS hybrid_score
        FROM products p, search_query sq
        WHERE p.tsv @@ sq.query_vector
        ORDER BY hybrid_score DESC
        LIMIT 10;
    `
    rows2, err := conn.Query(ctx, query2, targetVec)
    if err != nil {
        log.Fatal("查询失败:", err)
    }
    defer rows2.Close()
    fmt.Println("混合查询结果:")
    for rows2.Next() {
        var id int
        var title string
        var price float64
        var score float64
        rows2.Scan(&id, &title, &price, &score)
        fmt.Printf("ID: %d, Title: %s, Price: %.2f, Score: %.4f\n", id, title, price, score)
    }

    // 场景四:个性化推荐
    fmt.Println("\n--- 场景四: 个性化推荐 ---")
    userId := "user_tech"
    query4 := `
        WITH user_context AS (
            SELECT up.preference_vector, p.category
            FROM user_profiles up
            JOIN user_events ue ON up.user_id = ue.user_id
            JOIN products p ON ue.product_id = p.id
            WHERE up.user_id = $1
            GROUP BY up.preference_vector, p.category
            ORDER BY COUNT(*) DESC
            LIMIT 1
        )
        SELECT p.id, p.title, p.category, p.price,
               (p.embedding <-> uc.preference_vector) AS similarity_distance
        FROM products p, user_context uc
        WHERE p.category = uc.category
        ORDER BY p.embedding <-> uc.preference_vector
        LIMIT 10;
    `
    rows4, err := conn.Query(ctx, query4, userId)
    if err != nil {
        log.Fatal("查询失败:", err)
    }
    defer rows4.Close()
    fmt.Println("个性化推荐结果:")
    for rows4.Next() {
        var id int
        var title string
        var category string
        var price float64
        var distance float64
        rows4.Scan(&id, &title, &category, &price, &distance)
        fmt.Printf("ID: %d, Title: %s, Category: %s, Price: %.2f, Distance: %.4f\n", id, title, category, price, distance)
    }
}
技术点总结
  • 驱动选择:使用 pgx/v5,这是 Go 生态中性能优异的 PostgreSQL 驱动,支持 pgvector 的向量类型传递(通过 $1::VECTOR 显式转换)。
  • 上下文管理:使用 context.Context 控制查询超时和取消。
  • 类型映射:Scan 方法直接将查询结果映射到 Go 基本类型,简单高效。
  • 连接管理:使用 defer 确保连接和 Rows 正确关闭,防止资源泄露。

Python 语言示例

本示例使用 Python 和 psycopg2 驱动,实现相同的演示逻辑。

运行说明
  1. 环境准备:
    • 安装 Python 3.9+。
    • 准备 PostgreSQL 数据库实例(含 pgvector 和初始化数据)。
  2. 安装依赖:
    • pip install psycopg2-binary
  3. 运行脚本:
    • 将以下代码保存为 demo.py,修改连接字符串,执行 python demo.py。
代码说明
# demo.py
import psycopg2
import random

def generate_vector(dim):
    return '[' + ','.join([f'{random.random() * 100:.4f}' for _ in range(dim)]) + ']'

def main():
    # 数据库连接
    conn = psycopg2.connect(
        host="127.0.0.1",
        port=5432,
        database="your_db",
        user="your_user",
        password="your_password"
    )
    cur = conn.cursor()
    print("数据库连接成功")

    target_vec = generate_vector(8)

    # 场景一
    print("\n--- 场景一: 业务过滤 + 向量 Top-K ---")
    cur.execute("""
        SELECT id, title, price, embedding <-> %s::VECTOR AS distance
        FROM products
        WHERE category = '手机' AND price BETWEEN 500 AND 1500
        ORDER BY embedding <-> %s::VECTOR
        LIMIT 10;
    """, (target_vec, target_vec))
    rows = cur.fetchall()
    for row in rows:
        print(f"ID: {row[0]}, Title: {row[1]}, Price: {row[2]:.2f}, Distance: {row[3]:.4f}")

    # 场景二
    print("\n--- 场景二: 全文检索 + 语义检索混合排序 ---")
    cur.execute("""
        WITH search_query AS (
            SELECT to_tsquery('simple', 'iphone | camera') AS query_vector,
                   %s::VECTOR AS target_embedding
        )
        SELECT id, title, price,
               (ts_rank(p.tsv, sq.query_vector) * 2 + (1 - (p.embedding <-> sq.target_embedding)) * 3) AS hybrid_score
        FROM products p, search_query sq
        WHERE p.tsv @@ sq.query_vector
        ORDER BY hybrid_score DESC
        LIMIT 10;
    """, (target_vec,))
    rows = cur.fetchall()
    for row in rows:
        print(f"ID: {row[0]}, Title: {row[1]}, Price: {row[2]:.2f}, Score: {row[3]:.4f}")

    # 场景四
    print("\n--- 场景四: 个性化推荐 ---")
    user_id = "user_tech"
    cur.execute("""
        WITH user_context AS (
            SELECT up.preference_vector, p.category
            FROM user_profiles up
            JOIN user_events ue ON up.user_id = ue.user_id
            JOIN products p ON ue.product_id = p.id
            WHERE up.user_id = %s
            GROUP BY up.preference_vector, p.category
            ORDER BY COUNT(*) DESC
            LIMIT 1
        )
        SELECT p.id, p.title, p.category, p.price,
               (p.embedding <-> uc.preference_vector) AS similarity_distance
        FROM products p, user_context uc
        WHERE p.category = uc.category
        ORDER BY p.embedding <-> uc.preference_vector
        LIMIT 10;
    """, (user_id,))
    rows = cur.fetchall()
    for row in rows:
        print(f"ID: {row[0]}, Title: {row[1]}, Category: {row[2]}, Price: {row[3]:.2f}, Distance: {row[4]:.4f}")

    cur.close()
    conn.close()

if __name__ == "__main__":
    main()
技术点总结
  • 驱动选择:psycopg2 是 Python 最成熟的 PostgreSQL 适配器,支持 %s 占位符和显式类型转换(%s::VECTOR)。
  • 参数化查询:使用元组传递参数,自动处理引号和转义,防止 SQL 注入。
  • 简洁性:Python 语法简洁,fetchall() 快速获取结果集,适合快速原型开发。
  • 游标管理:手动关闭游标和连接,确保资源释放。

Java 语言示例

本示例使用 Java 和 JDBC 驱动(org.postgresql:postgresql),实现相同功能。

运行说明
  1. 环境准备:
    • 安装 JDK 17+。
    • 准备 PostgreSQL 数据库实例(含 pgvector 和初始化数据)。
  2. 项目配置:
    • 使用 Maven 或 Gradle 添加依赖(见下方 pom.xml)。
    • 将以下代码保存为 Demo.java,编译运行。
  3. 依赖坐标(Maven):
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.7.2</version>
    </dependency>
    
代码说明
// Demo.java
import java.sql.*;
import java.util.Random;

public class Demo {

    private static String generateVector(int dim) {
        Random rand = new Random();
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < dim; i++) {
            if (i > 0) sb.append(",");
            sb.append(String.format("%.4f", rand.nextFloat() * 100));
        }
        sb.append("]");
        return sb.toString();
    }

    public static void main(String[] args) {
        String url = "jdbc:postgresql://127.0.0.1:5432/your_db";
        String user = "your_user";
        String password = "your_password";

        try (Connection conn = DriverManager.getConnection(url, user, password)) {
            System.out.println("数据库连接成功");

            String targetVec = generateVector(8);

            // 场景一
            System.out.println("\n--- 场景一: 业务过滤 + 向量 Top-K ---");
            String sql1 = """
                SELECT id, title, price, embedding <-> ?::VECTOR AS distance
                FROM products
                WHERE category = '手机' AND price BETWEEN 500 AND 1500
                ORDER BY embedding <-> ?::VECTOR
                LIMIT 10;
            """;
            try (PreparedStatement pstmt = conn.prepareStatement(sql1)) {
                pstmt.setString(1, targetVec);
                pstmt.setString(2, targetVec);
                ResultSet rs = pstmt.executeQuery();
                while (rs.next()) {
                    System.out.printf("ID: %d, Title: %s, Price: %.2f, Distance: %.4f%n",
                            rs.getInt("id"), rs.getString("title"),
                            rs.getDouble("price"), rs.getDouble("distance"));
                }
            }

            // 场景二
            System.out.println("\n--- 场景二: 全文检索 + 语义检索混合排序 ---");
            String sql2 = """
                WITH search_query AS (
                    SELECT to_tsquery('simple', 'iphone | camera') AS query_vector,
                           ?::VECTOR AS target_embedding
                )
                SELECT id, title, price,
                       (ts_rank(p.tsv, sq.query_vector) * 2 + (1 - (p.embedding <-> sq.target_embedding)) * 3) AS hybrid_score
                FROM products p, search_query sq
                WHERE p.tsv @@ sq.query_vector
                ORDER BY hybrid_score DESC
                LIMIT 10;
            """;
            try (PreparedStatement pstmt = conn.prepareStatement(sql2)) {
                pstmt.setString(1, targetVec);
                ResultSet rs = pstmt.executeQuery();
                while (rs.next()) {
                    System.out.printf("ID: %d, Title: %s, Price: %.2f, Score: %.4f%n",
                            rs.getInt("id"), rs.getString("title"),
                            rs.getDouble("price"), rs.getDouble("hybrid_score"));
                }
            }

            // 场景四
            System.out.println("\n--- 场景四: 个性化推荐 ---");
            String sql4 = """
                WITH user_context AS (
                    SELECT up.preference_vector, p.category
                    FROM user_profiles up
                    JOIN user_events ue ON up.user_id = ue.user_id
                    JOIN products p ON ue.product_id = p.id
                    WHERE up.user_id = ?
                    GROUP BY up.preference_vector, p.category
                    ORDER BY COUNT(*) DESC
                    LIMIT 1
                )
                SELECT p.id, p.title, p.category, p.price,
                       (p.embedding <-> uc.preference_vector) AS similarity_distance
                FROM products p, user_context uc
                WHERE p.category = uc.category
                ORDER BY p.embedding <-> uc.preference_vector
                LIMIT 10;
            """;
            try (PreparedStatement pstmt = conn.prepareStatement(sql4)) {
                pstmt.setString(1, "user_tech");
                ResultSet rs = pstmt.executeQuery();
                while (rs.next()) {
                    System.out.printf("ID: %d, Title: %s, Category: %s, Price: %.2f, Distance: %.4f%n",
                            rs.getInt("id"), rs.getString("title"),
                            rs.getString("category"), rs.getDouble("price"),
                            rs.getDouble("similarity_distance"));
                }
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
技术点总结
  • JDBC 标准:使用 java.sql 包,兼容所有 PostgreSQL JDBC 驱动。
  • 文本块语法:Java 15+ 支持 """ 多行字符串,提高 SQL 可读性。
  • PreparedStatement:使用 ? 占位符,通过 setString 传递向量参数,类型由 ::VECTOR 在 SQL 中转换。
  • 资源管理:使用 try-with-resources 自动关闭连接和语句,避免内存泄露。
  • 格式化输出:使用 System.out.printf 美化输出。

多语言对比总结

特性Node.js (pg)Go (pgx)Python (psycopg2)Java (JDBC)
驱动/库pggithub.com/jackc/pgx/v5psycopg2-binaryorg.postgresql:postgresql
参数占位符$1, $2$1, $2%s?
向量参数传递直接作为字符串,SQL 中 ::VECTOR直接作为字符串,SQL 中 ::VECTOR直接作为字符串,SQL 中 ::VECTOR直接作为字符串,SQL 中 ::VECTOR
错误处理try-catch / async-awaiterror 返回值try-excepttry-catch / SQLException
连接管理客户端手动 closedefer conn.Close()手动 closetry-with-resources
依赖大小轻量 (纯 JS)轻量 (静态编译)中等 (C 扩展)中等 (JDBC 驱动)
异步支持原生 async/await支持 pgx 原生异步支持异步 (asyncpg)支持异步 (R2DBC)
类型安全性弱类型 (运行时)强类型 (编译时)弱类型 (运行时)强类型 (编译时)
适用场景快速原型、全栈 JS高并发、微服务数据分析、脚本自动化企业级应用、Spring 生态

各语言在实现相同业务逻辑时的核心差异在于驱动 API 风格、错误处理机制和类型系统,但对 PostgreSQL + pgvector 的 SQL 语义支持完全一致,均可通过标准 SQL 完成实时推荐与搜索的混合查询任务。

项目难点与解决方案

核心难点

  • 混合查询性能调优: 当 WHERE 子句中同时包含业务过滤条件和向量距离计算时,优化器可能无法选择最优索引,导致查询性能下降。
  • 索引选择与参数调优: IVFFLAT 和 HNSW 索引有不同的适用场景和参数(如 lists, m, ef_construction),不当配置会影响召回率或查询速度。
  • 向量维度与存储成本: 高维向量(如1536维)会显著增加存储开销和计算时间,需在精度和资源间取得平衡。

解决方案

  • 查询规划调优: 使用 CTE 或子查询强制将业务过滤和向量检索分离执行,或通过设置 enable_seqscan 等参数(谨慎使用)引导优化器选择索引扫描。
  • 索引实验与监控: 在实际数据分布下,对比 IVFFLAT 和 HNSW 在不同参数下的查询延迟和召回率,选择最佳配置。例如,调整 IVFFLAT 的 lists 参数约为 rows / 1000。
  • 向量降维与量化: 在应用层考虑使用更高效的嵌入模型或降维技术(如 PCA)。pgvector 也支持 halfvec 类型以降低存储开销。

广度

涵盖了构建实时推荐系统所需的多方面技术,包括数据库设计、索引优化、全文检索、向量检索、排序算法设计以及与后端应用的集成。

深度

深入探讨了 PostgreSQL 内部机制,如生成列、多种索引类型的实现原理与适用场景、SQL 层复杂评分函数的构建,以及查询性能的调优策略。

复杂度

面对混合检索、个性化推荐和实时性要求,系统复杂度较高。通过将所有逻辑集中在数据库层,有效降低了应用层和系统整体的复杂度,但同时也对数据库管理和 SQL 编写能力提出了更高要求。

官方文档

参考链接

总结

本文详细阐述了如何利用 PostgreSQL 及其扩展 pgvector 构建一个功能完备的实时推荐与搜索系统。我们深入探讨了从数据建模、索引创建到复杂混合查询(融合业务过滤、全文检索、向量相似度、热度及时效性排序)的全过程。通过具体的 SQL 示例和 Node.js Demo 演示,证明了 PostgreSQL 作为一个多模态数据库,能够有效整合传统检索与 AI 向量检索能力,简化技术栈,并在中小规模场景下提供卓越的实时性能。其核心价值在于将复杂的召回、过滤与排序逻辑整合于数据库内核,为开发者提供了一种高效、简洁的解决方案。

基于RAG与PostgreSQL pgvector构建实时AI法律咨询平台 检索增强生成(RAG)是一种将外部知识库与大语言模型(LLM)能力相结合的技术范式,其核心原理是通过语义检索从可信数据源中获取相关信息,再交由大模型进行整合与生成,从而有效解决大模型在专业领域的“幻觉”问题,提升回答的准确性与可信度。该技术具有极高的工程实践价值,尤其在法律、医疗等对准确性要求严苛的垂直领域,能够构建出专业、可靠的智能问答系统。其典型应用场景包括智能客服、知识库问答和个性化推荐等。本文聚焦于法律咨询这一具体场景,详细阐述了如何利用PostgreSQL的pgvector扩展构建向量数据库实现法 阅读详情

相关推荐

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

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

cucanqi9387的博客 476

pgvector实时搜索:流式数据的实时向量搜索

在当今数据驱动的世界中,实时性已成为企业竞争力的关键因素。无论是电商平台的实时商品推荐、金融系统的欺诈检测,还是物联网设备的实时监控,都需要在数据产生的同时进行快速分析和响应。传统批处理方式已无法满足这些场景的需求,流式数据处理和实时搜索技术应运而生。 pgvector作为PostgreSQL的开源向量相似性搜索扩展,不仅提供了强大的向量存储和检索能力,更通过其优化的索引结构和插入机制,为实时向...

gitblog_00349的博客 1032

AltiumDesigner 高效封装库管理 -- samacsys插件实战指南

本文详细介绍了如何利用samacsys插件高效管理AltiumDesigner封装库。通过实战指南,指导用户完成插件安装、云端元件搜索与放置,并分享将海量资源整合为个人标准库的管理策略,从而大幅提升PCB设计效率与可靠性,杜绝封装错误。

weixin_28285943的博客 127

pgvector完整指南:PostgreSQL向量搜索的终极解决方案

在当今AI驱动的时代,向量搜索已成为现代应用的核心需求。无论你是构建智能推荐系统、语义搜索引擎还是AI助手,都需要高效处理高维向量数据。pgvector作为PostgreSQL的开源向量相似度搜索扩展,将向量存储与关系数据库的强大功能完美结合,为开发者提供了完整的向量搜索解决方案。 pgvector支持精确和近似最近邻搜索,提供L2距离、内积、余弦距离等多种相似度计算方法,同时支持单精度、半精度

gitblog_01141的博客 1001

安装Quartus-II 13 和Modelsim

目录一、Quartus-II安装1.Quartus-II 13下载2.Quartus-II 13安装3.Quartus-II 13注册二、Modelsim安装 实验目的:安装Quartus-II 13 和Modelsim 实验环境:Windows10 参考资料:Quartus-II安装及使用 一、Quartus-II安装 1.Quartus-II 13下载 正点原子官方资料下载 百度网盘下载链接: https://pan.baidu.com/s/1a9d-bq9RZmWrRV542X4IEA 提取码:

qqq080的博客 8644

【学习笔记】人群归因分数 PAF 以及combined PAF

人群归因风险比例(Population Attributable Fraction,PAF)是一个流行病学指标,它估计了在总体中,如果能消除一个特定的危险因素,能预防多少百分比的疾病或健康结果。简单来说,PAF回答的是:“如果没有这个风险因素,总体中会有多少病例是可以避免的?

weixin_53499537的博客 4906

3分钟掌握PostgreSQL向量搜索:pgvector实战指南

你是否正在寻找一个简单高效的向量数据库解决方案?pgvector作为PostgreSQL的开源扩展,让你无需学习新的数据库系统,就能在熟悉的PostgreSQL环境中实现强大的向量相似性搜索功能。本文将带你快速上手这个强大的工具,让你的应用瞬间获得AI能力! ## 🚀 为什么你需要向量搜索? 在AI时代,一切数据都可以表示为向量。无论是文本嵌入、图像特征还是用户行为模式,向量搜索都能帮你找到

gitblog_00297的博客 1173

详解STM32F407双重ADC同步采集与DMA传输的配置技巧及实战应用

本文详细解析了STM32F407双重ADC同步采集与DMA传输的配置技巧及实战应用。通过CubeMX配置、代码实现和常见问题解决方案,帮助开发者高效实现多通道数据同步采集,提升工业自动化和嵌入式系统的数据采集效率与精度。

ii567的博客 366

PostgreSQL向量搜索扩展pgvector的容器化部署与运维指南

pgvector是一个为PostgreSQL数据库设计的开源向量相似性搜索扩展,支持单精度、半精度、二进制和稀疏向量存储,提供精确和近似最近邻搜索功能。在AI应用、推荐系统和语义搜索等场景中,pgvector能够将向量数据与关系型数据统一存储,实现高效的向量检索。 ## 技术背景与架构原理 ### 向量搜索的核心概念 向量相似性搜索是现代AI应用的基础设施组件,它通过计算向量之间的距离来找到

gitblog_00640的博客 1099

华为防火墙USG6000系列多ISP上网(通过WEB界面设置)

华为防火墙多ISP上网,内网分区上网。内网多网段不同上网方式。

daxihe880的博客 1万+

sylar学习系列一

开发环境 Centos7最小系统 gcc 9.1 cmake 环境可能存在的一些问题 可能存在的问题,linux最小系统没有一些常用命令,如果我们处于外网我们可以yum安装,但却遇到以下问题 can not find a valid baseurl for repo: base/7/x86-64 可修改网络配置 vi /etc/sysconfig/network-scripts/ifcfg-ens123 # 不是每个主机都是ens123 把ONBOOT=no,改为ONBOOT=yes 重启网络

wuguinianjing的博客 1020

5步快速部署pgvector:PostgreSQL向量搜索扩展终极指南

你是否正在寻找一个简单高效的向量数据库扩展,让你的PostgreSQL具备AI时代必备的向量搜索能力?pgvector正是你需要的PostgreSQL插件!这个开源向量数据库扩展让PostgreSQL从传统的关系型数据库华丽转身,成为支持向量相似性搜索的强大工具。 想象一下,你的应用程序需要处理海量文本、图像或音频的嵌入向量,传统的关键词搜索已经无法满足精准匹配的需求。pgvector向量数据库

gitblog_00130的博客 908

某手sig3-ios算法 Chomper黑盒调用

本文主要是介绍Chomper的算法模拟执行,Chomper目前已经已经是能比较完整的模拟ios可执行文件执行的模拟器,在这块有非常大的优势。以前安卓端有强势的unidbg,现在iOS也有Chomper了,后续等待作者持续更新,完善Chomper。强势推荐一波-> Chomper地址: https://github.com/sledgeh4w/chomper。我这块也已经使用Chomper完成雅迪系列、某手的算法调用。后续也会有更多扩展。

成小新的博客 2159

PostgreSQL向量搜索终极指南:pgvector完整入门教程

PostgreSQL向量相似性搜索扩展pgvector为数据库带来了强大的AI能力,让您能够在PostgreSQL中直接存储和搜索向量数据。这个开源项目让开发者能够在熟悉的SQL环境中实现高效的近似最近邻搜索,完美支持机器学习模型生成的嵌入向量。pgvector支持单精度向量、半精度向量、二进制向量和稀疏向量,并提供多种距离度量函数,是构建智能应用的基础设施。 ## 📊 为什么选择pgvect

gitblog_00938的博客 1042

别再自己造轮子了!用MONAI Model Zoo里的预训练模型,5分钟搞定医学影像AI项目

本文介绍了如何利用MONAI Model Zoo中的预训练模型快速搭建医学影像AI项目,大幅节省开发时间和计算资源。通过实战案例展示了UNet、DenseNet121等核心模型的应用技巧,帮助临床医生和研究者5分钟内启动高质量医学影像分析,特别适合小样本场景下的病灶分割和分类任务。

weixin_33704234的博客 242

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

如何在PostgreSQL中快速部署pgvector向量搜索扩展:完整实战指南

PostgreSQL作为最流行的开源关系数据库之一,现在通过pgvector扩展具备了强大的向量搜索能力。pgvector是一个开源的向量相似性搜索扩展,它将AI向量处理功能直接集成到PostgreSQL中,让你能够在熟悉的SQL环境中执行高效的向量相似性查询。无论你是想要构建智能推荐系统、实现语义搜索功能,还是进行图像相似性分析,pgvector都能为你提供完整的解决方案。 ## 🚀 pgv

gitblog_00448的博客 847

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

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

PostgreSQL向量搜索实战:pgvector扩展完整安装与应用指南

PostgreSQL向量搜索功能通过pgvector扩展为数据库带来了强大的AI能力,让开发者能够在熟悉的SQL环境中处理高维向量数据。无论是构建智能推荐系统、语义搜索应用还是其他AI驱动的业务场景,pgvector都能提供专业级的向量相似性搜索解决方案。 ## 前置环境准备与系统检查 在开始安装pgvector之前,请确保您的系统满足以下基本要求: **必备组件:** - PostgreS

gitblog_01070的博客 1001

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

PostgreSQL向量搜索终极指南:pgvector扩展深度解析与实战

在当今AI驱动的应用开发浪潮中,向量相似性搜索已成为构建智能推荐系统、语义搜索引擎和内容匹配平台的核心技术。PostgreSQL作为最受欢迎的开源关系数据库,通过pgvector扩展成功将向量搜索能力融入其强大的生态系统。本文将为您提供pgvector扩展的完整安装配置指南和实战应用技巧。 ## 🚀 向量搜索技术概述与核心优势 **pgvector扩展**为PostgreSQL带来了原生的向

gitblog_00465的博客 895

如何在5分钟内为PostgreSQL添加向量搜索能力:pgvector终极指南

想要让您的PostgreSQL数据库具备AI时代的向量搜索能力吗?pgvector正是您需要的开源扩展!这个强大的工具让您的数据库能够存储和查询向量数据,为构建智能推荐系统、语义搜索应用和图像相似性分析提供了坚实的基础。 ## 🎯 为什么每个开发者都应该了解pgvector? 在人工智能和机器学习快速发展的今天,向量搜索已经成为现代应用的核心技术。pgvector将这一强大功能直接集成到您熟

gitblog_00090的博客 954

Neighbor与pgvector集成:PostgreSQL向量搜索的10个最佳实践

在当今AI驱动的世界中,向量搜索已成为构建智能应用的核心技术。Neighbor作为一个专为Rails设计的最近邻搜索gem,与PostgreSQL的pgvector扩展完美集成,为开发者提供了简单高效的向量搜索解决方案。本文将分享10个最佳实践,帮助您充分利用Neighbor与pgvector的强大功能,构建高性能的向量搜索应用。🚀 ## 1. 快速安装与配置pgvector扩展 在开始使用

gitblog_00481的博客 822

PostgreSQL学习总结(16)—— PostgreSQL 插件之 pgvector

pgvector作为PostgreSQL的向量搜索扩展,正在成为AI应用的关键组件。它通过持续迭代优化,从0.4.x到0.8.x版本逐步完善了IVFFlat和HNSW索引、量化支持、并行构建等核心功能。0.8.0引入的IterativeIndexScan有效解决了带过滤条件的向量查询难题,平衡了速度与准确性。pgvector支持多种量化方案和索引类型,适用于不同场景:IVFFlat适合批量搜索,HNSW适合实时应用。随着多模态支持增强,pgvector正从文本嵌入扩展到更广泛的AI应用领域,成为Postgr

科技D人生 3493

PostgreSQL向量搜索革命:pgvector扩展深度解析与实践指南

在人工智能和机器学习快速发展的今天,向量数据已成为现代应用的核心组成部分。pgvector作为PostgreSQL的开源向量相似度搜索扩展,为开发者提供了在关系型数据库中存储和查询高维向量的完整解决方案。本文将深入探讨pgvector的技术原理、实战应用和性能优化策略,帮助您构建高效的向量数据库应用。 ## 向量搜索的核心概念与原理 向量搜索的本质是在高维空间中寻找最相似的向量。传统的关系型数

gitblog_00113的博客 690

Windows系统下PostgreSQL pgvector扩展的极速安装指南

还在为Windows环境下的PostgreSQL向量搜索功能发愁吗?🤔 别担心,今天我就带你用最简单的方式搞定pgvector扩展的安装,让你的数据库瞬间拥有AI级别的向量相似性搜索能力!PostgreSQL向量搜索从此不再是难题。 ## 为什么你的Windows安装总是失败? Windows用户经常遇到这些问题: - 编译环境配置复杂,Visual Studio版本不匹配 - 缺少必要的头

gitblog_00314的博客 1292

如何为PostgreSQL添加向量搜索能力:pgvector扩展的完整实战指南

在AI应用爆炸式增长的今天,向量相似性搜索已成为现代数据库系统的核心需求。pgvector作为一个开源的PostgreSQL扩展,为传统关系型数据库赋予了强大的向量搜索能力,让你可以在PostgreSQL中直接存储和查询向量数据,实现高效的近似最近邻搜索。 ## 为什么你需要pgvector?🎯 想象一下这样的场景:你的电商平台需要根据用户浏览历史推荐相似商品,你的内容平台需要根据文章语义匹

gitblog_01427的博客 700

实战指南:PostgreSQL向量搜索扩展pgvector深度解析与性能优化

在人工智能和机器学习快速发展的今天,向量相似性搜索已成为现代应用的核心需求。pgvector作为PostgreSQL的开源向量搜索扩展,为开发者提供了在关系型数据库中存储和查询向量数据的强大能力。本文将深入探讨pgvector的核心功能、性能优化策略以及实际应用场景,帮助你在生产环境中高效部署和使用这一强大的向量搜索工具。 ## 🚀 pgvector:PostgreSQL的向量搜索革命 pg

gitblog_00240的博客 1051

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
上一篇: PostgreSQL笔记49:向量检索核心算法、索引调优与过滤策略深度解析
下一篇: PostgreSQL笔记51: 基于 pgvector 构建企业级智能问答系统
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、付费专栏及课程。

余额充值