วิธีติดตั้ง Memmy ระบบหน่วยความจำส่วนกลางสำหรับ AI Agent

Memmy คืออะไรและจัดเก็บข้อมูลอะไรบ้าง

Memmy คือศูนย์กลางหน่วยความจำภายในสำหรับ AI agent ซึ่งทำงานบน VPS (virtual private server) ของคุณเอง โดยจะเก็บฐานข้อมูล SQLite ไว้หนึ่งชุดสำหรับสิ่งที่ agent ของคุณได้เรียนรู้ และ agent ทุกตัวบนเซิร์ฟเวอร์จะอ่านและเขียนลงในแหล่งเก็บข้อมูลเดียวกันนี้ โครงการนี้เป็น memmy-agent จาก MemTensor ภายใต้สัญญาอนุญาต MIT โดยเป็นเวอร์ชัน 1.0.4 ณ เดือนกรกฎาคม 2026

มีเพียงบางส่วนเท่านั้นที่จำเป็นต้องใช้บนเซิร์ฟเวอร์ Memmy มาพร้อมกับบริการหน่วยความจำที่คอยรับการเชื่อมต่อที่ http://127.0.0.1:18960, อินเทอร์เฟซบรรทัดคำสั่ง (CLI) แบบ memmy-memory ที่สื่อสารกับบริการดังกล่าว และเวิร์กเบนช์สำหรับเดสก์ท็อป เนื่องจากเวิร์กเบนช์ถูกจัดทำแพ็กเกจสำหรับ macOS และ Windows เท่านั้น บน Linux VPS คุณจึงใช้งานเพียงบริการและ CLI ก็เพียงพอแล้ว ซึ่งเพียงพอที่จะทำให้ Claude Code, Codex และ Cursor มีหน่วยความจำร่วมกัน

Memmy จัดหมวดหมู่ข้อมูลที่จัดเก็บออกเป็นสี่ชั้น ได้แก่ L1 Trace คือข้อมูลการโต้ตอบดิบ ประกอบด้วยคำขอ การตอบกลับ และการเรียกใช้เครื่องมือ L2 Policy คือขั้นตอนที่สรุปมาจาก Trace ซึ่งพิสูจน์แล้วว่ามีประโยชน์ L3 World Model คือความรู้ที่เสถียรเกี่ยวกับโครงการหรือสภาพแวดล้อม ส่วน Skill คือขั้นตอนที่เรียกใช้งานได้ซึ่งตกผลึกมาจาก Policy บริการจะกำหนดชั้นข้อมูลให้โดยอัตโนมัติเมื่อมีการนำเข้าข้อมูลการโต้ตอบ ดังนั้นคุณจึงไม่จำเป็นต้องสร้างชั้นข้อมูลเหล่านี้ด้วยตนเอง

การเปลี่ยนแปลงเมื่อใช้ฮับหน่วยความจำส่วนกลางเทียบกับการเก็บหน่วยความจำแยกตามเครื่องมือ

ในปัจจุบัน เอเจนต์แต่ละตัวจะจัดเก็บหน่วยความจำของตนเอง Claude Code เก็บไฟล์คำสั่งไว้ในที่เก็บข้อมูล (repository) Cursor เก็บกฎต่างๆ ไว้ในฐานข้อมูลของเวิร์กสเปซ และ Codex เก็บประวัติเซสชันไว้ภายใต้ ~/.codex เนื่องจากที่เก็บข้อมูลแต่ละแห่งเป็นของเครื่องมือเพียงตัวเดียว ข้อมูลที่คุณสอนไว้ในเครื่องมือหนึ่งเมื่อวันจันทร์จึงไม่ถูกรับรู้โดยเครื่องมืออื่นในวันอังคาร คุณต้องจ่ายต้นทุนในส่วนนี้สองต่อ: ต่อแรกคือการสิ้นเปลืองโทเค็นเพื่ออธิบายโปรเจกต์เดิมซ้ำ และต่อที่สองคือความผิดพลาดในการทำงานเมื่อเอเจนต์ตัดสินใจโดยอิงจากสมมติฐานที่คุณเคยแก้ไขไปแล้วในที่อื่น

