SSD Nodes Learn Hosting plans →
คู่มือ Matt Connorโดย Matt Connor

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

ติดตั้ง Memmy บน Ubuntu เพื่อสร้างศูนย์กลางหน่วยความจำสำหรับ AI Agent ให้ใช้งานร่วมกันผ่านพอร์ต 18960 รองรับการจัดเก็บข้อมูลแบบ Local พร้อมคำแนะนำการตั้งค่าบน VPS โดยละเอียด

Verified Every command ran end-to-end on a fresh Ubuntu 24.04 server, July 31, 2026.

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

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

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

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

การเปลี่ยนแปลงที่เกิดขึ้นเมื่อใช้ Shared Memory Hub เทียบกับการเก็บหน่วยความจำแยกตามเครื่องมือ

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

Hub จะย้ายที่เก็บข้อมูลออกมาจากตัวเครื่องมือ Memmy สามารถอ่านที่เก็บข้อมูลเดิมที่มีอยู่ได้ คุณจึงไม่ต้องเริ่มต้นจากฐานข้อมูลเปล่า ตัวสแกนของ Memmy รองรับแหล่งข้อมูลในตัว 10 แห่ง ได้แก่ 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, DeepSeek Harness ที่ ~/.dsh/sessions, WorkBuddy ที่ ~/.workbuddy/projects, Pi ที่ ~/.pi/agent/sessions และ QwenWork ที่ ~/.qwenworkcn/projects Desktop workbench สามารถเพิ่ม Agent อื่นได้โดยระบุชื่อ และจะถามหา path ของประวัติการใช้งานเฉพาะเมื่อไม่พบตัว Agent นั้นๆ ตัวสแกนฝั่งเซิร์ฟเวอร์ไม่มีแหล่งข้อมูลแบบกำหนดเอง ดังนั้นบน headless VPS คุณจะใช้งานได้เฉพาะแหล่งข้อมูลที่มีมาให้ในตัวเท่านั้น

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

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

สิ่งที่จำเป็นต้องมีบน VPS

  • Node.js เวอร์ชัน 22 หรือใหม่กว่า เอกสารของ Memmy กำหนดให้ใช้เวอร์ชันนี้ แต่ Ubuntu 24.04 มาพร้อมกับ Node 18
  • git และ build toolchain เนื่องจาก better-sqlite3 เป็น native module ที่อาจต้องคอมไพล์ระหว่างการติดตั้ง
  • หน่วยความจำ (RAM) สำหรับการติดตั้ง root workspace และ build chain ของส่วนหน้า (frontend)
  • พื้นที่ว่างบนดิสก์สำหรับ 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 หรือสูงกว่าสำหรับการ build จากซอร์สตามที่ระบุไว้ในเอกสาร หากได้ v18 ในขั้นตอนนี้ แสดงว่าขั้นตอนการติดตั้งผ่าน NodeSource ไม่สำเร็จ โดยปกติแล้ว engine-strict ของ npm จะตั้งค่าเริ่มต้นไว้ที่ false ดังนั้นการประกาศ 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 workspace ไปยัง Memory/dist นอกจากนี้ยังสร้าง AgentSourceCore, โปรแกรมดูหน่วยความจำ (memory viewer) และสินทรัพย์สำหรับการเชื่อมต่อที่จำเป็นสำหรับ workspace นั้น ให้ตรวจสอบว่าโมดูลเนทีฟโหลดขึ้นมาแล้ว:

node -e "const Database = require('better-sqlite3'); const db = new Database(':memory:'); db.close(); console.log('better-sqlite3 loads')"

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

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

