สร้าง AI Agents ที่ไม่มีวันลืม

การเดินทางจากหลักการแรกผ่านหน่วยความจำของเอเจนต์: จากลิสต์ Python ไปจนถึงไฟล์ Markdown, การค้นหาแบบเวกเตอร์, และไฮบริดกราฟ-เวกเตอร์ และสุดท้ายคือโซลูชันโอเพนซอร์สที่สะอาดสำหรับทุกสิ่งนี้

LLM ถูกออกแบบให้ไม่มีสถานะ ทุกการเรียก API เริ่มต้นใหม่ "หน่วยความจำ" ที่คุณรู้สึกเมื่อแชทกับ ChatGPT เป็นภาพลวงตาที่เกิดจากการส่งประวัติการสนทนาทั้งหมดซ้ำในทุกคำขอ

เคล็ดลับนั้นใช้ได้กับการแชททั่วไป แต่มันพังทลายทันทีที่คุณพยายามสร้างเอเจนต์จริง

นี่คือ 7 โหมดความล้มเหลวที่เกิดขึ้นทันทีที่คุณข้ามหน่วยความจำ:

1. การหลงลืมบริบท: เอเจนต์ถามข้อมูลที่คุณให้ไปแล้ว
2. ไม่มีการปรับเปลี่ยนเฉพาะบุคคล: ทุกการโต้ตอบดูเหมือนทั่วไป
3. ความล้มเหลวของงานหลายขั้นตอน: สถานะกลางหายไปอย่างเงียบ ๆ ระหว่างทำงาน
4. ข้อผิดพลาดซ้ำซาก: ไม่มีการจดจำเหตุการณ์ครั้งก่อน ทำให้เกิดข้อผิดพลาดเดิมซ้ำไปซ้ำมา
5. ไม่มีการสะสมความรู้: ทุกเซสชันเริ่มจากศูนย์
6. ภาพหลอนจากช่องว่าง: เมื่อบริบตล้น โมเดลจะสร้างข้อมูลขึ้นมาเอง
7. การล่มสลายของตัวตน: ไม่มีความต่อเนื่อง ไม่มีความน่าเชื่อถือ

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

แต่มันไม่ใช่

ความแม่นยำลดลงมากกว่า 30% เมื่อข้อมูลที่เกี่ยวข้องอยู่ตรงกลางบริบทที่ยาว นี่คือผล "หลงทางตรงกลาง" ที่ได้รับการบันทึกไว้อย่างดี

บริบทเป็นงบประมาณที่ใช้ร่วมกัน: พรอมต์ระบบ, เอกสารที่ดึงมา, ประวัติการสนทนา และผลลัพธ์ ทั้งหมดแข่งขันกันเพื่อโทเค็นเดียวกัน

แม้ที่ 100K โทเค็น การไม่มีทั้งความคงทน การจัดลำดับความสำคัญ และความโดดเด่น ทำให้ความยาวบริบทดิบไม่เพียงพอ

หน่วยความจำไม่ใช่การยัดข้อความลงในพรอมต์ แต่มันเกี่ยวกับการจัดโครงสร้างสิ่งที่เอเจนต์จำได้ เพื่อให้มันสามารถหาสิ่งที่สำคัญได้

กรอบแนวคิดวิทยาศาสตร์การรู้คิดที่ช่วยได้จริง

สูตรของ Lilian Weng ในปี 2023 ได้กลายเป็นกรอบแนวคิดเริ่มต้น:

เอเจนต์ = LLM + หน่วยความจำ + การวางแผน + การใช้เครื่องมือ

สี่เสาหลักที่เท่าเทียมกัน

อนุกรมวิธานของเธอยืมมาจากวิทยาศาสตร์การรู้คิด ซึ่งหน่วยความจำของมนุษย์แบ่งออกเป็นสามระบบ:

