สร้าง AI Agent จำลูกค้าได้ข้ามวันด้วย Ollama + Mem0 + Qdrant: ระบบ Long-Term Memory แบบออฟไลน์ 100% ลดต้นทุน API สำหรับธุรกิจไทยตาม PDPA

ปัญหาที่ธุรกิจไทยเจอทุกวัน

คุณเคยเจอไหม ลูกค้าทักมาวันจันทร์ถามเรื่องสินค้า คุณตอบไป AI ช่วยตอบไป แล้ววันอังคารลูกค้าทักมาใหม่ AI กลับถามว่า "สวัสดีครับ มีอะไรให้ช่วยไหม" เหมือนไม่เคยคุยกันมาก่อน

นี่คือปัญหาใหญ่ของ Chatbot ทั่วไป มันไม่มี Long-Term Memory ทุกครั้งที่เปิด session ใหม่ข้อมูลเก่าหายหมด ลูกค้ารู้สึกว่าธุรกิจไม่แคร์ ไม่จำ ไม่สนใจ

ทางออกคือการสร้างระบบความจำถาวรให้ AI แต่ถ้าใช้บริการ Cloud อย่าง OpenAI หรือ Anthropic ต้นทุนจะบานปลาย แถบข้อมูลลูกค้ายังไปเก็บที่เซิร์ฟเวอร์ต่างประเทศ ซึ่ง ผิดกฎหมาย PDPA ถ้าไม่มีมาตรการป้องกันที่ชัดเจน

บทความนี้เราจะมาสร้าง AI Agent ที่จำลูกค้าได้ข้ามวัน รันออฟไลน์ 100% บนเครื่องของคุณเอง ด้วยสามเครื่องมือหลักคือ Ollama + Mem0 + Qdrant

ทำไมต้อง Ollama + Mem0 + Qdrant

ก่อนลงมือทำ มาทำความรู้จักแต่ละตัวก่อน

Ollama — LLM ที่รันบนเครื่องคุณ

Ollama เป็นเครื่องมือที่ให้คุณรัน LLM บนเครื่องของคุณเอง ไม่ต้องเสียเงินค่า API รองรับหลายโมเดล เช่น Llama 3, Qwen, Mistral ติดตั้งง่ายเหมือน Docker pull

Mem0 — เลเยอร์ความจำสำหรับ AI

Mem0 (อ่านว่า Mem-Zero) เป็นไลบรารีที่ทำหน้าที่จัดการความจำให้ AI มันจะแยกแยะว่าข้อมูลไหนสำคัญควรจำ ข้อมูลไหนไม่สำคัญควรลืม และดึงข้อมูลที่เกี่ยวข้องมาใช้ตอนที่ลูกค้าคุยด้วย

Qdrant — Vector Database สำหรับเก็บความจำ

Qdrant เป็น Vector Database ที่เก็บข้อมูลในรูปแบบเวกเตอร์ ทำให้ค้นหาข้อมูลที่ "ใกล้เคียง" ได้เร็วและแม่นยำ รันได้บนเครื่องของคุณเองผ่าน Docker

สามตัวนี้รวมกัน = AI ที่จำลูกค้าได้ รันออฟไลน์ ไม่ส่งข้อมูลออกไปไหน

สถาปัตยกรรมระบบ

ลูกค้าส่งข้อความ
    ↓
Mem0 ตรวจสอบว่ามีความจำเก่าของลูกค้าคนนี้ไหม
    ↓
Qdrant ค้นหาเวกเตอร์ที่เกี่ยวข้อง
    ↓
Ollama รับ context + ความจำ + ข้อความใหม่ → สร้างคำตอบ
    ↓
Mem0 บันทึกข้อมูลใหม่ที่สำคัญลง Qdrant
    ↓
ตอบลูกค้า

flow นี้ทำให้ AI จำได้ว่าลูกค้าคนนี้เคยถามอะไร สนใจสินค้าอะไร มีปัญหาอะไรมาก่อน

เริ่มลงมือ: ติดตั้งทุกอย่าง

1. ติดตั้ง Ollama

ดาวน์โหลดจาก ollama.com แล้วติดตั้งตามปกติ จากนั้นดึงโมเดลที่ต้องการ

# ดึงโมเดล Qwen 2.5 ที่ภาษาไทยได้ดี
ollama pull qwen2.5:7b

# หรือถ้าเครื่องแรง ลอง Llama 3.1
ollama pull llama3.1:8b

ทดสอบว่ารันได้

ollama run qwen2.5:7b "สวัสดีครับ"

2. ติดตั้ง Qdrant ผ่าน Docker

docker run -d \
  --name qdrant \
  -p 6333:6333 \
  -p 6334:6334 \
  -v $(pwd)/qdrant_data:/qdrant/storage \
  qdrant/qdrant

Qdrant จะรันอยู่ที่ localhost:6333 ข้อมูลเก็บในโฟลเดอร์ qdrant_data ไม่หายแม้ปิดเครื่อง

