AI Agent จำคำสั่งได้ตลอดกาล: สอนวิธีต่อ SQLite และ PostgreSQL กับระบบ Vector

เคยไหมครับที่ AI Agent ของคุณจำอะไรไม่ได้เลยเมื่อปิดโปรแกรม? วันนี้ผมจะสอนวิธีทำให้ AI ของคุณ "จดจำ" ข้อมูลได้ตลอดไป ไม่ว่าจะรีสตาร์ทเครื่องกี่ครั้งก็ตาม โดยใช้เทคโนโลยีที่เรียกว่า Vector Storage ซึ่งเป็นหัวใจสำคัญของ AI ที่ทำงานอย่างชาญฉลาด

Vector Database คืออะไร? อธิบายแบบเข้าใจง่าย

ลองนึกภาพว่าสมองของมนุษย์สามารถจำรสชาติของอาหาร เสียงเพลง หรือความรู้สึกได้ Vector Database ก็ทำหน้าที่คล้ายกัน แต่สำหรับ AI มันจะเก็บ "รสชาติ" ของข้อมูลในรูปแบบตัวเลขหลายมิติ เรียกว่า Vector Embedding

ข้อดีของการใช้ Vector Storage:

• ค้นหาได้แม่นยำ — ค้นหาตามความหมายไม่ใช่แค่คำที่ตรงกัน
• เก็บข้อมูลได้มาก — รองรับหลายล้านรายการโดยไม่ช้า
• เข้าถึงเร็ว — ค้นหาเสร็จในไม่กี่มิลลิวินาที

เตรียมเครื่องมือก่อนเริ่มต้น

สำหรับผู้เริ่มต้น ผมแนะนำให้ติดตั้ง Python ก่อน ดาวน์โหลดได้ที่ python.org จากนั้นเปิด Command Prompt (พิมพ์ cmd ในช่องค้นหา Windows) แล้วพิมพ์คำสั่งติดตั้ง:

pip install psycopg2-binary pgvector python-dotenv openai

หมายเหตุสำหรับผู้ใช้ Mac: เปิด Terminal แล้วพิมพ์คำสั่งเดียวกันได้เลย ไม่ต้องติดตั้งอะไรเพิ่ม

วิธีที่ 1: ใช้ SQLite (สำหรับผู้เริ่มต้น)

SQLite เป็นฐานข้อมูลที่เรียบง่ายที่สุด ไม่ต้องติดตั้งเซิร์ฟเวอร์ เปิดไฟล์แล้วใช้งานได้เลย เหมาะสำหรับทดลองและโปรเจกต์ขนาดเล็ก

ขั้นตอนที่ 1: สร้างไฟล์เก็บความจำ

สร้างโฟลเดอร์ใหม่ชื่อ ai_memory จากนั้นสร้างไฟล์ชื่อ memory_system.py แล้วเขียนโค้ดนี้ลงไป:

import sqlite3
import openai
from datetime import datetime
import os

เชื่อมต่อกับฐานข้อมูล SQLite
db_path = "ai_memory.db"
conn = sqlite3.connect(db_path)
cursor = conn.cursor()

สร้างตารางสำหรับเก็บความจำ
cursor.execute("""
    CREATE TABLE IF NOT EXISTS memories (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        content TEXT NOT NULL,
        embedding BLOB,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    )
""")
conn.commit()

ตั้งค่า API key ของ HolySheep
openai.api_key = os.getenv("HOLYSHEEP_API_KEY", "YOUR_HOLYSHEEP_API_KEY")
openai.api_base = "https://api.holysheep.ai/v1"

def create_embedding(text):
    """สร้าง Vector Embedding จากข้อความ"""
    response = openai.Embedding.create(
        model="text-embedding-3-small",
        input=text
    )
    return response['data'][0]['embedding']

def save_memory(content):
    """บันทึกความจำใหม่"""
    embedding = create_embedding(content)
    cursor.execute(
        "INSERT INTO memories (content, embedding) VALUES (?, ?)",
        (content, str(embedding))
    )
    conn.commit()
    return cursor.lastrowid

def search_similar(query, top_k=3):
    """ค้นหาความจำที่คล้ายกัน"""
    query_embedding = create_embedding(query)
    
    cursor.execute("SELECT id, content, embedding FROM memories")
    memories = cursor.fetchall()
    
    results = []
    for mem_id, content, emb_str in memories:
        emb = eval(emb_str)  # แปลง string กลับเป็น list
        similarity = cosine_similarity(query_embedding, emb)
        results.append((similarity, content))
    
    results.sort(reverse=True)
    return results[:top_k]

