Ces dernières années, les intégrations vectorielles sont devenues le fondement du traitement du langage naturel (NLP) moderne et de la recherche sémantique. Au lieu de s'appuyer sur des recherches par mots clés, les bases de données vectorielles comparent la ? signification ? du texte à l'aide de représentations numériques (embeddings). Cet exemple montre comment créer un moteur de recherche sémantique à l'aide de l'intégration OpenAI, Go et PostgreSQL avec l'extension pgvector.

Qu'est-ce que l'intégration??

L'intégration est une représentation vectorielle de texte (ou d'autres données) dans un espace de grande dimension. Si deux morceaux de texte sont sémantiquement similaires, leurs vecteurs seront proches l’un de l’autre dans cet espace. En stockant les intégrations dans une base de données comme PostgreSQL (avec l'extension pgvector), nous pouvons effectuer des recherches de similarité rapidement et avec précision.

Pourquoi choisir PostgreSQL et pgvector??

pgvector est une extension populaire qui ajoute des types de données vectorielles à PostgreSQL. Il vous permet de :

• Stocker les intégrations sous forme de colonnes vectorielles
• Effectuer une recherche approximative ou exacte du voisin le plus proche
• Exécuter des requêtes en utilisant SQL standard

Présentation de l'application

1. Appelez l'API d'intégration d'OpenAI pour convertir le texte d'entrée en intégrations vectorielles.
2. Utilisez l'extension pgvector pour stocker ces intégrations dans PostgreSQL.
3. Interrogez les intégrations pour trouver les entrées les plus sémantiquement similaires dans la base de données.

Prérequis

• Go installé (1.19 recommandé).
• PostgreSQL installé et exécuté (local ou hébergé).
• Installez l'extension pgvector dans PostgreSQL. (Voir la page GitHub de pgvector pour les instructions d'installation.)
• Clé API OpenAI avec accès intégré.

Makefile contenant les taches liées à postgres/pgvector et Docker pour les tests locaux.

pgvector:
    @docker run -d \
        --name pgvector \
        -e POSTGRES_USER=admin \
        -e POSTGRES_PASSWORD=admin \
        -e POSTGRES_DB=vectordb \
        -v pgvector_data:/var/lib/postgresql/data \
        -p 5432:5432 \
        pgvector/pgvector:pg17
psql:
    @psql -h localhost -U admin -d vectordb

Assurez-vous que pgvector est installé. Ensuite, dans votre base de données PostgreSQL?:

CREATE EXTENSION IF NOT EXISTS vector;

Code complet

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "strings"

    "github.com/jackc/pgx/v5/pgxpool"
    "github.com/joho/godotenv"
    "github.com/sashabaranov/go-openai"
)

func floats32ToString(floats []float32) string {
    strVals := make([]string, len(floats))
    for i, val := range floats {
        // 將每個浮點數(shù)格式化為字符串
        strVals[i] = fmt.Sprintf("%f", val)
    }

    // 使用逗號 + 空格連接它們
    joined := strings.Join(strVals, ", ")

    // pgvector 需要方括號表示法才能輸入向量，例如 [0.1, 0.2, 0.3]
    return "[" + joined + "]"
}

func main() {
    // 加載環(huán)境變量
    err := godotenv.Load()
    if err != nil {
        log.Fatal("加載 .env 文件出錯")
    }

    // 創(chuàng)建連接池
    dbpool, err := pgxpool.New(context.Background(), os.Getenv("DATABASE_URL"))
    if err != nil {
        fmt.Fprintf(os.Stderr, "無法創(chuàng)建連接池：%v\n", err)
        os.Exit(1)
    }
    defer dbpool.Close()

    // 1. 確保已啟用 pgvector 擴展
    _, err = dbpool.Exec(context.Background(), "CREATE EXTENSION IF NOT EXISTS vector;")
    if err != nil {
        log.Fatalf("創(chuàng)建擴展失敗：%v\n", err)
        os.Exit(1)
    }

    // 2. 創(chuàng)建表（如果不存在）
    createTableSQL := `
    CREATE TABLE IF NOT EXISTS documents (
        id SERIAL PRIMARY KEY,
        content TEXT,
        embedding vector(1536)
    );
    `
    _, err = dbpool.Exec(context.Background(), createTableSQL)
    if err != nil {
        log.Fatalf("創(chuàng)建表失?。?v\n", err)
    }

    // 3. 創(chuàng)建索引（如果不存在）
    createIndexSQL := `
    CREATE INDEX IF NOT EXISTS documents_embedding_idx
    ON documents USING ivfflat (embedding vector_l2_ops) WITH (lists = 100);
    `
    _, err = dbpool.Exec(context.Background(), createIndexSQL)
    if err != nil {
        log.Fatalf("創(chuàng)建索引失敗：%v\n", err)
    }

    // 4. 初始化 OpenAI 客戶端
    apiKey := os.Getenv("OPENAI_API_KEY")
    if apiKey == "" {
        log.Fatal("未設(shè)置 OPENAI_API_KEY")
    }
    openaiClient := openai.NewClient(apiKey)

    // 5. 插入示例文檔
    docs := []string{
        "PostgreSQL 是一個先進的開源關(guān)系數(shù)據(jù)庫。",
        "OpenAI 提供基于 GPT 的模型來生成文本嵌入。",
        "pgvector 允許將嵌入存儲在 Postgres 數(shù)據(jù)庫中。",
    }

    for _, doc := range docs {
        err = insertDocument(context.Background(), dbpool, openaiClient, doc)
        if err != nil {
            log.Printf("插入文檔“%s”失敗：%v\n", doc, err)
        }
    }

    // 6. 查詢相似性
    queryText := "如何在 Postgres 中存儲嵌入？"
    similarDocs, err := searchSimilarDocuments(context.Background(), dbpool, openaiClient, queryText, 5)
    if err != nil {
        log.Fatalf("搜索失敗：%v\n", err)
    }

    fmt.Println("=== 最相似的文檔 ===")
    for _, doc := range similarDocs {
        fmt.Printf("- %s\n", doc)
    }
}