ฮับหน่วยความจำจะย้ายที่เก็บข้อมูลออกมาจากตัวเครื่องมือ Memmy สามารถอ่านที่เก็บข้อมูลเดิมที่มีอยู่ได้ ดังนั้นคุณจึงไม่ต้องเริ่มต้นจากฐานข้อมูลเปล่า ตัวสแกนของ Memmy รองรับแหล่งข้อมูล 6 แห่ง ได้แก่ Claude Code ที่ ~/.claude/projects/**/*.jsonl, Codex ที่ ~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-*.jsonl, OpenCode ที่ ~/.local/share/opencode/opencode.db, ไฟล์ state.vscdb ของ Cursor, ฐานข้อมูล SQLite ของ OpenClaw ภายใต้ ~/.openclaw และ Hermes ภายใต้ ~/.hermes คุณสามารถเพิ่มแหล่งข้อมูลด้วยตนเองโดยระบุชื่อและพาธในเครื่องได้

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

นี่คือส่วนประกอบที่ทำงานร่วมกับ วิธีการที่ Claude Code จัดการบริบทภายในเซสชันเดียว การจัดการบริบทจะเป็นตัวกำหนดว่าข้อมูลใดเหมาะสมที่จะอยู่ในหน้าต่างการสนทนาเดียว ส่วนฮับหน่วยความจำจะเป็นตัวกำหนดว่าข้อมูลใดจะยังคงอยู่หลังจากหน้าต่างนั้นปิดลง

สิ่งที่คุณต้องมีบน VPS

• Node.js เวอร์ชัน 22 หรือใหม่กว่า เอกสารของ Memmy จำเป็นต้องใช้เวอร์ชันนี้ ในขณะที่ Ubuntu 24.04 มาพร้อมกับ Node 18
• git และชุดเครื่องมือสำหรับ build เนื่องจาก better-sqlite3 เป็นโมดูลแบบ native ซึ่งอาจต้องมีการคอมไพล์ระหว่างการติดตั้ง
• RAM ประมาณ 2 GB การติดตั้งในระดับ root จะดึง workspace ขนาดใหญ่และชุดเครื่องมือสำหรับ build ส่วน frontend มาด้วย
• พื้นที่ว่างบนดิสก์อีกสองสาม GB สำหรับ node_modules และฐานข้อมูล

sudo apt update
sudo apt install -y git build-essential python3 curl ca-certificates sqlite3
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt install -y nodejs
node --version

node --version ควรแสดงผลเป็น v22 หรือสูงกว่า หากพบ v18 ในขั้นตอนนี้ แสดงว่าขั้นตอนของ NodeSource ไม่ทำงาน และการติดตั้งจะล้มเหลวในภายหลังเมื่อระบบตรวจสอบ engine ของโปรเจกต์

การติดตั้ง Memmy จากซอร์สโค้ดบน Ubuntu 24.04

git clone https://github.com/MemTensor/memmy-agent.git
cd memmy-agent
cp .env.example .env
npm install
npm run memory:build

npm run memory:build จะคอมไพล์เวิร์กสเปซ @memmy/memory ไปยัง Memory/dist สำหรับเซิร์ฟเวอร์แบบ headless ไม่จำเป็นต้องสร้างส่วนอื่นในทรีเพิ่มเติม ตรวจสอบว่าโมดูลเนทีฟถูกโหลดแล้ว:

node -e "require('better-sqlite3'); console.log('better-sqlite3 loads')"

หากบรรทัดดังกล่าวแสดงข้อผิดพลาดแทนที่จะแสดงผลลัพธ์ แสดงว่าโมดูลเนทีฟไม่ตรงกับเวอร์ชันของ Node ที่คุณใช้งาน ให้รัน npm rebuild better-sqlite3 ซึ่งเป็นคำสั่งเดียวกับที่สคริปต์เริ่มต้นของโปรเจกต์ใช้ก่อนที่จะเริ่มการทำงานใดๆ