3. ติดตั้ง Python และไลบรารี

pip install mem0ai ollama qdrant-client

เขียนโค้ด AI Agent ที่จำลูกค้าได้

สร้างไฟล์ agent.py แล้ววางโค้ดนี้

from mem0 import Memory
import ollama

# ตั้งค่า Mem0 ให้ใช้ Ollama + Qdrant
config = {
    "llm": {
        "provider": "ollama",
        "config": {
            "model": "qwen2.5:7b",
            "temperature": 0.7,
            "max_tokens": 2000,
        }
    },
    "embedder": {
        "provider": "ollama",
        "config": {
            "model": "nomic-embed-text",
        }
    },
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "host": "localhost",
            "port": 6333,
            "collection_name": "customer_memories",
        }
    }
}

# ดึง embedding model สำหรับ Qdrant
ollama.pull("nomic-embed-text")

# สร้าง instance ของ Memory
m = Memory.from_config(config)


def chat_with_customer(user_id: str, message: str) -> str:
    """ฟังก์ชันหลักสำหรับคุยกับลูกค้า"""
    
    # 1. ดึงความจำเก่าของลูกค้าคนนี้
    memories = m.search(query=message, user_id=user_id)
    
    context = ""
    if memories and len(memories["results"]) > 0:
        context = "\n\nข้อมูลที่จำได้เกี่ยวกับลูกค้า:\n"
        for mem in memories["results"]:
            context += f"- {mem['memory']}\n"
    
    # 2. สร้าง prompt ที่มีความจำ
    system_prompt = f"""คุณเป็นผู้ช่วยของร้านค้าไทย ตอบลูกค้าเป็นกันเอง สุภาพ
ใช้ข้อมูลที่จำได้เพื่อตอบให้เป็นส่วนตัว
{context}"""
    
    # 3. เรียก Ollama สร้างคำตอบ
    response = ollama.chat(
        model="qwen2.5:7b",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": message},
        ],
    )
    
    answer = response["message"]["content"]
    
    # 4. บันทึกข้อมูลใหม่ลงความจำ
    m.add(
        messages=[
            {"role": "user", "content": message},
            {"role": "assistant", "content": answer},
        ],
        user_id=user_id,
    )
    
    return answer


# ทดสอบ
if __name__ == "__main__":
    customer_id = "cust_001"
    
    # วันจันทร์: ลูกค้าถามครั้งแรก
    print("ลูกค้า:", "สนใจรองเท้าผ้าใบสีดำ ไซส์ 42 มีไหม")
    print("AI:", chat_with_customer(customer_id, "สนใจรองเท้าผ้าใบสีดำ ไซส์ 42 มีไหม"))
    
    print("---")
    
    # วันอังคาร: ลูกค้าทักมาใหม่
    print("ลูกค้า:", "รองเท้าที่ถามเมื่อวาน มีสีอื่นไหม")
    print("AI:", chat_with_customer(customer_id, "รองเท้าที่ถามเมื่อวาน มีสีอื่นไหม"))

ลองรันดู

python agent.py

ผลที่ได้: วันอังคาร AI จะจำได้ว่าลูกค้าคนนี้เคยถามรองเท้าผ้าใบสีดำไซส์ 42 และตอบได้ว่ามีสีอื่นอะไรบ้าง โดยไม่ต้องให้ลูกค้าบอกซ้ำ

ทำไม Mem0 ไม่ใช่แค่เก็บทุกอย่าง

สิ่งที่ Mem0 ทำได้ดีกว่าการเก็บ chat history ธรรมดาคือมัน กรองข้อมูล ให้เอง

เช่น ลูกค้าพูดว่า "อากาศร้อนจัง" Mem0 จะไม่เก็บประโยคนี้เพราะไม่ใช่ข้อมูลที่จำเป็น แต่ถ้าลูกค้าพูดว่า "ผมแพ้น้ำหอม" Mem0 จะเก็บไว้เพราะเป็นข้อมูลสำคัญที่ควรจำ

มันใช้ LLM ในการตัดสินใจว่าข้อมูลไหนควรเก็บ ข้อมูลไหนควรอัปเดต ข้อมูลไหนควรลบ ทำให้ความจำไม่บวมจนค้นหาช้า

ประเมินต้นทุน: ออฟไลน์ vs Cloud API

มาดูตัวเลขจริงสำหรับธุรกิจขนาดเล็กที่มีลูกค้า 1,000 คน คุยวันละ 10 รอบ

รายการ	Cloud API (OpenAI)	ออฟไลน์ (Ollama)
ค่า LLM ต่อเดือน	~$200-500	0 บาท
ค่า Embedding	~$50	0 บาท
ค่าเซิร์ฟเวอร์	0	ไฟฟ้า ~300 บาท
ความเป็นส่วนตัว	ข้อมูลไปต่างประเทศ	อยู่ในเครื่องคุณ
PDPA Compliance	ต้องทำ DPA	ง่ายกว่ามาก

