SSD Nodes Learn Hosting plans →
கல்வி வழிகாட்டிகள் Matt Connorஆல் Matt Connor

VPS-ல் AI agents-க்கு Memmy memory hub அமைப்பது எப்படி?

உங்கள் AI agents-க்கு பகிரப்பட்ட memory store உருவாக்க Memmy-ஐ Ubuntu VPS-ல் நிறுவுவது எப்படி என்பதை அறியுங்கள். 18960 போர்ட்டில் சேவையை இயக்கி தரவுகளை உள்ளூர்மயமாக்குங்கள்.

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

Memmy என்றால் என்ன மற்றும் அது எதைச் சேமிக்கிறது

Memmy என்பது AI agents-க்கான ஒரு local memory hub ஆகும்; இது உங்கள் சொந்த VPS-ல் (virtual private server) இயங்குகிறது. இது உங்கள் agents கற்றுக்கொண்டவற்றை ஒரே ஒரு SQLite database-ல் வைத்திருக்கிறது; அந்த server-ல் உள்ள ஒவ்வொரு agent-ம் அதே store-ல் இருந்து தகவல்களைப் படிக்கவும் எழுதவும் செய்கிறது. இந்தத் திட்டம் MemTensor-லிருந்து memmy-agent பெறப்பட்டது, MIT உரிமம் பெற்றது, மேலும் 1 நவம்பர் 2026 நிலவரப்படி 1.2.401 பதிப்பில் உள்ளது; Memory தனித்தனியாக 2.1.7 பதிப்பைக் கொண்டுள்ளது.

server-ல் அதன் ஒரு பகுதி மட்டுமே முக்கியமானது. Memmy ஒரு memory service-ஐ வழங்குகிறது, இது http://127.0.0.1:18960-ல் listening நிலையில் இருக்கும்; மேலும் அந்த service-உடன் தொடர்புகொள்ளும் ஒரு memmy-memory command line interface (CLI) மற்றும் ஒரு desktop workbench ஆகியவற்றையும் வழங்குகிறது. workbench ஆனது macOS மற்றும் Windows-க்கு மட்டுமே தொகுக்கப்பட்டுள்ளது, எனவே Linux VPS-ல் நீங்கள் service மற்றும் CLI-ஐ மட்டுமே இயக்குவீர்கள். Claude Code, Codex மற்றும் Cursor ஆகியவற்றிற்கு பகிரப்பட்ட memory-ஐ வழங்க இது போதுமானது.

Memmy தான் சேமிக்கும் தகவல்களை நான்கு அடுக்குகளாகப் பிரிக்கிறது. Capture முதலில் ஒரு தனி Raw Turn-ஐச் சேமிக்கிறது, பின்னர் ஒவ்வொரு captured step-க்கும் ஒரு L1 Trace உருப்படியை எழுதுகிறது; இதில் requests, responses, tool calls மற்றும் முடிவுகள் அடங்கும். L2 Policy என்பது பயனுள்ளதாக நிரூபிக்கப்பட்ட traces-லிருந்து பெறப்பட்ட ஒரு செயல்முறை ஆகும். L3 World Model என்பது ஒரு project அல்லது சூழலைப் பற்றிய நிலையான அறிவு ஆகும். Skill என்பது ஒரு policy-லிருந்து உருவாக்கப்பட்ட, அழைக்கக்கூடிய (callable) செயல்முறை ஆகும். Capture ஆனது L1 traces-ஐ உருவாக்குகிறது, background jobs உயர் அடுக்குகளை மேம்படுத்துகின்றன, மேலும் explicit writes மூலம் ஒரு அடுக்கைத் தேர்ந்தெடுக்க முடியும். இந்த வேறுபாடுகள் சுருக்கமானதாகத் தோன்றினால், agents உருவாக்கக் கற்றுக்கொள்வதற்கான ஒரு படிநிலை பாதையில் memory என்பது பிந்தைய நிலைகளில் ஒன்றாகும்; நீங்கள் ஒரு எளிய agent loop-ஐ நீங்களே எழுதி, ஒவ்வொரு run-க்கும் இடையில் அது அனைத்தையும் மறந்துவிடுவதைக் கவனித்த பிறகு, இந்த அடுக்குகள் உங்களுக்கு இன்னும் தெளிவாகப் புரியும்.

Shared memory hub, தனிப்பட்ட கருவி சார்ந்த நினைவகத்தை விட எவ்வாறு மாற்றுகிறது

இன்று ஒவ்வொரு ஏஜென்ட்டும் (agent) அதன் சொந்த நினைவகத்தைக் கொண்டுள்ளது. Claude Code அறிவுறுத்தல் கோப்புகளை repository-ல் வைத்திருக்கிறது. Cursor அதன் workspace database-ல் விதிகளை வைத்திருக்கிறது. Codex அதன் session logs-ஐ ~/.codex-ன் கீழ் வைத்திருக்கிறது. ஒவ்வொரு சேமிப்பகமும் ஒரு கருவிக்கு மட்டுமே சொந்தமானது; எனவே, திங்களன்று ஒரு கருவியில் நீங்கள் கற்பித்த ஒரு தகவல், செவ்வாயன்று மற்றொரு கருவிக்குத் தெரியாது. இதற்கு நீங்கள் இரண்டு முறை விலை கொடுக்கிறீர்கள்: ஒன்று, அதே திட்டத்தைப் பற்றி மீண்டும் விளக்குவதற்குச் செலவிடப்படும் tokens, மற்றொன்று, நீங்கள் ஏற்கனவே வேறொரு இடத்தில் திருத்திய ஒரு கருத்தை அடிப்படையாகக் கொண்டு ஏஜென்ட் தவறான வேலையைச் செய்வது.