ไฟล์ README ระบุว่า bash scripts/dev-start.sh เป็นคำสั่งสำหรับการเริ่มต้นการทำงานในคำสั่งเดียว ห้ามรันคำสั่งนี้บน VPS แบบ headless เนื่องจากคำสั่งดังกล่าวจะเริ่มการทำงานของ Electron desktop shell และ Vite dev server บนพอร์ต 19000 ควบคู่ไปกับบริการ memory และเนื่องจาก Electron ต้องการหน้าจอแสดงผล สคริปต์จึงจะค้างหรือหยุดทำงานบนเซิร์ฟเวอร์ที่ไม่มีเซสชันกราฟิก

เริ่มต้นบริการหน่วยความจำและตรวจสอบการตอบสนอง

npm run memory:serve:dev

นี่คือวิธีการรันบริการหน่วยความจำจากซอร์สโค้ดตามที่ระบุไว้ในเอกสาร โดยบริการจะผูกกับ 127.0.0.1:18960 เก็บฐานข้อมูลไว้ที่ ~/.memmy/memory-service/memory.sqlite และอ่านค่าคอนฟิกจาก ~/.memmy/config.yaml ไฟล์ README ได้ระบุค่าเหล่านี้ไว้เช่นกันในกรณีที่คุณต้องการกำหนดค่าอย่างชัดเจน:

npm run memory:serve:dev -- \
  --host 127.0.0.1 --port 18960 \
  --db ~/.memmy/memory-service/memory.sqlite \
  --config ~/.memmy/config.yaml

จากเชลล์ที่สอง ให้สอบถามบริการว่ายังทำงานอยู่หรือไม่:

curl -sS http://127.0.0.1:18960/api/v1/health

Health เป็น endpoint เดียวที่ไม่ต้องการโทเค็น จึงเป็นจุดตรวจสอบที่เหมาะสมที่สุด หาก curl จบการทำงานด้วยรหัส 7 และข้อความ Failed to connect to 127.0.0.1 port 18960 แสดงว่าไม่มีบริการใดกำลังรอรับการเชื่อมต่ออยู่ ให้ตรวจสอบเทอร์มินัลที่รันบริการนั้น เนื่องจากหากเกิดการขัดข้องขณะเริ่มต้นระบบ ข้อความแจ้งเตือนจะแสดงที่นั่น ซึ่งสาเหตุทั่วไปมักเกิดจากการที่โมดูล SQLite แบบเนทีฟไม่สามารถโหลดได้ ss -lntp | grep 18960 จะยืนยันการมีอยู่ของซ็อกเก็ตเมื่อบริการทำงานแล้ว

ส่วนที่เหลือของ HTTP API (อินเทอร์เฟซการเขียนโปรแกรมแอปพลิเคชัน) จะอยู่ภายใต้ /api/v1

• POST /api/v1/memory/add ใช้สำหรับเขียนหน่วยความจำ และ POST /api/v1/memory/search ใช้สำหรับสืบค้น
• GET /api/v1/memory/:id และ DELETE /api/v1/memory/:id ใช้สำหรับอ่านและลบรายการเดียว
• POST /api/v1/sessions/open และ POST /api/v1/sessions/:sessionId/close ใช้สำหรับจัดการช่วงเวลาของเอเจนต์
• POST /api/v1/turns/start และ POST /api/v1/turns/:turnId/complete ใช้สำหรับบันทึกการโต้ตอบหนึ่งรอบ
• GET /api/v1/panel/overview, /api/v1/panel/analysis และ /api/v1/panel/items ใช้สำหรับส่งข้อมูลไปยังแดชบอร์ด