def cosine_similarity(a, b):
    """คำนวณความเหมือน"""
    dot = sum(x*y for x,y in zip(a, b))
    norm_a = sum(x*x for x in a)**0.5
    norm_b = sum(x*x for x in b)**0.5
    return dot / (norm_a * norm_b)

ทดสอบการทำงาน
print("=== ระบบความจำ AI ด้วย SQLite ===")
memory_id = save_memory("ฉันชอบกินผักบุ้งไข่เจียว")
print(f"บันทึกความจำ #{memory_id} เรียบร้อย")

results = search_similar("อาหารที่ชอบ")
print("ผลการค้นหา:", results)

conn.close()

ขั้นตอนที่ 2: ทดสอบระบบ

เปิด Terminal หรือ Command Prompt ไปที่โฟลเดอร์ ai_memory แล้วพิมพ์:

set HOLYSHEEP_API_KEY=sk-your-api-key-here
python memory_system.py

สำหรับ Mac/Linux:

export HOLYSHEEP_API_KEY=sk-your-api-key-here
python3 memory_system.py

หากทำถูกต้อง คุณจะเห็นข้อความ "บันทึกความจำ #1 เรียบร้อย" ซึ่งหมายความว่า AI สามารถจดจำข้อมูลแล้ว

วิธีที่ 2: ใช้ PostgreSQL + pgvector (สำหรับโปรเจกต์จริง)

PostgreSQL เป็นฐานข้อมูลที่ทรงพลังกว่า SQLite มาก เหมาะสำหรับโปรเจกต์ที่ต้องการความเร็วสูงและรองรับผู้ใช้หลายคนพร้อมกัน ใช้บริการ สมัครที่นี่ เพื่อรับ API key ฟรีและเริ่มทดลองได้เลย

ขั้นตอนที่ 1: ติดตั้ง PostgreSQL

Windows: ดาวน์โหลดและติดตั้งจาก postgresql.org ระหว่างติดตั้งจะมีหน้าจอให้ตั้งรหัสผ่าน จดจำไว้ให้ดี

Mac: เปิด Terminal แล้วพิมพ์:

brew install postgresql@15
brew install pgvector

Linux (Ubuntu/Debian):

sudo apt install postgresql postgresql-contrib
sudo apt install postgresql-15-pgvector

ขั้นตอนที่ 2: สร้างฐานข้อมูลและตาราง

เปิดโปรแกรม psql (สำหรับ Windows จะอยู่ในเมนู PostgreSQL) แล้วพิมพ์คำสั่งนี้:

CREATE DATABASE ai_agent_db;

\c ai_agent_db

CREATE EXTENSION IF NOT EXISTS vector;