• หน่วยความจำประสาทสัมผัส จับข้อมูลนำเข้าดิบจากการรับรู้และเก็บไว้เพียงเสี้ยววินาที เฉพาะส่วนที่คุณใส่ใจเท่านั้นที่จะถูกส่งผ่านต่อไป
• หน่วยความจำทำงาน คือที่ที่การคิดเชิงรุกเกิดขึ้น มันจุได้ประมาณ 7±2 รายการในแต่ละครั้ง (การค้นพบของ Miller ในปี 1956) ถ้าคุณเสียสมาธิ เนื้อหาจะหายไป
• หน่วยความจำระยะยาว คือการจัดเก็บที่ทนทานโดยไม่มีขีดจำกัดความจุเชิงปฏิบัติ การดึงคืนเป็นคอขวด: คุณสามารถเก็บสิ่งนับล้านและยังล้มเหลวในการจำสิ่งที่คุณต้องการ

แต่ละอย่างจับคู่โดยตรงกับส่วนประกอบในสถาปัตยกรรมเอเจนต์สมัยใหม่:

หน่วยความจำระยะยาวยังแบ่งย่อยเพิ่มเติม:

• เหตุการณ์ครั้งก่อน: เหตุการณ์เฉพาะในอดีต ("เมื่อวันอังคาร คลัสเตอร์ PostgreSQL ล่ม")
• ความหมาย: ข้อเท็จจริงและแนวคิด ("PostgreSQL เป็นฐานข้อมูลเชิงสัมพันธ์")
• ขั้นตอน: ทักษะและเวิร์กโฟลว์ ("เมื่อผู้ใช้ขอเงินคืน ให้ตรวจสอบวันที่ซื้อก่อน")

สะพานเชื่อมระหว่างเหตุการณ์ครั้งก่อนและความหมายคือ การรวมหน่วยความจำ: เหตุการณ์เฉพาะที่เกิดขึ้นซ้ำ ๆ ถูกกลั่นเป็นความรู้ทั่วไป เอเจนต์ที่สังเกตเห็น "ผู้ใช้มักชอบบทสรุปผู้บริหาร" จากการโต้ตอบหลายสิบครั้ง ควรเปลี่ยนสิ่งนั้นเป็นกฎที่ใช้ซ้ำได้ หากไม่มีการรวมหน่วยความจำ เอเจนต์ของคุณจะเล่นซ้ำเหตุการณ์แต่ละอย่างแทนที่จะเรียนรู้จากมัน

เอเจนต์ขั้นต่ำ และสิ่งที่พังก่อน

ถอดกรอบแนวคิดออก เอเจนต์คือลูป: รับรู้ คิด ลงมือ

1class Agent:
2    """เอเจนต์ AI ขั้นต่ำ: รับรู้ คิด ลงมือ"""
3    def __init__(self):
4        self.client = anthropic.Anthropic()
5        self.model = "claude-sonnet-4-20250514"
6
7    def run(self, user_input: str) -> str:
8        response = self.client.messages.create(
9            model=self.model,
10            max_tokens=1024,
11            messages=[{"role": "user", "content": user_input}],
12        )
13        return response.content[0].text

บอกมันว่า "ฉันมีแอปเปิ้ล 4 ลูก" แล้วถาม "ฉันกินไปหนึ่งลูก เหลือกี่ลูก?" แล้วมันไม่รู้ว่าคุณกำลังพูดถึงแอปเปิ้ลอะไร ทุกการเรียกแยกกันอยู่โดยอิสระ

เลเยอร์ 1: ลิสต์ Python

การแก้ไขครั้งแรกที่ทุกคนทำ:

1class Agent:
2    def __init__(self):
3        self.client = anthropic.Anthropic()
4        self.messages = []  # "หน่วยความจำ" ทั้งหมดเป็นแค่ลิสต์
5
6    def chat(self, user_input: str) -> str:
7        self.messages.append({"role": "user", "content": user_input})
8        response = self.client.messages.create(
9            model="claude-sonnet-4-20250514",
10            max_tokens=1024,
11            messages=self.messages,  # ส่งประวัติทั้งหมดทุกครั้ง
12        )
13        reply = response.content[0].text
14        self.messages.append({"role": "assistant", "content": reply})
15        return reply