ஒரு hub, சேமிப்பகத்தை கருவியிலிருந்து வெளியே நகர்த்துகிறது. Memmy ஏற்கனவே உள்ள சேமிப்பகங்களையும் வாசிப்பதால், நீங்கள் காலியான database-லிருந்து தொடங்க வேண்டியதில்லை. அதன் scanner பத்து உள்ளமைக்கப்பட்ட (built-in) மூலங்களை அறியும்: ~/.claude/projects/**/*.jsonl-ல் Claude Code, ~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-*.jsonl-ல் Codex, ~/.local/share/opencode/opencode.db-ல் OpenCode, Cursor-ன் state.vscdb கோப்புகள், ~/.openclaw-ன் கீழ் உள்ள OpenClaw-ன் SQLite databases, ~/.hermes-ல் Hermes, ~/.dsh/sessions-ல் DeepSeek Harness, ~/.workbuddy/projects-ல் WorkBuddy, ~/.pi/agent/sessions-ல் Pi மற்றும் ~/.qwenworkcn/projects-ல் QwenWork. Desktop workbench மூலம் மற்றொரு ஏஜென்ட்டை அதன் பெயரைக் கொண்டு சேர்க்கலாம்; ஏஜென்ட்டை தானாகக் கண்டறிய முடியாதபோது மட்டுமே அது அதன் history path-ஐக் கேட்கும். Server-side scanner-ல் custom மூலங்கள் இல்லை, எனவே headless VPS-ல் நீங்கள் உள்ளமைக்கப்பட்ட மூலங்களை மட்டுமே பெறுவீர்கள்.

இறக்குமதி எண்ணிக்கைகள் (import counters) ஒத்துப்போகாது, இது எதிர்பார்க்கப்படுவதுதான். Scanner செய்திகளை மூலம் மற்றும் உரையாடல் வாரியாக வகைப்படுத்துகிறது, பின்னர் ஒவ்வொரு முழுமையான சுற்றிற்கும் (turn) ஒரு L1 நினைவகத்தை எழுதுகிறது. பயனர் உள்ளடக்கம் காலியாக இல்லாமல், உதவியாளர் செய்தியுடன் முடிவடையும் போது ஒரு சுற்று முழுமையானதாகக் கருதப்படுகிறது; எனவே, முழுமையற்ற சுற்று பிற்காலத்தில் sync மூலம் முழுமையடையும் வரை எதையும் சேர்க்காது. செய்திகள், உரையாடல் checkpoints மற்றும் நிலையான turn ID-கள் மூலம் நகல் நீக்கம் (deduplication) செய்யப்படுகின்றன. ஸ்கேன் செய்யப்பட்ட எண்ணிக்கை, இறக்குமதி செய்யப்பட்ட செய்திகளின் எண்ணிக்கை மற்றும் புதிய நினைவக எண்ணிக்கை ஆகியவை ஒரே run-ல் மாறுபடும்.

இது Claude Code ஒரு session-க்குள் சூழலை எவ்வாறு நிர்வகிக்கிறது என்பதோடு இணையும் ஒரு பகுதியாகும். சூழல் மேலாண்மை (context management) என்பது ஒரு single window-க்குள் எவை பொருந்தும் என்பதைத் தீர்மானிக்கிறது. ஒரு memory hub என்பது அந்த window மூடப்பட்ட பிறகு எவை நிலைத்திருக்கும் என்பதைத் தீர்மானிக்கிறது.

VPS-ல் உங்களுக்குத் தேவையானவை

  • Node.js 22 அல்லது அதற்குப் புதிய பதிப்பு. Memmy ஆவணங்களுக்கு இது தேவை, ஆனால் Ubuntu 24.04-ல் Node 18 மட்டுமே உள்ளது.
  • git மற்றும் ஒரு build toolchain, ஏனெனில் better-sqlite3 என்பது நிறுவலின் போது compile செய்யப்பட வேண்டிய ஒரு native module ஆகும்.
  • root workspace நிறுவல் மற்றும் அதன் frontend build chain-க்குத் தேவையான RAM.
  • node_modules மற்றும் database-க்குத் தேவையான காலி வட்டு இடம் (free disk).
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 கட்டளை, ஆவணப்படுத்தப்பட்ட source build-க்கு v22 அல்லது அதற்கு மேற்பட்ட பதிப்பைக் காட்ட வேண்டும். இங்கே v18 என்று வந்தால், NodeSource படிமுறை சரியாகச் செயல்படவில்லை என்று அர்த்தம். npm-ன் engine-strict இயல்பாகவே false என்று இருப்பதால், பொருந்தாத engine declaration பொதுவாக நிறுவலைத் தானாகவே நிறுத்தாமல் ஒரு எச்சரிக்கையை மட்டுமே காட்டும்.