Memmy จองช่วงพอร์ตไว้หลายพอร์ต และสำหรับการใช้งานแบบ headless คุณจะใช้เพียงพอร์ตแรกเท่านั้น ได้แก่ 18960 สำหรับหน่วยความจำ, 18970 สำหรับสถานะสุขภาพของเกตเวย์, 18980 สำหรับเว็บ UI และ HTTP สำหรับผู้ดูแลระบบ, 18990 สำหรับ API ที่รองรับ OpenAI ซึ่ง memmy serve จะเป็นตัวเริ่มต้น จากนั้นคือ 19000 และ 19010 สำหรับเซิร์ฟเวอร์พัฒนาของเดสก์ท็อปฟรอนต์เอนด์ หากมีบริการอื่นบนเครื่องของคุณใช้งานพอร์ตเหล่านี้อยู่ รายการข้างต้นคือจุดที่คุณควรตรวจสอบ

ที่มาของคำสั่ง memmy-memory

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

node -p "JSON.stringify(require('./Memory/package.json').bin)"

คำสั่งดังกล่าวจะแสดงผล {"memmy-memory":"./dist/src/cli/index.js"} ดังนั้นจุดเริ่มต้น (entry point) ที่ถูกสร้างขึ้นคือ Memory/dist/src/cli/index.js ซึ่งจะมีอยู่จริงหลังจากรัน npm run memory:build เท่านั้น เนื่องจากกระบวนการ build คือสิ่งที่สร้าง dist และกำหนดให้ไฟล์ดังกล่าวสามารถเรียกใช้งานได้ (executable) ให้รันคำสั่งโดยตรงดังนี้:

node Memory/dist/src/cli/index.js health

หากคุณต้องการใช้ชื่อย่อใน PATH ของคุณ ให้สร้างลิงก์ไปยังไฟล์เดียวกันนี้:

sudo ln -s "$PWD/Memory/dist/src/cli/index.js" /usr/local/bin/memmy-memory
memmy-memory health

CLI จะใช้ค่าเริ่มต้นเป็น http://127.0.0.1:18960 และรองรับ --url, --token, --config, --source และ --user-id คำสั่งย่อยของมันประกอบด้วย init, health, search, add, get และ delete รวมถึงการเรียกใช้งาน session และ turn ซึ่งเอเจนต์เป็นผู้ใช้งานแทนมนุษย์ โดย memmy-memory search "deploy steps" และ memmy-memory add "staging migrates on deploy" คือสองคำสั่งที่เอเจนต์เรียกใช้งานบ่อยที่สุด

วิธีเชื่อมต่อ Claude Code เข้ากับ Memmy

Claude Code ไม่มีอินเทอร์เฟซสำหรับปลั๊กอินหน่วยความจำ ดังนั้น Memmy จึงไม่ได้เชื่อมต่อโดยตรงกับตัวโปรแกรม การทำงานร่วมกันนั้นเรียบง่ายกว่านั้น Claude Code จะรัน memmy-memory ในฐานะคำสั่งเชลล์ทั่วไป โดยมีไฟล์คำสั่งระบุว่าจะต้องรันเมื่อใด ตัวติดตั้งของ Memmy ที่ระบุไว้ในเอกสารจะสร้างไฟล์ดังกล่าวให้คุณ โดย memmy-memory init --agent จะวางไฟล์คำสั่งหน่วยความจำลงในไดเรกทอรีกฎของเอเจนต์เป้าหมาย

คุณควรเขียนคำสั่งด้วยตนเองหนึ่งครั้ง เพื่อให้ทราบแน่ชัดว่ามีการกำหนดคำสั่งใดให้กับเอเจนต์ Claude Code จะอ่าน CLAUDE.md จากรูทของโปรเจกต์เมื่อเริ่มต้นทุกเซสชัน ดังนั้นส่วนประกอบดังต่อไปนี้คือการเชื่อมต่อทั้งหมดที่จำเป็น:

## Memory

Before starting a task, run `memmy-memory search "<topic>"` and read what comes back.
When a task is done, run `memmy-memory add "<what you learned>"` for anything that will matter next session.

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

สำหรับการทำงานในทิศทางตรงกันข้ามไม่จำเป็นต้องตั้งค่าใดๆ ทั้งสิ้น ตัวสแกนของ Memmy จะอ่าน ~/.claude/projects/**/*.jsonl โดยอัตโนมัติ ซึ่งเป็นตำแหน่งที่ Claude Code ใช้บันทึกทรานสคริปต์ของเซสชัน เพียงรัน Memmy บนเซิร์ฟเวอร์เดียวกับที่คุณรัน Claude Code ภายในเซสชัน tmux งานของเมื่อวานก็จะกลายเป็นหน่วยความจำโดยที่คุณไม่ต้องตั้งค่าใดๆ เพิ่มเติม