การสนทนาหลายรอบทำงานตอนนี้ คำถามเกี่ยวกับแอปเปิ้ลได้รับคำตอบถูกต้องเพราะการสนทนาทั้งหมดถูกส่งซ้ำทุกครั้ง

ปัญหาสองอย่างปรากฏขึ้นเร็ว ๆ นี้:

• ลิสต์เติบโตไร้ขอบเขต ประมาณรอบที่ 200 คุณจะถึงเพดานบริบท และข้อความที่เก่าที่สุดจะถูกทิ้งอย่างเงียบ ๆ ชื่อผู้ใช้จากรอบที่ 1 หายไปนานก่อนมุขตลกเมื่อวาน ไม่มีการจัดลำดับความสำคัญ มีแค่ลำดับเวลาที่เคร่งครัด
• ทุกอย่างอยู่ใน RAM ทันทีที่โปรเซส Python สิ้นสุด เอเจนต์ของคุณไม่รู้ว่าคุณเป็นใคร

เลเยอร์ 2: ไฟล์ Markdown เพื่อความคงทน

ขั้นตอนต่อไปคือการเขียนหน่วยความจำลงดิสก์ Markdown เหมาะสม: อ่านได้โดยมนุษย์, เข้ากันได้กับ Git, และเอเจนต์สามารถอ่านกลับมาเป็นข้อความธรรมดาได้ Claude Code ใช้รูปแบบนี้กับไฟล์ CLAUDE.md และ MEMORY.md

1class MarkdownMemoryAgent:
2    def __init__(self):
3        self.client = anthropic.Anthropic()
4        self.history_file = Path("memory/conversation_history.md")
5        self.facts_file = Path("memory/known_facts.md")
6
7    def save_to_disk(self, role: str, content: str) -> None:
8        with open(self.history_file, "a") as f:
9            f.write(f"### {role} at {datetime.now().isoformat()}\n{content}\n\n")
10
11    def load_history(self) -> str:
12        if self.history_file.exists():
13            return self.history_file.read_text()
14        return ""
15
16    def chat(self, user_input: str) -> str:
17        self.save_to_disk("user", user_input)
18        history = self.load_history()
19        response = self.client.messages.create(
20            model="claude-sonnet-4-20250514",
21            max_tokens=1024,
22            system=f"การสนทนาก่อนหน้านี้:\n{history}",
23            messages=[{"role": "user", "content": user_input}],
24        )
25        reply = response.content[0].text
26        self.save_to_disk("assistant", reply)
27        return reply

ความคงทนได้รับการแก้ไขแล้ว รีสตาร์ทสคริปต์ และการสนทนายังคงอยู่บนดิสก์ คุณยังสามารถรักษาไฟล์ข้อเท็จจริงแยกต่างหากที่เอเจนต์ดึงข้อมูลเมื่อเวลาผ่านไป:

1- ชื่อผู้ใช้คือ Sarah
2- Sarah จัดการทีมแบ็คเอนด์ที่ Acme Corp
3- Acme Corp เป็นบริษัท B2B SaaS
4- ปัจจุบันกำลังย้ายฐานข้อมูลผลิตไปยังภูมิภาค AWS ใหม่

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

ด้วยข้อเท็จจริง 4 ข้อ งานนี้สมบูรณ์แบบ โหลดไฟล์ทั้งหมดลงในบริบท และ LLM จัดการคำถามใด ๆ เกี่ยวกับ Sarah บริษัท หรืออุตสาหกรรมของเธอ

ตอนนี้เร่งเวลาสามเดือน เอเจนต์ของคุณมีข้อเท็จจริงที่สกัดได้ 2,000 ข้อและบันทึกการสนทนา 200 รายการ นั่นคือโทเค็น Markdown 500K+ บนดิสก์ และหน้าต่างบริบทของคุณคือ 128K

