วิธีติดตั้งและใช้ OpenAI Embeddings ร่วมกับ PostgreSQL เพื่อสร้างระบบค้นหาเอกสารเชิงบริบทแบบโลคล

Overview — Overview

การสร้างระบบค้นหาเอกสารเชิงบริบทแบบโลคัลด้วย OpenAI Embeddings และ PostgreSQL ช่วยให้คุณสามารถดึงข้อมูลที่เกี่ยวข้องจากชุดข้อความขนาดใหญ่ได้อย่างแม่นยำและเร็วทันใจ บทความนี้จะอธิบายขั้นตอนตั้งแต่การติดตั้งจนถึงการใช้งานจริงในรูปแบบสั้น ๆ ที่อ่านง่าย

ความต้องการเบื้องต้น — Prerequisites

ก่อนเริ่มทำงาน คุณต้องเตรียมเครื่องมือพื้นฐานดังต่อไปนี้

• **Python 3.9+ (พร้อม `pip`)
• PostgreSQL 13 ขึ้นไป พร้อมสิทธิ์ผู้ดูแลระบบ
• pgvector extension สำหรับจัดเก็บเวกเตอร์ใน PostgreSQL
• คีย์ API ของ OpenAI ที่มีสิทธิ์ใช้บริการ Embeddings

**Tip: หากคุณยังไม่มี PostgreSQL ให้ใช้ Docker เพื่อติดตั้งแบบเร็ว ๆ ด้วยคำสั่ง `docker run --name pg -e POSTGRES_PASSWORD=secret -p 5432:5432 postgres`

การติดตั้ง pgvector บน PostgreSQL — Install pgVector

pgvector เป็น extension ที่ทำให้ PostgreSQL รองรับการจัดเก็บและค้นหาเวกเตอร์ได้อย่างมีประสิทธิภาพ

• **ขั้นตอนที่ 1: เปิดเทอร์มินัลแล้วเข้าสู่ `psql` ด้วยผู้ใช้ `postgres`
• **ขั้นตอนที่ 2: รันคำสั่ง `CREATE EXTENSION IF NOT EXISTS vector;` เพื่อติดตั้ง extension ในฐานข้อมูลที่ต้องการ
• **ขั้นตอนที่ 3: ตรวจสอบว่าตาราง `pg_extension` มีรายการ `vector` อยู่

**Tip: หากใช้ Docker image ของ PostgreSQL ให้เลือกภาพที่รวม pgvector ไว้แล้ว (`postgres:15-pgvector`) เพื่อลดขั้นตอนการติดตั้ง

การตั้งค่า Python Environment — Setup Python

สร้าง virtual environment เพื่อแยกโค้ดและแพคเกจจากระบบหลัก

• สร้าง env ด้วย `python -m venv venv`
• เปิดใช้งาน: Windows `.\venv\Scripts\activate`, macOS/Linux `source venv/bin/activate`
• ติดตั้งไลบรารีที่จำเป็น `pip install openai psycopg2-binary tqdm`

**Tip: ใช้ `psycopg2-binary` แทน `psycopg2` เพื่อหลีกเลี่ยงปัญหาเกี่ยวกับคอมไพล์ C บนเครื่องไม่มี build tools

การสร้างตารางเก็บเอกสารและเวกเตอร์ — Create Tables

กำหนดโครงสร้างตารางเพื่อบันทึกข้อความต้นฉบับและเวกเตอร์ที่ได้จาก OpenAI

```sql CREATE TABLE documents ( id SERIAL PRIMARY KEY, title TEXT NOT NULL, content TEXT NOT NULL, embedding VECTOR(1536) -- ขนาดเวกเตอร์ของ model text-embedding-ada-002 ); ```

• **id: รหัสเอกสารอัตโนมัติ
• **title / content: ข้อมูลต้นฉบับที่ต้องการค้นหา
• **embedding: เวกเตอร์ความหมายจาก OpenAI

**Tip: หากใช้โมเดลเวกเตอร์อื่น ให้ปรับขนาด `VECTOR(N)` ให้ตรงกับมิติของโมเดลนั้น

การแปลงข้อความเป็น Embedding — Generate Embeddings

ใช้ API ของ OpenAI เพื่อสร้างเวกเตอร์สำหรับแต่ละเอกสาร

```python import openai, os, psycopg2, tqdm

openai.api_key = os.getenv("OPENAI_API_KEY")

def get_embedding(text): response = openai.Embedding.create( model="text-embedding-ada-002", input=text ) return response["data"][0]["embedding"] ```

• ส่งข้อความ ไม่เกิน 8192 token เพื่อให้ API ตอบเร็ว
• เก็บผลลัพธ์เป็น `list[float]` แล้วแปลงเป็น `array` ก่อนบันทึกลง DB

**Tip: ทำ batch processing ด้วย `tqdm` เพื่อติดตามความคืบหน้าและหลีกเลี่ยง rate‑limit ของ OpenAI

การใส่ข้อมูลเข้าสู่ PostgreSQL — Insert Documents