Ubuntu 24.04-ல் source-லிருந்து Memmy-ஐ நிறுவுதல்

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-க்கு compile செய்கிறது. இது AgentSourceCore, memory viewer மற்றும் அந்த workspace-க்குத் தேவையான integration assets ஆகியவற்றையும் உருவாக்குகிறது. native module சரியாக load ஆகியுள்ளதா என்பதைச் சரிபார்க்கவும்:

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

அந்த வரியை இயக்கும்போது output வருவதற்குப் பதிலாக error வந்தால், load அல்லது database initialization தோல்விக்கான காரணத்தைக் கண்டறிய அந்த error-ஐப் படிக்கவும். native module பொருந்தவில்லை எனில், npm rebuild better-sqlite3-ஐ இயக்கவும்; எதையும் தொடங்குவதற்கு முன்பு இந்த project-ன் சொந்த start script சரியாக இதைத்தான் செய்கிறது.

README ஆவணத்தில் bash scripts/dev-start.sh என்பது ஒரே கட்டளையில் தொடங்குவதற்கான வழியாகக் குறிப்பிடப்பட்டுள்ளது. இதை headless VPS-ல் இயக்க வேண்டாம். இது memory service-க்கு அருகில் port 19000-ல் Electron desktop shell மற்றும் Vite dev server-ஐத் தொடங்குகிறது. Electron-க்கு display தேவை என்பதால், graphical session இல்லாத server-ல் இந்த script நின்றுவிடும் அல்லது வெளியேறிவிடும்.

சமீபத்திய releases-ல் Linux x64 மற்றும் arm64-க்கான memmy-agent-linux-cli.tar.gz மற்றும் install.sh ஆகியவையும் இணைக்கப்பட்டுள்ளன. இந்த installer-க்கு Node.js 22.x-ல் 22.23.4+, 24.x-ல் 24.22.1+, அல்லது 26.x-ல் 26.12.1+ ஆகிய பதிப்புகளும், systemd user session-உம் தேவை; மற்ற major versions-ஐ இது ஏற்காது. இது memmy மற்றும் memmy-memory launchers-ஐ ~/.local/bin-ல் வைக்கிறது, மேலும் memory service-ஐ 127.0.0.1:18960-ல் user unit-ஆகத் தொடங்குகிறது. ஒவ்வொரு script-ஐயும் இயக்கும் முன் வாசிக்க முடியும் என்பதால், இந்த வழிகாட்டி source build முறையையே பின்பற்றுகிறது.

Memory service-ஐத் தொடங்கி, அது பதிலளிக்கிறதா எனச் சரிபார்க்கவும்

npm run memory:serve:dev

Memory service-ஐ source-லிருந்து இயக்குவதற்கான ஆவணப்படுத்தப்பட்ட வழி இதுவாகும். இது 127.0.0.1:18960-ல் பிணைக்கப்பட்டு (bind), ~/.memmy/memory-service/memory.sqlite-ல் தரவுத்தளத்தைப் பராமரித்து, ~/.memmy/config.yaml-லிருந்து உள்ளமைவை (config) வாசிக்கிறது. நீங்கள் மதிப்புகளைத் தெளிவாகக் குறிப்பிட விரும்பினால், server அதே மதிப்புகளை flags-ஆக ஏற்றுக்கொள்கிறது:

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

இரண்டாவது shell-லிருந்து, service இயங்குகிறதா என்று கேட்கவும்:

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

Health சரிபார்ப்பிற்கு token தேவையில்லை, அதனால்தான் இது சரியான probe ஆகும். curl கட்டளை code 7 மற்றும் Failed to connect to 127.0.0.1 port 18960 செய்தியுடன் வெளியேறினால், இணைப்பு தோல்வியடைந்தது என்று அர்த்தம்; listener உள்ளதா என்பதை இது மட்டும் உறுதிப்படுத்தாது. முகவரி, port மற்றும் local firewall ஆகியவற்றைச் சரிபார்க்கவும், மேலும் service தொடங்கும் போது ஏற்படும் பிழைகளைக் காண அந்த terminal-ஐ வாசிக்கவும். service இயங்கியதும் ss -lntp | grep 18960 socket-ஐ உறுதிப்படுத்தும்.

HTTP API-ன் (application programming interface) பிற பகுதிகள் /api/v1-க்குக் கீழ் உள்ளன.

  • POST /api/v1/memory/add memory-ஐ எழுதுகிறது மற்றும் POST /api/v1/memory/search வினவுகிறது (query).
  • 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 ஒரு turn-ஐப் பதிவு செய்கின்றன.
  • GET /api/v1/panel/overview, /api/v1/panel/analysis மற்றும் /api/v1/panel/items dashboard-க்குத் தரவை வழங்குகின்றன.