คุณไม่สามารถโหลดทุกอย่างได้อีกต่อไป คุณต้องดึงเฉพาะข้อเท็จจริงที่เกี่ยวข้องกับคำถามปัจจุบันเท่านั้น ด้วยไฟล์แบน ตัวเลือกเดียวของคุณคือการค้นหาด้วยคำสำคัญ:

1# ผู้ใช้ถาม: "สถานะการย้ายคลาวด์ของเราเป็นอย่างไร?"
2grep("cloud migration", facts_file)
3# คืนค่า: []
4# ข้อเท็จจริงบนดิสก์บอกว่า "กำลังย้ายฐานข้อมูลผลิตไปยังภูมิภาค AWS ใหม่"
5# คำว่า "cloud migration" ไม่ปรากฏเลย
6
7# ผู้ใช้ถาม: "ทีมไหนจัดการงานฐานข้อมูล?"
8grep("database team", facts_file)
9# คืนค่า: []
10# ข้อเท็จจริงหนึ่งบอกว่า Sarah "จัดการทีมแบ็คเอนด์" อีกข้อบอกว่าทีม
11# "กำลังย้ายฐานข้อมูลผลิต" แต่ไม่มีบรรทัดเดียวที่มีทั้ง "ฐานข้อมูล" และ "ทีม" รวมกัน

ในขนาดเล็ก ไฟล์ Markdown ใช้งานได้ ในขนาดจริง มันบังคับให้ค้นหาด้วยคำสำคัญ และคำสำคัญไม่สามารถจัดการกับคำพ้องความหมาย การถอดความ หรือการเชื่อมต่อข้ามข้อเท็จจริงได้

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

ถ้าคุณใช้ OpenClaw คุณจะเห็นสิ่งนี้เกิดขึ้น มันเก็บหน่วยความจำเป็นไฟล์ Markdown checkpoint และเมื่อใช้งานทุกวันเป็นเวลาหลายสัปดาห์ ข้อเท็จจริงก่อนหน้านี้จะค่อย ๆ หายไปเมื่อบริบทสะสมและถูกบีบอัด การจัดเก็บมีอยู่ การดึงคืนไม่มี

การจัดเก็บโดยไม่มีการดึงคืนอย่างชาญฉลาดคือห้องสมุดที่ไม่มีแคตตาล็อก

เลเยอร์ 3: การค้นหาแบบเวกเตอร์และกำแพงที่มันชน

เพิ่ม embeddings แบ่ง Markdown ของคุณฝังชิ้นส่วน ค้นหาโดยความคล้ายคลึงโคไซน์ ตอนนี้ "ฐานข้อมูล" ตรงกับ "PostgreSQL" เพราะเวกเตอร์ของพวกมันอยู่ใกล้กันในสเปซ embedding ปัญหาคำพ้องความหมายหายไป

แล้วคุณก็ชนกำแพงใหม่ พิจารณาข้อเท็จจริงสามข้อนี้ในฐานข้อมูลเวกเตอร์ของคุณ:

1- "Alice เป็นหัวหน้าทีมเทคนิคของ Project Atlas"
2- "Project Atlas ใช้ PostgreSQL เป็นที่เก็บข้อมูลหลัก"
3- "คลัสเตอร์ PostgreSQL ประสบปัญหาขัดข้องเมื่อวันอังคาร"

ผู้ใช้ถาม: "โปรเจกต์ของ Alice ได้รับผลกระทบจากการขัดข้องเมื่อวันอังคารหรือไม่?"

คำถามพูดถึง Alice และการขัดข้องเมื่อวันอังคาร ดังนั้นการค้นหาเวกเตอร์จึงจัดอันดับข้อเท็จจริงที่หนึ่งและสามสูง แต่สะพานสำคัญ "Project Atlas ใช้ PostgreSQL" ไม่ได้พูดถึง Alice หรือวันอังคารเลย มันเป็นชิ้นส่วนที่เชื่อมต่อ และเป็นชิ้นส่วนที่จะไม่โผล่ขึ้นมา

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

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