Memmy ทำงานเป็น MCP server สำหรับ Claude Code หรือไม่

ไม่ และการทราบทิศทางนี้จะช่วยประหยัดเวลาของคุณได้มาก MCP (model context protocol) ประกอบด้วยไคลเอนต์และเซิร์ฟเวอร์ Memmy เป็นไคลเอนต์ มันเชื่อมต่อออกไปยัง MCP server ต่างๆ และนำเครื่องมือของเซิร์ฟเวอร์เหล่านั้นมาให้เอเจนต์รันไทม์ของตัวเองใช้งาน มันไม่ได้เผยแพร่ MCP endpoint ที่ claude mcp add จะชี้ไปหาได้ สะพานเชื่อม MCP เพียงหนึ่งเดียวในที่เก็บข้อมูลนี้เป็นส่วนหนึ่งของการรวมระบบ Composio ภายใน API ท้องถิ่นของเดสก์ท็อป และ API นั้นจะผูกพอร์ตแบบสุ่มบน 127.0.0.1 ไว้หลังส่วนหัว x-memmy-mcp-token ของตัวเอง

ฝั่งไคลเอนต์ถูกกำหนดค่าไว้ใน ~/.memmy/config.yaml ซึ่งเป็นไฟล์ที่ MEMMY_CONFIG ชี้ไปหา ภายใต้ tools.mcpServers:

tools:
  mcpServers:
    example:
      type: stdio
      command: npx
      args:
        - "-y"
        - "your-mcp-server"
      toolTimeout: 30
      enabledTools:
        - "*"

type ยอมรับ stdio, sse และ streamableHttp เซิร์ฟเวอร์ stdio จะทำงานเป็นกระบวนการลูก (child process) ของ Memmy ซึ่งหมายความว่าคำสั่งของเซิร์ฟเวอร์นั้นต้องมีอยู่บนเครื่องเดียวกันและทำงานภายใต้ผู้ใช้เดียวกัน หากคุณเก็บ MCP servers ที่ทำงานบน VPS ไว้ใช้งานอยู่แล้ว นั่นคือเซิร์ฟเวอร์ที่คุณควรระบุไว้ที่นี่

การรักษาความเป็นส่วนตัวของหน่วยความจำ

ทุกสิ่งที่ Memmy เป็นเจ้าของจะถูกจัดเก็บไว้ภายใต้ ~/.memmy ได้แก่ config.yaml, พื้นที่ทำงาน, memory-service/memory.sqlite และไฟล์รันไทม์ การสแกนและการนำเข้าข้อมูลจะเกิดขึ้นภายในเครื่อง และหน่วยความจำจะถูกเขียนลงในไฟล์ SQLite ในเครื่อง ดังนั้นสถานะเริ่มต้นจึงเป็นแบบภายในเครื่องอย่างแท้จริง

มีเส้นทางสองเส้นทางที่เชื่อมต่อกับเครือข่าย โดยค่าเริ่มต้น MEMMY_CLOUD_SERVICE จะชี้ไปที่ https://memmy-api.memtensor.cn และรองรับโหมดบัญชีผู้ใช้ด้วยโทเค็นทดลอง ดังนั้นโหมด API key จึงไม่มีการเรียกใช้งานส่วนนี้ ส่วนโปรแกรมปรับปรุงหน่วยความจำจะเป็นสวิตช์แยกต่างหากในการตั้งค่าความเป็นส่วนตัว ซึ่งจะถูกปิดไว้จนกว่าคุณจะเปิดใช้งานด้วยตนเอง

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

