วิธีเพิ่มความจำระยะยาวให้ AI Agent ด้วย OpenAI และ Mem0

AI agent ในปัจจุบันมีความสามารถในการใช้เหตุผลและจัดการงานที่ซับซ้อนได้ดีเยี่ยม แต่ข้อจำกัดสำคัญคือส่วนใหญ่มักจะลืมข้อมูลทุกอย่างทันทีเมื่อจบเซสชันการทำงาน

นั่นหมายความว่าทุกครั้งที่คุณเริ่มการสนทนาใหม่ คุณจะต้องเสียเวลาเริ่มต้นนับหนึ่งเพื่อป้อนบริบทเดิมซ้ำๆ เสมอ

หน่วยความจำของ Agent (Agent Memory) จึงเข้ามาแก้ปัญหานี้ เพื่อช่วยให้ระบบ AI สามารถจดจำข้อมูลที่เป็นประโยชน์ข้ามเซสชันได้ ไม่ว่าจะเป็นการตั้งค่าส่วนบุคคล การตัดสินใจในอดีต เป้าหมายหลัก หรือบริบทสำคัญอื่นๆ

ในบทความนี้ เราจะสร้าง AI agent ที่มีหน่วยความจำระยะยาวโดยใช้ OpenAI Agents SDK และ Mem0 พร้อมวิธีการเชื่อมต่อระบบนี้เข้ากับ OpenCode เพื่อให้เครื่องมือเขียนโค้ดของคุณจดจำข้อมูลสำคัญได้เช่นกัน

หลักการทำงานของหน่วยความจำ AI Agent

ระบบหน่วยความจำของ agent ทำงานผ่านลูปที่เรียบง่าย คือ เมื่อผู้ใช้ส่งข้อความ agent จะค้นหาบริบทที่เกี่ยวข้องในหน่วยความจำ นำข้อมูลนั้นมาใช้ประกอบการใช้เหตุผล และบันทึกประเด็นที่เป็นประโยชน์สำหรับการทำงานในอนาคต

หน่วยความจำสามารถแบ่งออกได้เป็นสองประเภทหลัก:

• Short-term memory (หน่วยความจำระยะสั้น): ข้อมูลเฉพาะหน้าจากการสนทนาปัจจุบัน เช่น ข้อความล่าสุด หรือสถานะการทำงานชั่วคราว
• Long-term memory (หน่วยความจำระยะยาว): ข้อมูลที่คงอยู่ถาวรข้ามเซสชัน เช่น สไตล์การทำงาน การตัดสินใจ และประสบการณ์ที่เคยเรียนรู้มา

หัวใจสำคัญคือกระบวนการ retrieval (การดึงข้อมูล) แทนที่ agent จะต้องอ่านประวัติการสนทนาทั้งหมด ซึ่งจะทำให้ prompt ยาวเกินไป แต่มันจะค้นหาและดึงมาเฉพาะ "ส่วนที่เกี่ยวข้อง" กับคำสั่งปัจจุบันเท่านั้น วิธีนี้ช่วยให้บริบทมีขนาดกะทัดรัด แต่ agent ยังสามารถแสดงพฤติกรรมราวกับจำเรื่องราวในอดีตได้ทั้งหมด

การสร้าง Agent ที่มีความจำระยะยาว

เราจะเริ่มสร้าง agent อย่างง่ายที่สามารถค้นหา บันทึก และเรียกคืนข้อมูลข้ามการสนทนาได้ ขั้นแรกให้ติดตั้ง OpenAI Agents SDK และ Mem0:

pip install openai-agents mem0ai

ถัดไป ให้ตั้งค่า API key ของคุณ:

export OPENAI_API_KEY="your-openai-key"
export MEM0_API_KEY="your-mem0-key"

จากนั้นนำเข้า class และสร้าง Mem0 client สำหรับจัดการข้อมูล:

from agents import Agent, Runner, function_tool
from mem0 import MemoryClient
 
memory = MemoryClient()
USER_ID = "abid"

MemoryClient จะทำหน้าที่เชื่อมต่อ agent เข้ากับฐานข้อมูลของ Mem0 โดยมี USER_ID เป็นตัวระบุเพื่อแยกหน่วยความจำของผู้ใช้แต่ละรายออกจากกันอย่างเป็นสัดส่วน

การสร้างเครื่องมือค้นหาหน่วยความจำ

เราต้องกำหนดเครื่องมือ search_memory เพื่อให้ agent สามารถเข้าถึงข้อมูลในอดีตได้ โดยเครื่องมือนี้จะส่งคำค้นหาไปยัง Mem0 และดึงผลลัพธ์ที่เกี่ยวข้องที่สุดกลับมา