เชื่อมต่อฐานข้อมูลแล้วอัปโหลดเอกสารพร้อมเวกเตอร์

```python conn = psycopg2.connect( dbname="mydb", user="postgres", password="secret", host="localhost" ) cur = conn.cursor()

for doc in documents: # documents เป็น list ของ dict {title, content} emb = get_embedding(doc["content"]) cur.execute( "INSERT INTO documents (title, content, embedding) VALUES (%s, %s, %s)", (doc["title"], doc["content"], emb) ) conn.commit() cur.close() conn.close() ```

• ใช้ `executemany` หรือ `COPY` หากต้องอัปโหลดหลายพันรายการเพื่อเพิ่มประสิทธิภาพ
• ตรวจสอบว่าตาราง embedding มีประเภท `VECTOR` ก่อนทำการ insert

**Tip: เปิดใช้ `autocommit=False` แล้ว commit ทีละ batch (เช่น 500 รายการ) จะลดเวลา I/O อย่างมาก

การสร้างดัชนีเพื่อค้นหาเร็วขึ้น — Create Index

pgvector รองรับหลายรูปแบบดัชนี; ดัชนีประเภท IVFFLAT ให้ความสมดุลระหว่างความแม่นยำและความเร็ว

```sql CREATE INDEX idx_documents_embedding ON documents USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100); ```

• `vector_cosine_ops` ใช้การวัดระยะทางแบบ cosine similarity
• ปรับค่า `lists` ให้เหมาะกับขนาดข้อมูล (มากขึ้น ค้นหาเร็วกว่า แต่ใช้ดิสก์มากกว่า)

**Tip: สร้างดัชนีก่อนใส่ข้อมูลจำนวนมากจะทำให้การ build ดัชนีช้าลง; จึงแนะนำให้ insert เสร็จก่อนค่อยสร้าง index

การค้นหาเอกสารเชิงบริบท — Querying

เมื่อผู้ใช้ส่งคำถาม เราต้องแปลงเป็น embedding แล้วหาความคล้ายกับเวกเตอร์ใน DB

```python def search(query, top_k=5): q_emb = get_embedding(query) cur.execute( " SELECT id, title, content, 1 - (embedding <=> %s) AS similarity -- cosine distance FROM documents ORDER BY embedding <=> %s LIMIT %s; ", (q_emb, q_emb, top_k) ) return cur.fetchall() ```

• `<=>` คือ operator ของ pgvector ที่คำนวณ cosine distance
• ผลลัพธ์เรียงตามความคล้ายสูงสุด (`similarity` ใกล้ 1)

**Tip: หากต้องการผลลัพธ์ที่หลากหลาย สามารถเพิ่มเงื่อนไข `WHERE similarity > 0.7` เพื่อกรองเอกสารที่ไม่เกี่ยวข้องมากเกินไป

การปรับแต่งและดูแลระบบ — Optimization & Maintenance

เพื่อให้ระบบทำงานได้ต่อเนื่อง ควรตั้งค่าดังนี้

• ตั้งค่า connection pool (เช่น `pgbouncer`) เพื่อจัดการจำนวนการเชื่อมต่อพร้อมกัน
• ใช้ VACUUM ANALYZE หลังจากอัปเดตหรือ delete เอกสารจำนวนมาก
• ตรวจสอบ latency ของ API OpenAI; หากเกิดคอขวดให้เพิ่ม cache (Redis) เก็บ embedding ที่เคยสร้างไว้

**Tip: บันทึก log เวลาในการ query (`EXPLAIN ANALYZE`) เพื่อระบุ bottleneck และปรับค่า `lists` หรือ `probes` ในดัชนี IVFFLAT ให้เหมาะสม

สรุป — Summary

• ติดตั้ง PostgreSQL + pgvector แล้วสร้างตารางเก็บเอกสารและเวกเตอร์
• ใช้ OpenAI Embeddings แปลงข้อความเป็นเวกเตอร์ขนาด 1536 มิติ
• บันทึกเวกเตอร์ในคอลัมน์ `VECTOR` และสร้างดัชนี IVFFLAT เพื่อค้นหาเร็ว
• คิวรีด้วย operator `<=>` เพื่อคำนวณ cosine similarity แล้วเรียงตามคะแนนสูงสุด

สิ่งที่ควรจำ

• ตรวจสอบให้แน่ใจว่าเวกเตอร์และดัชนีใช้ขนาดเดียวกันกับโมเดลที่เลือก
• ใช้ batch insert และ commit เป็นขั้นตอนเพื่อประหยัดเวลา I/O
• ตั้งค่า cache และ connection pool เพื่อรองรับการใช้งานจริง
• ปรับค่าดัชนี (lists, probes) ตามปริมาณข้อมูลและความต้องการ latency

ทำตามขั้นตอนเหล่านี้ คุณจะได้ระบบค้นหาเอกสารเชิงบริบทแบบโลคัลที่เร็ว แรง และแม่นยำ พร้อมรองรับการขยายตัวในอนาคต.