ให้คงพอร์ต 18960 ไว้ที่ loopback address โดยไม่จำเป็นต้องมีกฎ firewall เนื่องจากบริการที่ผูกไว้กับ 127.0.0.1 จะไม่สามารถเข้าถึงได้จากภายนอกเครื่องเลย ให้เข้าถึงผ่านแล็ปท็อปของคุณด้วย SSH แทน:

ssh -N -L 18960:127.0.0.1:18960 you@your-vps

หากคุณจำเป็นต้องผูกพอร์ตในวงกว้างขึ้น ให้ตั้งค่าโทเค็นก่อน การตั้งค่า storage.token ในไฟล์คอนฟิก หรือการใช้ตัวแปรสภาพแวดล้อม MEMMY_MEMORY_TOKEN หรือ MEMORY_SERVICE_TOKEN จะทำให้ทุก endpoint ยกเว้น health ต้องใช้ bearer token ในการเข้าถึง ค่าคอนฟิกรองรับการอ้างอิง ${ENV_NAME} ดังนั้นโทเค็นและ API key ของโมเดลของคุณจะไม่อยู่ในไฟล์คอนฟิกโดยตรง ซึ่งเป็นแนวทางปฏิบัติเดียวกับ การเก็บความลับให้ห่างจาก AI agents ในที่อื่นๆ และ นโยบาย default deny ของ ufw จะเป็นมาตรการป้องกันสำรองของคุณ หากเวอร์ชันในอนาคตมีการเปลี่ยนแปลงค่า bind address เริ่มต้น

สำรองข้อมูล ~/.memmy ก่อนเริ่มใช้งาน

memory.sqlite คือที่เก็บข้อมูลทั้งหมด เวกเตอร์ต่างๆ จะถูกจัดเก็บอยู่ในไฟล์เดียวกันนี้ผ่านส่วนขยาย sqlite-vec ดังนั้นไฟล์นี้จึงเป็นไฟล์เดียวที่คุณต้องสำรองข้อมูล การคัดลอกไฟล์ด้วย cp ในขณะที่บริการกำลังเขียนข้อมูลอยู่อาจทำให้ฐานข้อมูลเสียหายได้ ให้ใช้คำสั่งสำรองข้อมูลของ SQLite โดยตรง:

mkdir -p ~/memmy-backup
sqlite3 ~/.memmy/memory-service/memory.sqlite ".backup '$HOME/memmy-backup/memory.sqlite'"

คำสั่งนี้จะสร้างสำเนาข้อมูลที่สมบูรณ์ในขณะที่บริการยังคงทำงานอยู่ ให้คัดลอกไฟล์ดังกล่าวออกจากเซิร์ฟเวอร์ตามกำหนดเวลา ซึ่งเป็นหน้าที่ของ restic เพื่อจัดเก็บข้อมูลนอกสถานที่ การสูญเสีย config.yaml จะทำให้คุณเสียการตั้งค่าของผู้ให้บริการซึ่งสามารถพิมพ์ใหม่ได้ แต่การสูญเสีย memory.sqlite จะทำให้คุณสูญเสียความทรงจำทั้งหมด และไม่มีส่วนอื่นใดในเครื่องที่เก็บสำเนาชุดที่สองไว้

การรันบริการหน่วยความจำภายใต้ systemd

npm run memory:serve:dev ในเชลล์จะหยุดทำงานเมื่อเชลล์ปิดตัวลง ไฟล์หน่วย (unit file) จะช่วยให้บริการยังคงทำงานอยู่แม้ผ่านการรีบูตเครื่อง

[Unit]
Description=Memmy memory service
After=network-online.target

[Service]
Type=simple
User=memmy
WorkingDirectory=/opt/memmy/memmy-agent
EnvironmentFile=/etc/memmy/memory.env
ExecStart=/usr/bin/npm run memory:serve:dev
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

อย่าใส่โทเค็นไว้ในไฟล์หน่วย ให้เก็บไว้ใน /etc/memmy/memory.env ซึ่งมี root เป็นเจ้าของ และตั้งค่าสิทธิ์เป็น 600:

MEMMY_CONFIG=/home/memmy/.memmy/config.yaml
MEMMY_MEMORY_TOKEN=replace-this-with-a-long-random-string