รุ่นล่าสุดยังมาพร้อมกับ memmy-agent-linux-cli.tar.gz และ install.sh สำหรับ Linux x64 และ arm64 ตัวติดตั้งต้องการ Node.js เวอร์ชัน 22.23.4 ขึ้นไปในตระกูล 22.x, เวอร์ชัน 24.22.1 ขึ้นไปในตระกูล 24.x หรือเวอร์ชัน 26.12.1 ขึ้นไปในตระกูล 26.x ร่วมกับ systemd user session โดยตัวติดตั้งจะปฏิเสธการทำงานหากใช้เวอร์ชันหลักอื่น ตัวติดตั้งจะวางตัวเรียกใช้งาน memmy และ memmy-memory ไว้ใน ~/.local/bin และเริ่มบริการหน่วยความจำในฐานะ user unit บน 127.0.0.1:18960 คู่มือนี้เลือกใช้วิธีการ build จากซอร์สโค้ดเนื่องจากเป็นแนวทางที่คุณสามารถตรวจสอบสคริปต์ทุกตัวได้ก่อนที่จะสั่งรันจริง

เริ่มการทำงานของ memory service และตรวจสอบการตอบสนอง

npm run memory:serve:dev

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

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 ไม่จำเป็นต้องใช้โทเค็น จึงเป็นเครื่องมือตรวจสอบที่เหมาะสม หาก curl จบการทำงานด้วยรหัส 7 พร้อมข้อความ Failed to connect to 127.0.0.1 port 18960 แสดงว่าการเชื่อมต่อล้มเหลว ซึ่งเพียงแค่นี้ยังไม่สามารถสรุปได้ว่ามี listener ทำงานอยู่หรือไม่ ให้ตรวจสอบที่อยู่ (address), พอร์ต, ไฟร์วอลล์ในเครื่อง และอ่านข้อความแจ้งเตือนความผิดพลาดขณะเริ่มระบบจากเทอร์มินัลที่รันบริการอยู่ ss -lntp | grep 18960 จะช่วยยืนยันสถานะของซ็อกเก็ตเมื่อบริการเริ่มทำงานแล้ว

HTTP API (application programming interface) ส่วนที่เหลือจะอยู่ภายใต้ /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 ใช้สำหรับจัดการช่วงเวลาของเอเจนต์ (agent session)
  • 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 สำหรับ memory, 18970 สำหรับ gateway health, 18980 สำหรับ web UI และ admin HTTP, 18990 สำหรับ API ที่รองรับ OpenAI ซึ่ง memmy serve จะเป็นตัวเริ่มการทำงาน จากนั้นคือ 19000 สำหรับ Vite dev server ของ desktop frontend และ 19001 สำหรับซ็อกเก็ต hot reload แม้หน้าเว็บรวมพอร์ตของโปรเจกต์จะยังระบุพอร์ต 19010 สำหรับ hot reload แต่คอนฟิกของ Vite ได้กำหนดไว้ที่ 19001 หากมีบริการอื่นในเครื่องของคุณใช้งานพอร์ตเหล่านี้อยู่ ให้ตรวจสอบรายการดังกล่าวเพื่อหาสาเหตุ

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

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

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

คำสั่งดังกล่าวจะแสดงผล {"memmy-memory":"./dist/src/cli/index.js"} ดังนั้น entry point ที่ถูก build ขึ้นมาคือ 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 โดยมีคำสั่งย่อย (subcommands) ได้แก่ init, health, search, add, get และ delete รวมถึงการเรียกใช้งาน session และ turn ซึ่งมักใช้โดย agent มากกว่าผู้ใช้งานทั่วไป และยังมี install, upgrade, service และ stop สำหรับการจัดการตัว service เอง โดย memmy-memory search "deploy steps" และ memmy-memory add "staging migrates on deploy" คือสองคำสั่งที่ agent เรียกใช้งานบ่อยที่สุด

คุณจะเชื่อมต่อ Claude Code เข้ากับ Memmy ได้อย่างไร