Memmy ஒரு தொகுதி ports-ஐ ஒதுக்குகிறது, headless முறையில் நீங்கள் முதல் port-ஐ மட்டுமே பயன்படுத்துவீர்கள்: memory-க்கு 18960, gateway health-க்கு 18970, web UI மற்றும் admin HTTP-க்கு 18980, memmy serve தொடங்கும் OpenAI-இணக்கமான API-க்கு 18990, desktop frontend-ன் Vite dev server-க்கு 19000 மற்றும் அதன் hot reload socket-க்கு 19001. திட்டத்தின் ports பக்கத்தில் இன்னும் 19010 hot reload-க்காகப் பட்டியலிடப்பட்டுள்ளது, ஆனால் Vite உள்ளமைவு 19001-ஐ அமைக்கிறது. உங்கள் கணினியில் ஏதேனும் ஒன்று ஏற்கனவே அந்த ports-ல் இயங்கினால், அந்தப் பட்டியலைப் பார்க்கவும்.

memmy-memory கட்டளை எங்கிருந்து வருகிறது

முதல்முறை நிறுவும்போதுதான் பெரும்பாலும் பிழைகள் ஏற்படும், எனவே யூகிக்காமல் தொகுப்பிலிருந்து (package) நேரடியாகப் படியுங்கள். கட்டளையின் பெயருக்கும் களஞ்சியத்தின் (repository) பெயருக்கும் எந்தத் தொடர்பும் இல்லை. இது அதை வரையறுக்கும் workspace-ன் bin புலத்திலிருந்து (field) வருகிறது:

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-ல் சுருக்கமான பெயர் தேவைப்பட்டால், அதே கோப்பிற்கு link உருவாக்கவும்:

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 ஆகும். இவை தவிர, மனிதர்களுக்குப் பதிலாக agents பயன்படுத்தும் session மற்றும் turn அழைப்புகள் உள்ளன. மேலும், சேவையை நிர்வகிக்க install, upgrade, service மற்றும் stop பயன்படுகின்றன. ஒரு agent பெரும்பாலும் memmy-memory search "deploy steps" மற்றும் memmy-memory add "staging migrates on deploy" ஆகிய இரண்டையே அதிகம் இயக்கும்.

Claude Code-ஐ Memmy-உடன் எவ்வாறு இணைப்பது?

Memmy தன்னை Claude Code-க்குள் ஒரு server-ஆகப் பதிவு செய்துகொள்வதில்லை. Claude Code ஏற்கனவே வாசிக்கும் கோப்புகள் மூலமாகவே இது இணைகிறது, மேலும் நீங்கள் இயக்கும் memmy-memory-ஐப் பொறுத்தே அதன் செயல்பாடு அமையும். Source checkout-லிருந்து, memmy-memory init --agent claude ஒரு memmy-memory Skill-ஐ ~/.claude/skills/-லும், ஒரு குறிக்கப்பட்ட memory block-ஐ ~/.claude/CLAUDE.md-லும் எழுதுகிறது. அந்த அறிவுறுத்தல்கள் கூறும்போது, Claude Code memmy-memory-ஐ ஒரு சாதாரண shell command-ஆக இயக்குகிறது. Linux installer ~/.local/bin-ல் வைக்கும் launcher இன்னும் கூடுதலாகச் செயல்படுகிறது: அதே command ~/.claude/settings.json-ல் SessionStart, UserPromptSubmit, Stop, PostCompact மற்றும் SessionEnd ஆகியவற்றிற்கான hooks-ஐயும் பதிவு செய்கிறது. இவை, model முடிவெடுக்க வேண்டிய அவசியமின்றி, தொடர்புடைய memory-ஐ உள்ளீடு செய்து ஒவ்வொரு சுற்றையும் சேமிக்கின்றன.

அறிவுறுத்தலை ஒருமுறை கையால் எழுதவும், ஏனெனில் அப்போதுதான் அந்த agent-க்கு என்ன சொல்லப்பட்டது என்பது உங்களுக்குத் துல்லியமாகத் தெரியும். ஒவ்வொரு session-ன் தொடக்கத்திலும் Claude Code project root-லிருந்து CLAUDE.md-ஐ வாசிக்கிறது, எனவே இது போன்ற ஒரு பகுதி source 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.

இதன் மூலம் உங்களுக்குக் கிடைக்கும் பயன் என்ன என்பதைத் தெளிவாகப் புரிந்துகொள்ளுங்கள். Hooks இல்லையென்றால், இது instruction level ஒருங்கிணைப்பாக மட்டுமே இருக்கும்; அதாவது model அந்த command-ஐ இயக்க முடிவெடுத்தால் மட்டுமே இது செயல்படும். கட்டாயப்படுத்தி எந்த அழைப்பும் செய்யப்படாது. ஒரு session add இல்லாமல் முடிந்தால், அந்த அறிவுறுத்தல் எதையும் சேமிக்காது; இருப்பினும், பிற்காலத்தில் history-ஐ scan செய்வதன் மூலம் அந்தச் சுற்றை import செய்ய முடியும். இது Claude Code-ன் சொந்த memory கோப்புகள் வழங்கும் அதே வர்த்தக பரிமாற்றம் (trade-off) தான், ஆனால் ஒரு சிறிய வேறுபாடு உள்ளது: இதில் store பகிரப்பட்டிருப்பதால், அதே machine-ல் உள்ள Codex மற்றும் Cursor-க்கும் இந்த note சென்றடையும். Hooks-கள் மென்மையாகக் கேட்பதற்குப் பதிலாக இடைவெளியை நிரப்புகின்றன. இதனால்தான், நீடித்த memory (durable memory), budget caps மற்றும் permission விதிகள் ஆகியவற்றுடன் சேர்த்து, நிறுவ வேண்டிய DeepSeek Harness plugins பட்டியலில் இதுவும் இடம்பெறுகிறது.