sudo systemctl daemon-reload
sudo systemctl enable --now memmy-memory
systemctl status memmy-memory --no-pager
curl -sS http://127.0.0.1:18960/api/v1/health

status=203/EXEC ในผลลัพธ์สถานะหมายความว่า systemd ไม่สามารถรัน ExecStart ได้เลย ให้ตรวจสอบ which npm โดยปกติจะเป็น /usr/bin/npm สำหรับการติดตั้งแบบ NodeSource หรืออยู่ในไดเรกทอรีของผู้ใช้สำหรับ nvm ซึ่ง systemd จะหาไม่พบ หากไฟล์หน่วยเริ่มทำงานแล้วหยุดทันที แสดงว่าเกิดข้อผิดพลาดภายใน npm ซึ่ง journalctl -u memmy-memory -n 50 จะแสดงสาเหตุของปัญหา กลไกการทำงานนี้เหมือนกับ บริการ systemd อื่นๆ บน VPS

สิ่งที่ Memmy ยังไม่รองรับในขณะนี้

• ยังไม่มีการสร้างไฟล์สำหรับ Linux desktop สคริปต์การแพ็กเกจรองรับเฉพาะ macOS และ Windows ดังนั้น workbench, ตัวช่วยตั้งค่าเริ่มต้น (onboarding wizard) และแดชบอร์ดหน่วยความจำจึงไม่สามารถใช้งานบนตัวเซิร์ฟเวอร์ได้โดยตรง
• memory:serve:dev จะรันจุดเริ่มต้นของ TypeScript ผ่าน tsx ซึ่งเป็นเส้นทางสำหรับการพัฒนา ตัว repository ยังมาพร้อมกับ memory:serve สำหรับผลลัพธ์ที่คอมไพล์แล้ว ให้รัน npm run โดยไม่ต้องใส่ argument เพื่อดูว่า checkout ของคุณมีสคริปต์ใดบ้าง
• การดึงข้อมูล (Retrieval) จะสร้างหน้าต่างการค้นหาจากแถวเวกเตอร์ล่าสุด 2,000 แถว จากนั้นจึงใช้การเลือกแบบ Top-K ภายในหน้าต่างนั้น ในกรณีที่มีที่เก็บข้อมูลขนาดใหญ่มาก หน่วยความจำเก่าอาจอยู่นอกขอบเขตดังกล่าว
• การทำ Embedding จะเกิดขึ้นหลังจากขั้นตอนการบันทึกข้อมูล หากเกิดความล้มเหลว ระบบจะส่งงานไปยังคิวสำหรับการลองใหม่ (retry queue) แทนที่จะขัดจังหวะการทำงานของ agent ดังนั้นหน่วยความจำที่เพิ่งเพิ่มเข้าไปเมื่อครู่ อาจยังไม่สามารถค้นหาได้ด้วยการค้นหาแบบเวกเตอร์
• ไฟล์ SQLite หนึ่งไฟล์หมายถึงหนึ่งโหนด ระบบไม่มีการทำ clustering ดังนั้นเซิร์ฟเวอร์เครื่องที่สองจึงถือเป็นหน่วยความจำแยกต่างหาก

เวอร์ชัน 1.0.4 และจำนวนดาวประมาณ 329 ดวง ณ เดือนกรกฎาคม 2026 บ่งบอกว่าเป็นโปรเจกต์ที่ยังอยู่ในช่วงเริ่มต้น แฟล็ก, เส้นทาง และชื่อสคริปต์อาจมีการเปลี่ยนแปลงระหว่างการออกรุ่นใหม่ โปรดอ่านฟิลด์ bin และผลลัพธ์ของ npm run ใน checkout ของคุณเอง แทนที่จะเชื่อคำสั่งที่คัดลอกมาจากแหล่งอื่น รวมถึงจากที่นี่ด้วย

FAQ

เหตุใดการตรวจสอบสถานะ (health check) จึงแจ้งว่า connection refused?