เมทริกซ์ความสามารถ

แต่ละเลเยอร์แก้ไขปัญหาก่อนหน้าแต่เผยให้เห็นปัญหาที่ลึกกว่า:

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

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

ฉันใช้โซลูชันที่เติมเต็มช่องว่างนี้อย่างสะอาด มันเป็นโอเพนซอร์สเต็มรูปแบบ จัดการกระบวนทัศน์การจัดเก็บทั้งสามภายใต้หลังคาเดียวกัน และคุณสามารถเริ่มต้นใช้งานได้ในไม่กี่นาที มาพูดถึง Cognee กันดีกว่า

Cognee: สามที่เก็บ หนึ่งเอนจิน สี่การเรียก

Cognee เป็นเอนจินความรู้โอเพนซอร์สที่สร้างขึ้นสำหรับหน่วยความจำเอเจนต์ มันรวมการค้นหาเวกเตอร์เข้ากับกราฟความรู้และเลเยอร์ที่มาของข้อมูลเชิงสัมพันธ์เป็นระบบเดียว

พื้นผิว API ทั้งหมดคือการเรียกแบบ async สี่ครั้ง:

1import cognee
2
3await cognee.add("เอกสารของคุณที่นี่")   # รับอะไรก็ได้
4await cognee.cognify()                    # สร้างกราฟความรู้ + embeddings
5await cognee.memify()                     # ปรับปรุงหน่วยความจำด้วยตนเอง
6await cognee.search("คำค้นหาของคุณ")      # ดึงคืนพร้อมการให้เหตุผล

เบื้องหลังการเรียกสี่ครั้งนั้นคือสถาปัตยกรรมสามที่เก็บ

ทำไมต้องสามที่เก็บไม่ใช่ที่เดียว?

แต่ละที่เก็บจับมิติของความรู้ที่ที่เก็บอื่นไม่สามารถทำได้:

• ที่เก็บเชิงสัมพันธ์ → ที่มา: ข้อมูลมาจากไหน, เมื่อไหร่ที่รับเข้า, ใครมีสิทธิ์เข้าถึง
• ที่เก็บเวกเตอร์ → ความหมาย: เนื้อหาหมายถึงอะไร, คล้ายกับอะไร
• ที่เก็บกราฟ → ความสัมพันธ์: เอนทิตีเชื่อมต่อกันอย่างไร, อะไรทำให้เกิดอะไร, ใครรายงานให้ใคร

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

สแตกเริ่มต้นคือ SQLite + LanceDB + Kuzu ซึ่งฝังตัวและใช้ไฟล์ทั้งหมด pip install cognee บวกคีย์ API ของ LLM แล้วคุณก็พร้อมทำงาน

ไม่ต้องใช้ Docker ไม่ต้องใช้บริการภายนอก

สำหรับการผลิต สลับ SQLite เป็น Postgres, LanceDB เป็น Qdrant/Pinecone/pgvector และ Kuzu เป็น Neo4j/FalkorDB/Neptune

API สี่การเรียกเดียวกันไม่ว่าจะเป็นแบบไหนก็ตาม

cognify ทำอะไรจริง ๆ?

cognee.cognify() รันไปป์ไลน์หลายขั้นตอนที่แปลงข้อความดิบเป็นความรู้ที่มีโครงสร้างและเชื่อมต่อกัน:

1. การจำแนกเอกสาร ตามประเภทและโดเมน
2. การตรวจสอบสิทธิ์ สำหรับการควบคุมการเข้าถึงแบบหลายผู้เช่า
3. การแยกชิ้นส่วน ที่เคารพโครงสร้างย่อหน้า (ไม่ใช่การตัดขนาดคงที่)
4. การแยกเอนทิตีและความสัมพันธ์ ผ่าน LLM พร้อมการห้ำซ้ำอัตโนมัติผ่านการแฮชเนื้อหา
5. การสร้างสรุป เพื่อการดึงคืนที่มีประสิทธิภาพ
6. การจัดทำดัชนีคู่ ไปยังที่เก็บเวกเตอร์ (embeddings) และที่เก็บกราฟ (ขอบ)

ขั้นตอนการห้ำซ้ำสำคัญกว่าที่คิด ถ้าเอนทิตีเดียวกันปรากฏในเอกสาร 50 ฉบับ Cognee จะรวมมันเป็นโหนดกราฟเดียวที่มีขอบขาเข้า 50 เส้น เอเจนต์ของคุณจะไม่เห็น "Alice" เป็นคนแปลกหน้า 50 คนอีกต่อไป และไปป์ไลน์เป็นแบบเพิ่มขึ้นตามค่าเริ่มต้น: เฉพาะไฟล์ใหม่หรือที่แก้ไขเท่านั้นที่ถูกประมวลผลใหม่

ทุกโหนดกราฟมี embedding ที่สอดคล้องกัน การแสดงคู่นี้เป็นเคล็ดลับหลัก: เข้าผ่านเวกเตอร์ (ค้นหาเนื้อหาที่คล้ายคลึงทางความหมาย) และออกผ่านกราฟ (ตามความสัมพันธ์ไปยังเอนทิตีที่เชื่อมต่อ) หรือกลับกัน นั่นคือสิ่งที่ทำให้การค้นหาแบบหลายฮอปทำงานได้โดยไม่เสียสละการค้นหาเชิงความหมาย

Memify: หน่วยความจำที่เรียนรู้

memify() คือสิ่งที่แยก Cognee ออกจากเครื่องมือ "รับเข้าและค้นหา" ทุกตัว มันรันการปรับให้เหมาะสมแบบ RL ที่ได้รับแรงบันดาลใจบนกราฟ:

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

กราฟของเอเจนต์สนับสนุนลูกค้าจะเสริมเส้นทางผ่านเอกสารผลิตภัณฑ์และนโยบายการคืนเงินโดยธรรมชาติ ในขณะที่ปล่อยให้ขอบ HR ที่ไม่ค่อยถูกค้นหาค่อย ๆ จางหายไป กราฟพัฒนาความรู้สึกของความเกี่ยวข้องของมันเองเมื่อเวลาผ่านไป

สิบสี่โหมดการดึงคืน

Cognee มาพร้อมกับโหมดการค้นหา 14 โหมด โหมดที่คุณจะใช้จริง ๆ :

การสร้างเอเจนต์จริงด้วยหน่วยความจำ Cognee

นี่คือรูปแบบที่สมบูรณ์ในการเชื่อมต่อ Cognee เข้ากับลูปรับรู้-คิด-ลงมือ:

1import cognee
2from cognee import SearchType
3
4class CogneeMemoryAgent:
5    """เอเจนต์ที่มีหน่วยความจำถาวรแบบไฮบริดกราฟ-เวกเตอร์"""
6
7    def __init__(self, session_id: str = "default"):
8        self.llm_client = OpenAI()
9        self.session_id = session_id
10
11    async def ingest(self, text: str, dataset: str = "main"):
12        await cognee.add(text, dataset)
13        await cognee.cognify([dataset])
14
15    async def recall(self, query: str) -> str:
16        results = await cognee.search(
17            query_text=query,
18            query_type=SearchType.GRAPH_COMPLETION,
19            session_id=self.session_id,
20        )
21        return results[0] if results else ""
22
23    async def chat(self, user_input: str) -> str:
24        context = await self.recall(user_input)
25        messages = [
26            {"role": "system", "content": "คุณเป็นผู้ช่วยที่มีประโยชน์ ใช้บริบทหน่วยความจำ"},
27            {"role": "system", "content": f"บริบทหน่วยความจำ:\n{context}"},
28            {"role": "user", "content": user_input},
29        ]
30        response = self.llm_client.chat.completions.create(
31            model="gpt-4o-mini", messages=messages
32        )
33        reply = response.choices[0].message.content
34        await cognee.add(
35            f"ผู้ใช้: {user_input}\nผู้ช่วย: {reply}",
36            "conversations"
37        )
38        await cognee.cognify(["conversations"])
39        return reply

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