மறுதிசையில் எந்த அமைப்பும் (setup) தேவையில்லை. Memmy-ன் scanner ஏற்கனவே ~/.claude/projects/**/*.jsonl-ஐ வாசிக்கிறது, அங்குதான் Claude Code தனது session transcripts-ஐ எழுதுகிறது. tmux session-க்குள் Claude Code-ஐ இயக்கும் அதே server-ல் Memmy-ஐயும் இயக்கினால், நீங்கள் எதையும் configure செய்யாமலேயே நேற்றைய பணி memory-ஆக மாறிவிடும்.

Memmy ஒரு MCP server-ஆக Claude Code-க்கு வேலை செய்யுமா?

இல்லை, இந்தத் திசையை அறிந்துகொள்வது உங்கள் நேரத்தை மிச்சப்படுத்தும். MCP (model context protocol)-ல் clients மற்றும் servers என இரு வகைகள் உள்ளன. Memmy ஒரு client ஆகும். இது MCP servers-உடன் இணைந்து, அவற்றின் கருவிகளைத் தனது சொந்த agent runtime-க்கு வழங்குகிறது. இது claude mcp add சுட்டிக்காட்டக்கூடிய ஒரு MCP endpoint-ஐ வெளியிடுவதில்லை. இந்த repository-ல் உள்ள ஒரே MCP bridge, desktop local API-க்குள் இருக்கும் Composio integration மட்டுமே. அந்த API, x-memmy-mcp-token header-க்கு பின்னால் 127.0.0.1-ல் ஒரு random port-ஐ bind செய்கிறது.

Client side அமைப்பு MEMMY_CONFIG சுட்டிக்காட்டும் ~/.memmy/config.yaml கோப்பில், tools.mcpServers-க்கு கீழ் செய்யப்படுகிறது:

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

type ஆனது stdio, sse மற்றும் streamableHttp ஆகியவற்றை ஏற்கும். ஒரு stdio server, Memmy-ன் child process-ஆக இயங்கும். அதாவது, அதன் command அதே machine-ல் இருக்க வேண்டும் மற்றும் அதே user-ஆக இயங்க வேண்டும். நீங்கள் ஏற்கனவே VPS-ல் MCP servers-ஐ இயக்கி வருகிறீர்கள் என்றால், அவற்றை இங்கே பட்டியலிடலாம்.

மெமரி ஸ்டோரைத் தனிப்பட்டதாக வைத்திருத்தல்

Memmy-க்குச் சொந்தமான அனைத்தும் ~/.memmy-ன் கீழ் உள்ளன: config.yaml, வொர்க்ஸ்பேஸ், memory-service/memory.sqlite மற்றும் ரன்டைம் கோப்புகள். ஸ்கேனிங் மற்றும் உள்ளீடு (ingestion) உள்ளூர் அளவில் நடைபெறுகின்றன, மேலும் மெமரி தகவல்கள் அந்த உள்ளூர் SQLite கோப்பில் எழுதப்படுகின்றன, எனவே இயல்புநிலை அமைப்பு முற்றிலும் உள்ளூர் சார்ந்ததாகவே உள்ளது.

கவனிக்க வேண்டிய ஒரு பாதை கிளவுட் இணைப்பு ஆகும். MEMMY_CLOUD_SERVICE கிளவுட் மூலத்தைக் குறிப்பிடுகிறது. இதற்கான இயல்புநிலை மதிப்பை நிரல் அமைப்பதில்லை, ஆனால் நிறுவல் படிகளின் போது .env-க்கு நகலெடுக்கப்படும் .env.example, இதை https://api.memmy.cn என அமைக்கிறது. இது அதன் ட்ரையல் டோக்கன்களுடன் அக்கவுண்ட் மோடை ஆதரிக்கிறது. இது அமைக்கப்பட்டிருக்கும்போது, API கீ மோடிலும் Memmy-ன் அனலிட்டிக்ஸ் குறியீடு பயன்பாட்டு நிகழ்வுகளை (usage events) அதற்கு அனுப்பும்: நிகழ்வு மற்றும் கட்டளைப் பெயர்கள், பதிப்புகள் மற்றும் ஒரு இன்ஸ்டாலேஷன் ஐடி (installation ID). CLI நிலையான கட்டளைச் சொற்களை மட்டுமே தெரிவிக்கும், தேடல் வினவல்களையோ அல்லது மெமரி உரையையோ ஒருபோதும் அனுப்பாது. மேலும், இந்த மதிப்பு அமைக்கப்படாதபோது அனலிட்டிக்ஸ் குறியீடு எதையும் அனுப்பாது, எனவே API கீகளை மட்டுமே பயன்படுத்தும் சர்வரில், எதையும் தொடங்குவதற்கு முன் .env-ல் உள்ள அந்த வரியை காலி செய்யவும். மெமரி மேம்பாட்டுத் திட்டம் (memory improvement program) என்பது பிரைவசி செட்டிங்ஸில் உள்ள ஒரு தனிப்பட்ட சுவிட்ச் ஆகும்.