ไม่มีบริการใดกำลังรอรับการเชื่อมต่อที่พอร์ต 18960 รหัสสถานะการออกของ curl คือ 7 พร้อมกับ Failed to connect to 127.0.0.1 port 18960 หมายความว่าบริการหน่วยความจำไม่ได้ทำงานหรือหยุดทำงานตั้งแต่เริ่มระบบ ให้ตรวจสอบที่เทอร์มินัลหรือบันทึก (journal) ของบริการ สาเหตุทั่วไปมี 2 ประการ ได้แก่ better-sqlite3 ซึ่งเป็นโมดูลเนทีฟที่ไม่ตรงกับเวอร์ชัน Node ของคุณ ซึ่งแก้ไขได้ด้วย npm rebuild better-sqlite3 และการใช้ Node เวอร์ชันที่ต่ำกว่า 22 ให้ยืนยันสถานะของซ็อกเก็ตด้วย ss -lntp | grep 18960 หลังจากที่บริการเริ่มทำงานแล้ว

คำสั่ง memmy-memory มาจากที่ใดหลังจากสร้าง (build) จากซอร์สโค้ด?

มาจากฟิลด์ bin ของแพ็กเกจในพื้นที่ทำงาน @memmy/memory ไม่ใช่จากชื่อของที่เก็บข้อมูล (repository) ให้รัน node -p "JSON.stringify(require('./Memory/package.json').bin)" ภายในไดเรกทอรีที่เช็คเอาต์ออกมา แล้วระบบจะแสดงผลเป็น {"memmy-memory":"./dist/src/cli/index.js"} ไฟล์ดังกล่าวจะมีอยู่ก็ต่อเมื่อรัน npm run memory:build แล้วเท่านั้น เนื่องจากกระบวนการสร้างจะสร้าง dist และกำหนดให้ไฟล์นั้นสามารถเรียกใช้งานได้ (executable) ให้รันคำสั่งโดยใช้ node Memory/dist/src/cli/index.js health หรือสร้าง symlink ไปยัง /usr/local/bin เพื่อใช้ชื่อคำสั่งแบบสั้น

ฉันสามารถเพิ่ม Memmy ลงใน Claude Code ด้วย claude mcp add ได้หรือไม่?

ไม่ได้ Memmy เป็นไคลเอนต์ MCP ไม่ใช่เซิร์ฟเวอร์ MCP โดย Memmy จะเชื่อมต่อไปยังเซิร์ฟเวอร์ที่ระบุไว้ภายใต้ tools.mcpServers ใน ~/.memmy/config.yaml และนำเครื่องมือของเซิร์ฟเวอร์เหล่านั้นมาใช้ในรันไทม์ของตัวเอง ส่วน Claude Code จะเข้าถึง Memmy ในทางกลับกัน โดยการรัน CLI ของ memmy-memory เป็นคำสั่งเชลล์ ตามคำแนะนำในไฟล์ที่ memmy-memory init --agent เขียนไว้ในไดเรกทอรีกฎของเอเจนต์

การรัน Memmy จะส่งข้อมูลความจำของฉันไปยังบริการคลาวด์หรือไม่?

กระบวนการสแกนและนำเข้าข้อมูลจะทำงานภายในเครื่อง และความจำจะถูกเขียนลงใน ~/.memmy/memory-service/memory.sqlite บนดิสก์ของคุณเอง MEMMY_CLOUD_SERVICE จะชี้ไปยัง https://memmy-api.memtensor.cn สำหรับโหมดบัญชีและโทเค็นทดลองใช้ และโปรแกรมปรับปรุงหน่วยความจำจะถูกปิดไว้จนกว่าคุณจะเปิดใช้งานด้วยตนเอง สิ่งที่ควรระวังคือผู้ให้บริการ embedding: โมเดล embedding ที่โฮสต์อยู่บนคลาวด์จะได้รับข้อความของทุกความจำที่ถูกแปลงเป็นเวกเตอร์ ดังนั้นให้ใช้ endpoint ที่คุณรันด้วยตัวเองหากคุณให้ความสำคัญกับความเป็นส่วนตัวในส่วนนี้