@function_tool
def search_memory(query: str) -> str:
    """Search for relevant memories about the user."""
 
results = memory.search(
        query=query,
        filters={"user_id": USER_ID},
        top_k=5,
    )
 
memories = results.get("results", [])
 
if not memories:
        return "No relevant memories found."
 
return "\n".join(
        f"- {item['memory']}"
        for item in memories
    )

Mem0 ใช้ระบบการค้นหาเชิงความหมาย (semantic search) ทำให้แม้คำค้นหาจะไม่ตรงกันเป๊ะ แต่ถ้าความหมายใกล้เคียงกัน agent ก็จะสามารถดึงข้อมูลที่ถูกต้องออกมาได้

การสร้างเครื่องมือบันทึกหน่วยความจำ

นอกจากค้นหาแล้ว agent ต้องสามารถบันทึกข้อมูลใหม่ๆ ได้ด้วยผ่านเครื่องมือ save_memory เพื่อจัดเก็บข้อเท็จจริงหรือการตั้งค่าสำคัญลงในระบบ

@function_tool
def save_memory(content: str) -> str:
    """Save useful long-term information about the user."""
 
memory.add(
        messages=[
            {
                "role": "user",
                "content": content,
            }
        ],
        user_id=USER_ID,
    )
 
return "Memory saved."

ระบบของ Mem0 จะช่วยคัดกรองและบันทึกเฉพาะส่วนที่เป็นประโยชน์แทนที่จะบันทึกการสนทนาทั้งหมดแบบไร้ระเบียบ

การประกอบร่าง Agent

เมื่อมีเครื่องมือครบแล้ว เราจะนำมาเชื่อมต่อกับ agent พร้อมกำหนดคำสั่ง (instructions) ให้ agent ตรวจสอบหน่วยความจำก่อนตอบทุกครั้ง

agent = Agent(
    name="Memory Assistant",
    model="gpt-5.6-luna",
    instructions="""
    You are a personal assistant with long-term memory.
    Always call search_memory before answering, even for general questions.
    When a relevant memory is found, acknowledge it naturally at the start,
    for example: "Oh, I remember you prefer...", then use it.
    Save durable preferences, goals, and facts; confirm each save in one
    sentence. Skip greetings, temporary info, and duplicates.
    """,
    tools=[
        search_memory,
        save_memory,
    ],
)

สุดท้าย สร้างฟังก์ชัน chat() เพื่อเริ่มต้นใช้งาน:

def chat(message):
    result = Runner.run_sync(
        agent,
        message,
    )
 
return result.final_output

การทดสอบประสิทธิภาพ

ลองทดสอบส่งข้อมูลเพื่อให้ agent บันทึกความจำ:

print(chat(
    "Remember that I prefer Python and use uv "
    "for managing my projects."
))

เมื่อเราลองถามคำถามในเวลาต่อมา แม้จะคนละเซสชัน:

print(chat(
    "How should I set up my next Python project?"
))

Agent จะสามารถดึงข้อมูลเดิมมาตอบได้อย่างแม่นยำว่าคุณชอบใช้ uv ในการจัดการโปรเจกต์ ซึ่งข้อมูลนี้จะยังคงอยู่แม้ว่าคุณจะปิดและเปิดโปรแกรมใหม่ก็ตาม

การเพิ่มหน่วยความจำให้ OpenCode ผ่าน MCP

สำหรับเครื่องมือเขียนโค้ดอย่าง OpenCode คุณสามารถเพิ่มหน่วยความจำได้ทันทีผ่านเซิร์ฟเวอร์ Model Context Protocol (MCP) ของ Mem0 โดยใช้คำสั่งดังนี้:

npx mcp-add \
  --name mem0-mcp \
  --type http \
  --url "https://mcp.mem0.ai/mcp" \
  --clients "opencode"

เมื่อรีสตาร์ท OpenCode ระบบจะสามารถเข้าถึงเครื่องมือจัดการหน่วยความจำ เช่น add_memory หรือ search_memories ได้ทันที ทำให้การทำงานในโปรเจกต์ถัดไปเป็นไปอย่างราบรื่นโดยไม่ต้องเริ่มอธิบายใหม่

ข้อคิดส่งท้าย

ฟีเจอร์หน่วยความจำคือสิ่งที่ทำให้ ChatGPT โดดเด่น เพราะมันทำให้เรารู้สึกว่า AI เข้าใจความต้องการของเราจริงๆ โดยไม่ต้องพูดซ้ำ

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

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