மாடல் அழைப்புகள் (Model calls) மற்றொரு பாதையாகும். நீங்கள் ஹோஸ்ட் செய்யப்பட்ட எம்பெடிங் (embedding) வழங்குநரை அமைத்தால், எம்பெடிங் செய்யப்படும் மெமரி உரை அந்த வழங்குநருக்கு அனுப்பப்படும், அப்போதுதான் அது வெக்டராக மாற்றப்படும். உள்ளூர் சேமிப்பு (local storage) இதற்கு உதவாது. அந்தப் பாதையை மூடுவதற்கு, உள்ளமைக்கப்பட்ட உள்ளூர் எம்பெடிங் வழங்குநரைப் பயன்படுத்தவும் அல்லது நீங்களே ஹோஸ்ட் செய்யும் எம்பெடிங் எண்ட்பாயிண்டைப் பயன்படுத்தவும். ஹோஸ்ட் செய்யப்பட்ட சுருக்கம் (summary), பரிணாமம் (evolution) மற்றும் பொருத்தமான-வடிகட்டி (relevance-filter) மாடல்களும் அந்தப் பணிகள் இயங்கும்போது மெமரி உள்ளடக்கத்தைப் பெறுகின்றன, எனவே அந்த மாடல் அமைப்புகளையும் சரிபார்க்கவும்.

18960 போர்ட்டை லூப்பேக் அட்ரஸில் (loopback address) வைத்திருங்கள். இதற்கு ஃபயர்வால் விதி தேவையில்லை, ஏனெனில் 127.0.0.1-ல் பிணைக்கப்பட்ட (bound) ஒரு சர்வீஸை சர்வருக்கு வெளியிலிருந்து அணுக முடியாது. அதற்குப் பதிலாக உங்கள் லேப்டாப்பிலிருந்து SSH மூலம் அதை அணுகுங்கள்:

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

தற்போதைய மெமரி சர்வீஸ் லூப்பேக் அல்லாத பிணைப்பு முகவரிகளை நிராகரிக்கிறது. கான்ஃபிக் கோப்பில் storage.token-ஐ அமைப்பது அல்லது MEMMY_MEMORY_TOKEN அல்லது MEMORY_SERVICE_TOKEN என்விரான்மென்ட் வேரியபிளைப் பயன்படுத்துவது, சாதாரண மெமரி API அழைப்புகளை ஒரு பியரர் டோக்கன் (bearer token) மூலம் பாதுகாக்கிறது; ஹெல்த் செக் அங்கீகாரம் இல்லாமல் இருக்கும், மேலும் பிரவுசர் வியூவர் உள்ளூர் கோரிக்கைகளுக்குத் தனித்தனி சோதனைகளைப் பயன்படுத்துகிறது. கான்ஃபிக் மதிப்புகள் ${ENV_NAME} குறிப்புகளை ஆதரிக்கின்றன, எனவே டோக்கன் மற்றும் உங்கள் மாடல் API கீகள் கோப்பிற்கு வெளியே இருக்கும். இது மற்ற எல்லா இடங்களிலும் AI ஏஜெண்டுகளிடமிருந்து ரகசியங்களை மறைத்து வைத்தல் போன்ற அதே பழக்கமாகும், மேலும் எதிர்கால பதிப்பில் இயல்புநிலை பிணைப்பு முகவரி மாறினால், இயல்புநிலையாக அனைத்தையும் மறுக்கும் ufw கொள்கை உங்களுக்குப் பாதுகாப்பாக இருக்கும்.

~/.memmy கோப்பை காப்புப்பிரதி எடுத்தல்

memory.sqlite என்பது முழுமையான தரவுத்தளமாகும். sqlite-vec நீட்டிப்பின் மூலம் வெக்டார்கள் (vectors) அதே கோப்பிலேயே சேமிக்கப்படுகின்றன, எனவே ஒரே ஒரு கோப்பை மட்டும் காப்புப்பிரதி எடுத்தால் போதுமானது. சேவை இயங்கிக்கொண்டிருக்கும்போது cp கட்டளையைப் பயன்படுத்தி நகலெடுப்பது, தரவுத்தளம் சிதைவடைய (torn database) காரணமாகலாம். அதற்குப் பதிலாக SQLite-ன் சொந்த காப்புப்பிரதி கட்டளையைப் பயன்படுத்தவும்:

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

இது சேவை இயங்கிக்கொண்டிருக்கும்போதே தரவுத்தளத்தின் சீரான நகலை உருவாக்குகிறது. இதை ஒரு கால அட்டவணையின்படி (schedule) சர்வரிலிருந்து வெளியே அனுப்ப வேண்டும், இதற்குத்தான் restic to off-site storage பயன்படுகிறது. config.yaml கோப்பை இழந்தால், நீங்கள் மீண்டும் உள்ளிடக்கூடிய provider அமைப்புகளை மட்டுமே இழப்பீர்கள். ஆனால் memory.sqlite கோப்பை இழந்தால், உங்கள் கடைசி காப்புப்பிரதிக்கு பிறகு சேமிக்கப்பட்ட நினைவுகளை இழக்க நேரிடும்; சேவை schema மாற்றங்களுக்கு (schema migrations) முன்பாக ஒரு உள்ளூர் காப்புப்பிரதியை உருவாக்கும், ஆனால் அது தற்போதைய off-site நகல் அல்ல.