Memmy ไม่ได้ลงทะเบียนตัวเองเป็นเซิร์ฟเวอร์ภายใน Claude Code แต่จะเชื่อมต่อผ่านไฟล์ที่ Claude Code อ่านอยู่แล้ว ซึ่งขอบเขตการทำงานจะขึ้นอยู่กับ memmy-memory ที่คุณเรียกใช้งาน หากเป็นการดึงซอร์สโค้ดมาใช้งาน memmy-memory init --agent claude จะเขียน Skill แบบ memmy-memory ลงใน ~/.claude/skills/ และเขียนบล็อกหน่วยความจำที่มีการทำเครื่องหมายไว้ลงใน ~/.claude/CLAUDE.md จากนั้น Claude Code จะเรียกใช้ memmy-memory เป็นคำสั่ง shell ปกติเมื่อได้รับคำสั่งดังกล่าว ตัวเรียกใช้งานที่ตัวติดตั้งบน Linux วางไว้ใน ~/.local/bin จะทำงานได้มากกว่านั้น โดยคำสั่งเดียวกันนี้จะลงทะเบียน hook ใน ~/.claude/settings.json สำหรับ SessionStart, UserPromptSubmit, Stop, PostCompact และ SessionEnd ซึ่งจะทำหน้าที่แทรกหน่วยความจำที่เกี่ยวข้องและบันทึกทุกรอบการทำงานที่เสร็จสิ้นโดยที่โมเดลไม่จำเป็นต้องตัดสินใจทำเอง

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

## 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.

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

สำหรับการทำงานในทิศทางตรงกันข้ามนั้นไม่จำเป็นต้องตั้งค่าใดๆ ทั้งสิ้น ตัวสแกนของ Memmy จะอ่าน ~/.claude/projects/**/*.jsonl ซึ่งเป็นตำแหน่งที่ Claude Code ใช้บันทึก transcript ของเซสชันอยู่แล้ว หากคุณเรียกใช้ 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 คือชื่อต้นทางของคลาวด์ โค้ดไม่ได้กำหนดค่าเริ่มต้นไว้ แต่ .env.example ซึ่งขั้นตอนการติดตั้งจะคัดลอกไปยัง .env ได้กำหนดค่าไว้เป็น https://api.memmy.cn ซึ่งรองรับโหมดบัญชีผู้ใช้พร้อมโทเค็นทดลอง และเมื่อใดก็ตามที่มีการตั้งค่านี้ โค้ดวิเคราะห์ของ Memmy จะส่งเหตุการณ์การใช้งานไปยังปลายทางดังกล่าวด้วย รวมถึงในโหมด API key เช่นกัน ได้แก่ ชื่อเหตุการณ์และคำสั่ง, เวอร์ชัน และ ID ของการติดตั้ง CLI จะรายงานเฉพาะคำสั่งที่เป็นค่าคงที่เท่านั้น ไม่มีการส่งคำค้นหาหรือข้อความในหน่วยความจำ และโค้ดวิเคราะห์จะไม่ส่งข้อมูลใดๆ หากค่านี้ไม่ได้ถูกตั้งค่าไว้ ดังนั้นบนเซิร์ฟเวอร์ที่ใช้เฉพาะ API keys ให้ลบค่าในบรรทัดนั้นใน .env ออกก่อนเริ่มการทำงานใดๆ ส่วนโปรแกรมปรับปรุงหน่วยความจำจะเป็นสวิตช์แยกต่างหากในการตั้งค่าความเป็นส่วนตัว

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

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

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

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

สำรองข้อมูล ~/.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 จะทำให้คุณเสียความทรงจำที่บันทึกไว้ตั้งแต่การสำรองข้อมูลครั้งล่าสุดที่ใช้งานได้ แม้ว่าบริการจะสร้างการสำรองข้อมูลในเครื่องก่อนการย้ายโครงสร้างฐานข้อมูล (schema migration) แต่ก็ไม่ใช่สำเนาที่เก็บไว้นอกสถานที่ในปัจจุบัน

การรัน memory service ภายใต้ systemd

npm run memory:serve:dev ใน shell จะสิ้นสุดการทำงานเมื่อ shell ปิดตัวลง ไฟล์ unit จะช่วยให้ service ทำงานต่อเนื่องหลังจาก reboot โดยรันในฐานะผู้ใช้ memmy จาก checkout ใน /opt/memmy และใช้ไฟล์ config ใน home directory ของผู้ใช้นั้น ให้หยุดการทำงานของสำเนาที่รันอยู่ใน shell ของคุณ จากนั้นย้าย checkout และ config ไปยังตำแหน่งที่ต้องการ แล้วชี้ลิงก์ memmy-memory ใหม่:

sudo useradd -m -s /bin/bash memmy
sudo mkdir -p /opt/memmy
sudo mv ~/memmy-agent /opt/memmy/memmy-agent
sudo chown -R memmy:memmy /opt/memmy
sudo ln -sfn /opt/memmy/memmy-agent/Memory/dist/src/cli/index.js /usr/local/bin/memmy-memory
sudo install -d -o memmy -g memmy -m 700 /home/memmy/.memmy
sudo install -o memmy -g memmy -m 600 ~/.memmy/config.yaml /home/memmy/.memmy/config.yaml
sudo install -d -m 755 /etc/memmy

service จะเก็บฐานข้อมูลไว้ภายใต้ /home/memmy/.memmy ดังนั้นมันจะเริ่มต้นด้วยที่เก็บข้อมูลเปล่า

[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

อย่าใส่ token ไว้ในไฟล์ unit ให้เก็บไว้ใน /etc/memmy/memory.env โดยกำหนดให้ root เป็นเจ้าของ และตั้ง permission เป็น 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 ในสถานะ output หมายความว่า systemd ไม่สามารถรัน ExecStart ได้เลย ให้ตรวจสอบ which npm: โดยปกติจะเป็น /usr/bin/npm สำหรับการติดตั้งแบบ NodeSource หรืออยู่ใน home directory ของผู้ใช้หากติดตั้งผ่าน nvm ซึ่ง systemd จะหาไม่พบ หาก unit เริ่มทำงานแล้วหยุดทันที ให้ตรวจสอบ exit status และ journal: code 0 คือการหยุดทำงานปกติ ส่วนผลลัพธ์อื่นรวมถึงการ exit ด้วยค่าที่ไม่ใช่ 0, สัญญาณ (signals) และการหมดเวลา (timeouts) ให้รัน journalctl -u memmy-memory -n 50 เพื่อดู output ของ service กลไกการทำงานนี้เหมือนกับ service อื่นๆ ของ systemd บน VPS

ปัจจุบันโปรเจกต์มีทางเลือกสำหรับผู้ใช้สองแบบ วิธีใน README สำหรับการ build จาก source คือ memmy-memory install --service-only ซึ่งจะดาวน์โหลด Memory runtime เวอร์ชันที่กำหนดและลงทะเบียนเป็น user service ส่วนตัวติดตั้งบน Linux จะตั้งค่า memmy-memory.service เป็น unit แบบ systemd --user ทั้งสองวิธีไม่ได้เปิดใช้งาน linger ไว้ ดังนั้นให้รัน sudo loginctl enable-linger <user> เพื่อให้ตัวจัดการ service ของผู้ใช้นั้นทำงานต่อไปหลังจาก logout และเริ่มทำงานตอนบูตเครื่อง

สิ่งที่ Memmy ยังไม่รองรับ

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

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

FAQ

ทำไม health check ถึงแจ้งว่า connection refused?

รหัส exit code 7 ของ curl พร้อมกับ Failed to connect to 127.0.0.1 port 18960 บ่งชี้ว่าการเชื่อมต่อล้มเหลว ไม่ได้ระบุว่า Memmy หยุดทำงาน, แครช, กำลังฟังพอร์ตอื่น หรือเข้าถึงไม่ได้ ให้ตรวจสอบที่อยู่และพอร์ต รันคำสั่ง ss -lntp | grep 18960 และอ่านข้อความจากเทอร์มินัลหรือ journal ที่บริการเริ่มทำงาน หาก log รายงานว่าโมดูล SQLite ไม่ตรงกัน ให้รัน npm rebuild better-sqlite3 ตรวจสอบเวอร์ชันของ Node ด้วย โดยเอกสารต้นฉบับระบุว่าต้องใช้ Node 22 ขึ้นไป ในขณะที่ตัวติดตั้งบน Linux รองรับเฉพาะ Node.js 22.23.4+ ในตระกูล 22.x, 24.22.1+ ในตระกูล 24.x หรือ 26.12.1+ ในตระกูล 26.x เท่านั้น

คำสั่ง memmy-memory มาจากไหนหลังจาก build จากซอร์สโค้ด?

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

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

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

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

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

บทความนี้มีประโยชน์หรือไม่