หน่วยความจำเซสชันจัดการการแก้ไขคำสรรพนามโดยอัตโนมัติ:

1await cognee.search(query_text="Alice อยู่ที่ไหน?", session_id="conv_1")
2await cognee.search(query_text="เธอทำงานอะไร?", session_id="conv_1")
3# "เธอ" แก้ไขเป็น Alice จากบริบทเซสชัน

ความสามารถหลายผู้เช่าถูกสร้างไว้ในระดับกราฟด้วยสิทธิ์ต่อชุดข้อมูล (อ่าน, เขียน, ลบ, แชร์) ไม่ใช่การแยกเนมสเปซ แต่เป็นการแยกระดับกราฟจริง

เส้นทางที่ปฏิบัติได้จริงต่อจากนี้

ถ้าคุณกำลังสร้างเอเจนต์วันนี้ คำถามเริ่มต้นที่แท้จริงคือ: "เอเจนต์ของฉันต้องจำอะไร และมันจะตอบคำถามประเภทไหน?"

ถ้าคำถามของคุณต้องการแค่การค้นหาความคล้ายคลึง ("หาการสนทนาแบบนี้") หน่วยความจำแบบเวกเตอร์อย่างเดียวก็ใช้ได้ ช่วงเวลาที่คำถามข้ามขอบเขตเอนทิตี ("โปรเจกต์ของ Alice ได้รับผลกระทบจากการขัดข้องเมื่อวันอังคารหรือไม่?") คุณต้องใช้การเดินกราฟ

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

Cognee ลดสิ่งนั้นเหลือสี่การเรียก API ค่าเริ่มต้นแบบฝังทำให้คุณเริ่มต้นได้ในไม่กี่นาที แบ็คเอนด์ที่สลับได้ (Postgres, Qdrant, Neo4j) พาคุณไปสู่การผลิตโดยไม่ต้องเปลี่ยนโค้ดเอเจนต์ของคุณ

ความฉลาดต้องการโครงสร้าง ไม่ใช่แค่การจัดเก็บ กระบวนทัศน์การจัดเก็บทั้งสาม (เชิงสัมพันธ์ เวกเตอร์ กราฟ) ไม่ใช่ตัวเลือกที่แข่งขันกัน พวกมันเป็นเลเยอร์เสริมของระบบหน่วยความจำเดียวกัน การปฏิบัติต่อพวกมันแบบนั้นคือสิ่งที่เปลี่ยน wrapper LLM ที่ไม่มีสถานะให้กลายเป็นสิ่งที่เรียนรู้ได้จริง

สิ่งต่อไปที่คุณอยากให้เอเจนต์ของคุณจำได้ในวันพรุ่งนี้ที่มันลืมไปวันนี้คืออะไร? เริ่มตรงนั้น

👉 ไปดู Cognee บน GitHub →, ให้ดาวมัน และลองต่อเข้ากับเอเจนต์ตัวต่อไปของคุณ

การเรียกแบบ async สี่ครั้ง, คำสั่ง pip install, แล้วคุณก็พร้อมทำงาน

นั่นคือทั้งหมด!

ถ้าคุณสนุกกับการอ่านสิ่งนี้:

ตามฉันมา →@akshay_pachaar ✔️

ทุกวัน ฉันแชร์บทเรียนและข้อมูลเชิงลึกเกี่ยวกับ AI, Machine Learning และแนวทางปฏิบัติที่ดีที่สุดในการเขียนโค้ดแบบ vibe coding