// insertDocument 使用 OpenAI API 為 `content` 生成嵌入，并將其插入 documents 表中。
func insertDocument(ctx context.Context, dbpool *pgxpool.Pool, client *openai.Client, content string) error {
    // 1) 從 OpenAI 獲取嵌入
    embedResp, err := client.CreateEmbeddings(ctx, openai.EmbeddingRequest{
        Model: openai.AdaEmbeddingV2, // "text-embedding-ada-002"
        Input: []string{content},
    })
    if err != nil {
        return fmt.Errorf("CreateEmbeddings API 調(diào)用失?。?w", err)
    }

    // 2) 將嵌入轉(zhuǎn)換為 pgvector 的方括號字符串
    embedding := embedResp.Data[0].Embedding // []float32
    embeddingStr := floats32ToString(embedding)

    // 3) 插入 PostgreSQL
    insertSQL := `
        INSERT INTO documents (content, embedding)
        VALUES (, ::vector)
    `
    _, err = dbpool.Exec(ctx, insertSQL, content, embeddingStr)
    if err != nil {
        return fmt.Errorf("插入文檔失敗：%w", err)
    }

    return nil
}

// searchSimilarDocuments 獲取用戶查詢的嵌入，并根據(jù)向量相似性返回前 k 個相似的文檔。
func searchSimilarDocuments(ctx context.Context, pool *pgxpool.Pool, client *openai.Client, query string, k int) ([]string, error) {
    // 1) 通過 OpenAI 獲取用戶查詢的嵌入
    embedResp, err := client.CreateEmbeddings(ctx, openai.EmbeddingRequest{
        Model: openai.AdaEmbeddingV2, // "text-embedding-ada-002"
        Input: []string{query},
    })
    if err != nil {
        return nil, fmt.Errorf("CreateEmbeddings API 調(diào)用失?。?w", err)
    }

    // 2) 將 OpenAI 嵌入轉(zhuǎn)換為 pgvector 的方括號字符串格式
    queryEmbedding := embedResp.Data[0].Embedding // []float32
    queryEmbeddingStr := floats32ToString(queryEmbedding)
    // 例如 "[0.123456, 0.789012, ...]"

    // 3) 構(gòu)建按向量相似性排序的 SELECT 語句
    selectSQL := fmt.Sprintf(`
        SELECT content
        FROM documents
        ORDER BY embedding <-> '%s'::vector
        LIMIT %d;
    `, queryEmbeddingStr, k)

    // 4) 運行查詢
    rows, err := pool.Query(ctx, selectSQL)
    if err != nil {
        return nil, fmt.Errorf("查詢文檔失?。?w", err)
    }
    defer rows.Close()

    // 5) 讀取匹配的文檔
    var contents []string
    for rows.Next() {
        var content string
        if err := rows.Scan(&content); err != nil {
            return nil, fmt.Errorf("掃描行失?。?w", err)
        }
        contents = append(contents, content)
    }
    if err = rows.Err(); err != nil {
        return nil, fmt.Errorf("行迭代錯誤：%w", err)
    }

    return contents, nil
}

Conclusion

Les intégrations OpenAI dans PostgreSQL, Go et pgvector fournissent une solution simple pour créer des applications de recherche sémantique. En représentant le texte sous forme de vecteurs et en tirant parti de la puissance des index de bases de données, nous passons des recherches traditionnelles basées sur des mots clés à la recherche par contexte et par signification.

Cette sortie révisée conserve le style de langue d'origine, reformule les phrases pour plus d'originalité et conserve l'image dans le même format et le même emplacement. Le code est également légèrement amélioré pour plus de clarté et de lisibilité. Les principales modifications incluent des noms de variables et des commentaires plus descriptifs.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!