systemd-ன் கீழ் memory service-ஐ இயக்குதல்

npm run memory:serve:dev-ஐ shell-ல் இயக்கினால், shell மூடும்போது அதுவும் நின்றுவிடும். ஒரு unit file, reboot-க்கு பிறகும் service-ஐத் தொடர்ந்து இயங்க வைக்கும். இது memmy பயனராக, /opt/memmy-ல் உள்ள checkout-லிருந்து, அந்தப் பயனரின் home directory-ல் உள்ள config கோப்புடன் இயங்கும். உங்கள் 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 தனது database-ஐ /home/memmy/.memmy-ன் கீழ் வைத்திருக்கும், எனவே இது காலியான store-உடன் தொடங்கும்.

[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 file-க்குள் வைக்க வேண்டாம். அதை /etc/memmy/memory.env-ல் வைக்கவும்; அதன் உரிமையாளர் root ஆகவும், mode 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 output-ல் status=203/EXEC என்று வந்தால், systemd-ஆல் ExecStart-ஐ இயக்க முடியவில்லை என்று அர்த்தம். எனவே which npm-ஐச் சரிபார்க்கவும்: இது NodeSource install-ல் /usr/bin/npm ஆக இருக்கும், nvm பயன்படுத்தினால் பயனரின் home directory-க்குள் இருக்கும், இதை systemd கண்டறியாது. ஒரு unit தொடங்கி உடனே நின்றுவிட்டால், அதன் exit status மற்றும் journal-ஐச் சரிபார்க்க வேண்டும்: code 0 என்பது வெற்றிகரமான வெளியேற்றம், மற்றவை non-zero exits, signals அல்லது timeouts ஆக இருக்கலாம். Service-ன் output-ஐப் பார்க்க journalctl -u memmy-memory -n 50-ஐ இயக்கவும். இதன் செயல்பாடுகள் VPS-ல் உள்ள மற்ற எந்த systemd service-க்கும் சமமானவை.

இந்தத் திட்டம் இப்போது இரண்டு பயனர்-நிலை மாற்றுகளை வழங்குகிறது. Source build-க்கான README வழிமுறை memmy-memory install --service-only ஆகும்; இது pinned Memory runtime-ஐத் தரவிறக்கம் செய்து பயனர் service-ஐப் பதிவு செய்யும். Linux installer memmy-memory.service-ஐ systemd --user unit-ஆக அமைக்கும். இவை எதுவும் linger-ஐ enable செய்யாது, எனவே logout செய்த பிறகும் பயனர் service manager இயங்கவும், boot-ன் போது தொடங்கவும் sudo loginctl enable-linger <user>-ஐ இயக்கவும்.

Memmy இன்னும் செய்யாதவை

  • இதில் Linux desktop build இல்லை. Packaging scripts macOS மற்றும் Windows-ஐ மட்டுமே உள்ளடக்கியுள்ளன, எனவே workbench மற்றும் அதன் onboarding wizard ஆகியவை server-ல் கிடைக்காது. Memory service இப்போது http://127.0.0.1:18960/viewer/-ல் ஒரு browser viewer-ஐக் கொண்டுள்ளது, இதை மேலே உள்ள SSH tunnel மூலம் அணுகலாம். Linux-க்கு CLI tarball மற்றும் install.sh மட்டுமே வழங்கப்படுகிறது.
  • memory:serve:dev, TypeScript entry point-ஐ tsx வழியாக இயக்குகிறது, இது ஒரு development path ஆகும். இந்த repository compiled output-க்காக memory:serve-ஐயும் வழங்குகிறது. உங்கள் checkout-ல் என்னென்ன scripts உள்ளன என்பதைப் பார்க்க, எந்த arguments-ம் இன்றி npm run-ஐ இயக்கவும்.
  • Retrieval, அதன் search window-ஐ சமீபத்திய 2,000 vector rows-லிருந்து உருவாக்குகிறது, பின்னர் அந்த window-க்குள் Top-K selection-ஐப் பயன்படுத்துகிறது. மிகப்பாரிய store-ல், ஒரு பழைய memory இதற்கு வெளியே இருக்கக்கூடும்.
  • Embedding, capture செய்த பிறகு நடக்கும். இதில் தோல்வி ஏற்பட்டால், அது agent-ன் செயல்பாட்டைத் தடுக்காமல், retry queue-க்குச் செல்லும். சற்று முன்பு சேர்க்கப்பட்ட ஒரு memory, vector search மூலம் இன்னும் கண்டறியப்படாமல் இருக்கலாம்.
  • சொந்தமாக local SQLite database-ஐக் கொண்ட இரண்டாவது server, தனித்தனி memory-ஐக் கொண்டிருக்கும்.

1 November 2026 நிலவரப்படி, Version 1.2.401 என்பது வேகமாக வளர்ந்து வரும் ஒரு புதிய திட்டமாகும். Flags, paths மற்றும் script பெயர்கள் releases-க்கு இடையே மாறக்கூடும். எங்காவது நகலெடுக்கப்பட்ட கட்டளையை நம்புவதை விட, உங்கள் சொந்த checkout-ல் உள்ள bin field மற்றும் npm run-ன் வெளியீட்டைப் படிக்கவும்.

FAQ

health check ஏன் connection refused என்று காட்டுகிறது?

Failed to connect to 127.0.0.1 port 18960 உடன் கூடிய curl exit code 7, இணைப்பு தோல்வியடைந்ததைக் குறிக்கிறது. இது Memmy நிறுத்தப்பட்டதா, செயலிழந்ததா, வேறு இடத்தில் இயங்குகிறதா அல்லது அணுக முடியாததா என்பதைத் தெரிவிக்காது. முகவரி மற்றும் port-ஐச் சரிபார்க்கவும், ss -lntp | grep 18960-ஐ இயக்கவும், மேலும் service தொடங்கப்பட்ட terminal அல்லது journal-ஐப் படிக்கவும். log-ல் native SQLite module பொருந்தவில்லை என்று காட்டினால், npm rebuild better-sqlite3-ஐ இயக்கவும். உங்கள் Node version-ஐயும் சரிபார்க்கவும்: source docs-க்கு Node 22 அல்லது அதற்குப் பிந்தைய பதிப்பு தேவை. Linux installer, Node.js 22.x-ல் 22.23.4+, 24.x-ல் 24.22.1+, அல்லது 26.x-ல் 26.12.1+ ஆகிய பதிப்புகளை மட்டுமே ஏற்கும்.

source-லிருந்து build செய்த பிறகு memmy-memory command எங்கிருந்து வருகிறது?

இது repository பெயரிலிருந்து அல்ல, @memmy/memory workspace package-ன் bin field-லிருந்து வருகிறது. checkout-க்குள் node -p "JSON.stringify(require('./Memory/package.json').bin)"-ஐ இயக்கினால் அது {"memmy-memory":"./dist/src/cli/index.js"}-ஐ அச்சிடும். npm run memory:build-க்கு பிறகுதான் அந்த file உருவாகும், ஏனெனில் build செயல்முறை dist-ஐ உருவாக்கி அந்த file-ஐ executable-ஆக மாற்றுகிறது. இதை node Memory/dist/src/cli/index.js health என்று இயக்கவும், அல்லது சுருக்கமான பெயருக்கு /usr/local/bin-க்குள் symlink செய்யவும்.

claude mcp add மூலம் Memmy-ஐ Claude Code-ல் சேர்க்க முடியுமா?

முடியாது. Memmy என்பது ஒரு MCP client, MCP server அல்ல. இது ~/.memmy/config.yaml-ல் உள்ள tools.mcpServers-ன் கீழ் பட்டியலிடப்பட்டுள்ள server-களுடன் இணைந்து, அவற்றின் கருவிகளைத் தனது runtime-க்கு வழங்குகிறது. Claude Code, Memmy-ஐ வேறு வழியில் அணுகுகிறது; அதாவது memmy-memory CLI-ஐ ஒரு shell command-ஆக இயக்குகிறது. memmy-memory init --agent claude ஒரு Skill மற்றும் CLAUDE.md block-ஐ எழுதுகிறது, இது எப்போது செயல்பட வேண்டும் என்று அதற்குத் தெரிவிக்கும். Linux installer-ல் உள்ள launcher, Claude Code hooks-ஐயும் சேர்க்கிறது, இது தானாகவே turns-ஐச் சேமிக்கும்.

Memmy-ஐ இயக்குவது எனது நினைவுகளை cloud service-க்கு அனுப்புமா?

Scanning மற்றும் ingestion உள்ளூர் கணினியிலேயே நடைபெறுகிறது, மேலும் நினைவுகள் உங்கள் disk-ல் உள்ள ~/.memmy/memory-service/memory.sqlite-ல் எழுதப்படுகின்றன. .env.example-ல் https://api.memmy.cn என அமைக்கப்பட்டுள்ள MEMMY_CLOUD_SERVICE, account mode மற்றும் trial tokens-ஐ வழங்குகிறது. இது அமைக்கப்பட்டிருக்கும் வரை, நினைவுகளின் உரை (memory text) இல்லாமல் பயன்பாட்டுத் தரவுகளை (usage analytics) பெறும். எனவே, நீங்கள் API keys-ஐ மட்டுமே பயன்படுத்துகிறீர்கள் என்றால் அதை நீக்கிவிடவும். நினைவுகளை மேம்படுத்தும் திட்டத்திற்குத் தனிப்பட்ட privacy toggle உள்ளது. Hosted embedding model, அது vector-ஆக மாற்றும் நினைவுகளின் உரையைப் பெறும்; அந்தச் செயல்பாட்டை உள்ளூரிலேயே வைத்திருக்க, உள்ளமைக்கப்பட்ட local provider-ஐ அல்லது நீங்கள் இயக்கும் endpoint-ஐப் பயன்படுத்தவும். Hosted summary, evolution மற்றும் relevance-filter மாதிரிகளும் அந்தப் பணிகள் நடக்கும்போது நினைவுகளின் உள்ளடக்கத்தைப் பெறும்.

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?

#memmy#memory#ai-agents#mcp#self-hosted