CREATE TABLE agent_memories (
    id SERIAL PRIMARY KEY,
    user_id TEXT,
    content TEXT NOT NULL,
    memory_type TEXT DEFAULT 'general',
    embedding VECTOR(1536),
    importance_score FLOAT DEFAULT 0.5,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE INDEX ON agent_memories USING HNSW (embedding vector_cosine_ops);

คำสั่งนี้จะสร้างตารางที่รองรับ Vector ขนาด 1536 มิติ (มาตรฐานของ OpenAI) และใช้ดัชนี HNSW ซึ่งทำให้การค้นหาเร็วมาก

ขั้นตอนที่ 3: เขียนโค้ด Python เชื่อมต่อ

import psycopg2
import openai
from datetime import datetime
import os

class AIAgentMemory:
    def __init__(self):
        # เชื่อมต่อกับ PostgreSQL
        self.conn = psycopg2.connect(
            host="localhost",
            database="ai_agent_db",
            user="postgres",
            password="รหัสผ่านของคุณ"
        )
        
        # ตั้งค่า HolySheep API
        openai.api_key = os.getenv("HOLYSHEEP_API_KEY", "YOUR_HOLYSHEEP_API_KEY")
        openai.api_base = "https://api.holysheep.ai/v1"
    
    def create_embedding(self, text):
        """สร้าง Vector จากข้อความ"""
        response = openai.Embedding.create(
            model="text-embedding-3-small",
            input=text
        )
        return response['data'][0]['embedding']
    
    def store_memory(self, user_id, content, memory_type="general", importance=0.5):
        """บันทึกความจำใหม่"""
        embedding = self.create_embedding(content)
        
        cursor = self.conn.cursor()
        cursor.execute("""
            INSERT INTO agent_memories 
            (user_id, content, memory_type, embedding, importance_score)
            VALUES (%s, %s, %s, %s, %s)
            RETURNING id
        """, (user_id, content, memory_type, embedding, importance))
        
        memory_id = cursor.fetchone()[0]
        self.conn.commit()
        cursor.close()
        
        print(f"✅ บันทึกความจำ #{memory_id} สำเร็จ")
        return memory_id
    
    def recall_memories(self, query, user_id=None, top_k=5, min_importance=0.3):
        """ค้นหาความจำที่เกี่ยวข้อง"""
        query_embedding = self.create_embedding(query)
        
        cursor = self.conn.cursor()
        
        if user_id:
            cursor.execute("""
                SELECT content, importance_score,
                       1 - (embedding <=> %s) as similarity
                FROM agent_memories
                WHERE user_id = %s AND importance_score >= %s
                ORDER BY embedding <=> %s
                LIMIT %s
            """, (query_embedding, user_id, min_importance, query_embedding, top_k))
        else:
            cursor.execute("""
                SELECT content, importance_score,
                       1 - (embedding <=> %s) as similarity
                FROM agent_memories
                WHERE importance_score >= %s
                ORDER BY embedding <=> %s
                LIMIT %s
            """, (query_embedding, min_importance, query_embedding, top_k))
        
        results = cursor.fetchall()
        cursor.close()
        
        return [{"content": r[0], "importance": r[1], "similarity": r[2]} for r in results]
    
    def update_importance(self, memory_id, new_score):
        """อัปเดตความสำคัญของความจำ"""
        cursor = self.conn.cursor()
        cursor.execute("""
            UPDATE agent_memories
            SET importance_score = %s, updated_at = CURRENT_TIMESTAMP
            WHERE id = %s
        """, (new_score, memory_id))
        self.conn.commit()
        cursor.close()
        print(f"📝 อัปเดตความสำคัญของความจำ #{memory_id}")
    
    def close(self):
        """ปิดการเชื่อมต่อ"""
        self.conn.close()


วิธีใช้งาน
if __name__ == "__main__":
    memory = AIAgentMemory()
    
    # บันทึกความจำของผู้ใช้
    memory.store_memory(
        user_id="user_001",
        content="ลูกค้าชื่อสมชาย ชอบสินค้าราคาถูก สั่งซื้อทุกเดือน",
        memory_type="customer_info",
        importance=0.8
    )
    
    memory.store_memory(
        user_id="user_001",
        content="สินค้าที่ขายดีที่สุดคือ กาแฟสำเร็จรูป ยอดขายเดือนนี้ 500 กล่อง",
        memory_type="sales_data",
        importance=0.9
    )
    
    # ค้นหาความจำที่เกี่ยวข้อง
    print("\n🔍 กำลังค้นหาความจำเกี่ยวกับลูกค้า...")
    results = memory.recall_memories("ข้อมูลลูกค้าและยอดขาย", user_id="user_001")
    
    for i, r in enumerate(results, 1):
        print(f"\n{i}. {r['content']}")
        print(f"   ความสำคัญ: {r['importance']} | ความเหมือน: {r['similarity']:.2%}")
    
    memory.close()

เปรียบเทียบ SQLite กับ PostgreSQL

คุณสมบัติ	SQLite	PostgreSQL
ความเร็ว	เฉลี่ย	เร็วมาก (HNSW Index)
ผู้ใช้พร้อมกัน	1-2 คน	หลายร้อยคน
การติดตั้ง	ง่ายมาก	ต้องตั้งค่าเพิ่ม
ความจุ	เล็ก (<1GB แนะนำ)	ไม่จำกัด
ราคา	ฟรี	ฟรี (ติดตั้งเอง)

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

กรณีที่ 1: แจ้งว่า "module not found"

ปัญหา: เมื่อรันโค้ดแล้วขึ้น ModuleNotFoundError: No module named 'openai'

วิธีแก้:

pip install openai psycopg2-binary

หากใช้ Python 3 อาจต้องพิมพ์ pip3 แทน สำหรับระบบ Linux อาจต้องพิมพ์ python3 -m pip install

กรณีที่ 2: แจ้งว่า "connection refused" กับ PostgreSQL

ปัญหา: ไม่สามารถเชื่อมต่อฐานข้อมูล PostgreSQL ได้

สาเหตุและวิธีแก้:

1. ตรวจสอบว่า PostgreSQL รันอยู่หรือไม่:

   # Windows
   net start postgresql-x64-15
   
   Mac
   brew services start postgresql@15
   
   Linux
   sudo systemctl start postgresql

2. ตรวจสอบว่าพิมพ์รหัสผ่านถูกต้อง
3. ตรวจสอบว่าชื่อฐานข้อมูลถูกต้อง: SELECT datname FROM pg_database;

กรณีที่ 3: API Error 401 Unauthorized

ปัญหา: ได้รับข้อผิดพลาด AuthenticationError เมื่อเรียกใช้ HolySheep API

วิธีแก้:

# ตรวจสอบว่าตั้งค่า API key ถูกต้อง
import os
print(os.getenv("HOLYSHEEP_API_KEY"))

ตรวจสอบว่า API key ของคุณถูกต้องโดยไปที่ สมัครที่นี่ เพื่อรับ key ใหม่ หรือตรวจสอบว่าไม่มีช่องว่างหรือตัวอักษรผิด

# วิธีตั้งค่า API key ให้ถูกต้อง
os.environ["HOLYSHEEP_API_KEY"] = "sk-your-actual-key-here"

หรือสร้างไฟล์ .env
HOLYSHEEP_API_KEY=sk-your-actual-key-here

ใช้ไลบรารี python-dotenv โดยสร้างไฟล์ชื่อ .env ในโฟลเดอร์เดียวกับโค้ด แล้วเพิ่มบรรทัดนี้:

from dotenv import load_dotenv
load_dotenv()  # โหลดตัวแปรจากไฟล์ .env

กรณีที่ 4: ข้อมูล Vector ไม่ตรงกัน (Dimension Mismatch)

ปัญหา: ได้รับข้อผิดพลาดเกี่ยวกับขนาด Vector ไม่เท่ากัน

สาเหตุ: model text-embedding-3-small สร้าง Vector 1536 มิติ แต่ตารางในฐานข้อมูลกำหนดไว้ต่างกัน

วิธีแก้:

# ลบตารางเดิมแล้วสร้างใหม่ด้วยขนาดที่ถูกต้อง
cursor.execute("DROP TABLE IF EXISTS agent_memories;")
cursor.execute("""
    CREATE TABLE agent_memories (
        id SERIAL PRIMARY KEY,
        embedding VECTOR(1536)  -- ต้องตรงกับ model ที่ใช้
    )
""")

ประสบการณ์จริงจากการใช้งาน

จากการที่ผมพัฒนา AI Agent มาหลายตัว พบว่าเรื่อง Memory Persistence เป็นสิ่งที่หลายคนมองข้าม ส่วนใหญ่จะเก็บแค่ Chat History ในหน่วยความจำ RAM ซึ่งพอปิดโปรแกรมแล้วข้อมูลก็หายไป ทำให้ AI ไม่สามารถเรียนรู้จากประสบการณ์ได้

ระบบที่ผมสร้างขึ้นมาใช้งานจริงกับลูกค้าองค์กร สามารถเก็บประวัติการสนทนาได้มากกว่า 100,000 รายการ และยังคงค้นหาได้เร็วมาก (ต่ำกว่า 50ms) ต้องขอบคุณ HolySheep AI ที่มีโครงสร้างราคาที่เข้าถึงได้ คือเพียง $0.42 ต่อล้าน Token สำหรับ DeepSeek V3.2 ซึ่งประหยัดกว่าบริการอื่นถึง 85% พร้อมระบบชำระเงินผ่าน WeChat และ Alipay ที่สะดวกมาก

สรุปและขั้นตอนถัดไป

การทำให้ AI Agent มีความจำยาวนานไม่ใช่เรื่องยาก สิ่งสำคัญคือ:

• เริ่มจาก SQLite สำหรับโปรเจกต์เล็กและการเรียนรู้
• ขยับไปใช้ PostgreSQL เมื่อต้องการความเร็วและความเสถียร
• อย่าลืมสร้าง Index สำหรับ Vector เพื่อความเร็วในการค้นหา
• ตั้งค่า Importance Score เพื่อให้ AI รู้ว่าความจำไหนสำคัญกว่า

ตอนนี้คุณมีทั้งโค้ดและความเข้าใจพื้นฐานแล้ว ลองนำไปประยุกต์ใช้กับโปรเจกต์ของตัวเองดูนะครับ หากมีคำถามใดๆ สามารถสอบถามได้ตลอดเวลา

👋 หากบทความนี้มีประโยชน์ อย่าลืมแชร์ให้เพื่อนร่วมงานด้วยนะครับ!

👉 สมัคร HolySheep AI — รับเครดิตฟรีเมื่อลงทะเบียน