เครื่องที่ใช้รัน Ollama แนะนำขั้นต่ำ:

• RAM 16GB (32GB ดีกว่า)
• GPU ไม่จำเป็น แต่มีจะเร็วมาก
• SSD 100GB สำหรับเก็บโมเดล + ข้อมูล

ถ้าใช้ GPU เช่น RTX 3060 ราคาประมาณ 7,000 บาท คืนทุนใน 2-3 เดือนเทียบกับค่า API

มุมมองเรื่อง PDPA ที่ธุรกิจไทยต้องรู้

PDPA บังคับให้ธุรกิจต้องปกป้องข้อมูลส่วนบุคคล ถ้าส่งข้อมูลลูกค้าไปเก็บที่เซิร์ฟเวอร์ต่างประเทศ ต้องมีมาตรการตามมาตรา 28-29 ซึ่งซับซ้อนและมีความเสี่ยง

การรัน AI ออฟไลน์บนเครื่องของคุณเอง ข้อมูลลูกค้าไม่ไปไหน ทำให้

• ไม่ต้องทำ Cross-Border Transfer Agreement
• ควบคุมการเข้าถึงข้อมูลได้ 100%
• ลบข้อมูลได้ทันทีเมื่อลูกค้าขอ (สิทธิ์ลบข้อมูลตามมาตรา 33)
• ไม่มีคนนอกองค์กรเห็นข้อมูล

ฟังก์ชันลบความจำลูกค้า (PDPA Compliance)

def delete_customer_data(user_id: str):
    """ลบข้อมูลลูกค้าทั้งหมด (สิทธิ์ตาม PDPA มาตรา 33)"""
    m.delete_all(user_id=user_id)
    print(f"ลบข้อมูลของ {user_id} เรียบร้อย")


def get_customer_data(user_id: str):
    """ดึงข้อมูลลูกค้าทั้งหมด (สิทธิ์เข้าถึงข้อมูลตาม PDPA)"""
    memories = m.get_all(user_id=user_id)
    return memories

เพิ่มฟังก์ชันนี้เข้าระบบ ลูกค้าขอลบข้อมูลก็ลบได้ทันที ไม่ต้องรอใครอนุมัติ

ข้อควรระวังเวลาใช้งานจริง

โมเดลภาษาไทยยังไม่สมบูรณ์

Qwen 2.5 และ Llama 3.1 ภาษาไทยได้ดีระดับหนึ่ง แต่ยังไม่เท่า GPT-4o ถ้าธุรกิจต้องการความแม่นยำสูงมาก อาจต้อง fine-tune โมเดลเพิ่ม หรือใช้โมเดลใหญ่ขึ้น เช่น Qwen 2.5 72B แต่ต้องการ GPU แรง

ความเร็วตอบสนอง

ถ้ารันบน CPU อย่างเดียว คำตอบอาจใช้เวลา 5-15 วินาทีต่อข้อความ ลูกค้าอาจรู้สึกช้า แนะนำให้ใช้ GPU หรือใช้โมเดลเล็กลง เช่น Qwen 2.5 3B ที่เร็วกว่าแต่ความฉลาดน้อยกว่า

Mem0 ยังพัฒนาอยู่

Mem0 เป็นโปรเจกต์ที่เปลี่ยนเร็ว API อาจเปลี่ยนระหว่างเวอร์ชัน ตรวจสอบเอกสารล่าสุดก่อนใช้งานจริง

สรุป: คุ้มไหมที่จะลอง

ถ้าธุรกิจของคุณ

• มีลูกค้าที่คุยซ้ำหลายครั้ง
• ต้องการ AI ที่จำลูกค้าเป็นรายคน
• กังวลเรื่อง PDPA และความเป็นส่วนตัว
• มีงบจ้างเซิร์ฟเวอร์หรือเครื่องรัน AI เอง

แล้วสูตร Ollama + Mem0 + Qdrant คุ้มมาก ต้นทุนระยะยาวต่ำกว่า Cloud API มาก แถบข้อมูลลูกค้าอยู่ในมือคุณ 100%

ลองทำเลยวันนี้

เริ่มจากทำตามโค้ดในบทความนี้ก่อน รันบนเครื่องของคุณ ทดสอบกับลูกค้า 2-3 คน ดูว่า AI จำได้จริงไหม แล้วค่อยขยายไประบบใหญ่

ถ้าทำเสร็จแล้วอยากแชร์ผล หรือมีปัญหาติดขัด โพสต์ถามในชุมชนได้เลย เราอยากเห็นธุรกิจไทยใช้ AI อย่างมีประสิทธิภาพและปลอดภัย

อ่านบทความถัดไปเรื่องการเชื่อม AI Agent นี้เข้ากับ LINE OA และ Facebook Messenger เพื่อใช้งานจริงกับลูกค้า