SSD Nodes Learn 🎉 VPS $5.50/மாதம் முதல்
கல்வி வழிகாட்டிகள் Matt Connorஆல் Matt Connor · புதுப்பிக்கப்பட்டது 2026-08-03

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 என்பது உங்கள் சொந்த VPS-ல் (virtual private server) இயங்கும் AI agents-க்கான ஒரு உள்ளூர் memory hub ஆகும். இது உங்கள் agents கற்றுக்கொண்டவற்றை ஒரே ஒரு SQLite database-ல் சேமித்து வைக்கிறது. அந்த server-ல் உள்ள அனைத்து agents-ம் அதே சேமிப்பகத்திலிருந்து தகவல்களைப் படிக்கவும் எழுதவும் செய்கின்றன. இந்தத் திட்டம் MemTensor-லிருந்து memmy-agent ஆகக் கிடைக்கிறது, இது MIT உரிமம் பெற்றது மற்றும் ஜூலை 2026 நிலவரப்படி 1.0.4 பதிப்பில் உள்ளது.

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

Memmy தான் சேமிக்கும் தகவல்களை நான்கு அடுக்குகளாகப் பிரிக்கிறது. L1 Trace என்பது மூலத் தரவு: அதாவது கோரிக்கை (request), பதில் (response) மற்றும் tool calls. L2 Policy என்பது பயனுள்ளதாக நிரூபிக்கப்பட்ட traces-லிருந்து பெறப்பட்ட ஒரு செயல்முறை ஆகும். L3 World Model என்பது ஒரு திட்டம் அல்லது சூழலைப் பற்றிய நிலையான அறிவு. Skill என்பது ஒரு policy-லிருந்து உருவாக்கப்பட்ட, அழைக்கக்கூடிய (callable) ஒரு செயல்முறை ஆகும். ஒரு தரவை உள்ளீடு செய்யும்போதே service அதற்கான அடுக்கை ஒதுக்கிவிடும், எனவே நீங்கள் அவற்றை கைமுறையாக உருவாக்க வேண்டியதில்லை.

கருவி சார்ந்த நினைவகத்துடன் ஒப்பிடும்போது பகிரப்பட்ட நினைவக மையம் (shared memory hub) எதை மாற்றுகிறது

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

ஒரு மையம் (hub) இந்தச் சேமிப்பகத்தை கருவியிலிருந்து வெளியே கொண்டு வருகிறது. Memmy ஏற்கனவே உள்ள சேமிப்பகங்களையும் வாசிப்பதால், நீங்கள் காலியான database-லிருந்து தொடங்க வேண்டியதில்லை. அதன் scanner ஆறு ஆதாரங்களை அறியும்: ~/.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. நீங்கள் ஒரு ஆதாரத்தை அதன் பெயர் மற்றும் local path-ஐக் கொண்டு கைமுறையாகச் சேர்க்கலாம்.

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

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

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

  • Node.js 22 அல்லது அதற்குப் புதிய பதிப்பு. Memmy ஆவணங்களுக்கு இது தேவை, ஆனால் Ubuntu 24.04-ல் Node 18 மட்டுமே உள்ளது.
  • git மற்றும் ஒரு build toolchain, ஏனெனில் better-sqlite3 என்பது நிறுவலின் போது compile ஆகக்கூடிய ஒரு native module ஆகும்.
  • சுமார் 2 GB RAM. root install ஒரு பெரிய workspace மற்றும் frontend build chain-ஐ பதிவிறக்கம் செய்யும்.
  • node_modules மற்றும் database-க்காக சில GB காலி வட்டு இடம் (disk space).
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 check-ல் நிறுவல் தோல்வியடையும்.

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 செய்கிறது. Headless server-க்கு இந்த tree-ல் உள்ள மற்ற எதையும் build செய்ய வேண்டிய அவசியமில்லை. Native module சரியாக load ஆகியுள்ளதா எனச் சரிபார்க்கவும்:

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

இந்த command எதையும் print செய்வதற்குப் பதிலாக error-ஐக் காட்டினால், உங்கள் Node version-க்கு ஏற்ற 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 இயங்காமல் நின்றுவிடும் அல்லது வெளியேறிவிடும்.

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

npm run memory:serve:dev

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

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) தேவையில்லாத ஒரே endpoint ஆகும், எனவே இதுவே சரியான probe ஆகும். curl கட்டளை code 7 மற்றும் Failed to connect to 127.0.0.1 port 18960 செய்தியுடன் வெளியேறினால், எந்தச் சேவையும் அந்த port-ல் இயங்கவில்லை என்று அர்த்தம். service இயங்கும் terminal-ஐப் படிக்கவும், ஏனெனில் தொடக்கத்திலேயே ஏற்படும் crash அங்கு பதிவாகும். பொதுவாக, native SQLite module சரியாக ஏற்றப்படாததே இதற்குக் காரணமாக இருக்கும். 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 ஒரு குறிப்பிட்ட port தொகுப்பை ஒதுக்குகிறது. headless முறையில் நீங்கள் முதல் port-ஐ மட்டுமே பயன்படுத்துவீர்கள்: memory-க்கு 18960, gateway health-க்கு 18970, web UI மற்றும் admin HTTP-க்கு 18980, memmy serve தொடங்கும் OpenAI-compatible API-க்கு 18990, மற்றும் desktop frontend-ன் dev server-க்கு 19000 மற்றும் 19010. உங்கள் கணினியில் ஏதேனும் ஒரு service ஏற்கனவே இந்த port-களில் ஒன்றைப் பயன்படுத்தினால், இந்தப் பட்டியலைச் சரிபார்க்கவும்.

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 அழைப்புகளும் உள்ளன. ஒரு agent பெரும்பாலும் இயக்கும் இரண்டு கட்டளைகள் memmy-memory search "deploy steps" மற்றும் memmy-memory add "staging migrates on deploy" ஆகும்.

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

Claude Code-ல் memory plugin interface இல்லை, எனவே Memmy அதனுடன் நேரடியாக இணைக்கப்படாது. இந்த ஒருங்கிணைப்பு மிகவும் எளிமையானது. Claude Code ஒரு சாதாரண shell command-ஆக memmy-memory-ஐ இயக்குகிறது, மேலும் ஒரு instruction file எப்போது அதை இயக்க வேண்டும் என்று அதற்குத் தெரிவிக்கிறது. Memmy-ன் ஆவணப்படுத்தப்பட்ட installer உங்களுக்காக அந்த file-ஐ உருவாக்குகிறது: memmy-memory init --agent ஒரு memory instruction file-ஐ இலக்கு agent-ன் rules directory-க்குள் சேர்க்கிறது.

இந்த instruction-ஐ ஒருமுறை நீங்களே கைமுறையாக எழுதுங்கள், அப்போதுதான் அந்த agent-க்கு என்ன அறிவுறுத்தப்பட்டது என்பது உங்களுக்குத் துல்லியமாகத் தெரியும். ஒவ்வொரு session-ன் தொடக்கத்திலும் project root-லிருந்து CLAUDE.md-ஐ Claude Code வாசிக்கும், எனவே இது போன்ற ஒரு பகுதிதான் முழுமையான ஒருங்கிணைப்பு:

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

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

மறு திசையில் எந்த அமைப்பும் (setup) தேவையில்லை. Memmy-ன் scanner ஏற்கனவே ~/.claude/projects/**/*.jsonl-ஐ வாசிக்கிறது, அங்குதான் Claude Code தனது session transcripts-ஐ எழுதுகிறது. Claude Code inside a tmux session-ஐ நீங்கள் இயக்கும் அதே 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, பணிச்சூழல் (workspace), memory-service/memory.sqlite மற்றும் இயக்க நேரக் கோப்புகள் (runtime files). ஸ்கேனிங் மற்றும் உள்ளீடு (ingestion) ஆகியவை உள்ளூர் கணினியிலேயே நடைபெறுகின்றன, மேலும் நினைவகங்கள் அந்த உள்ளூர் SQLite கோப்பில் எழுதப்படுகின்றன. எனவே, இயல்பான செயல்பாட்டு முறை முற்றிலும் உள்ளூர் சார்ந்தது.

இரண்டு வழிகளில் மட்டும் நெட்வொர்க் தொடர்பு ஏற்படுகிறது. MEMMY_CLOUD_SERVICE இயல்பாக https://memmy-api.memtensor.cn-ஐப் பயன்படுத்துகிறது மற்றும் அதன் சோதனை டோக்கன்களுடன் கணக்கு பயன்முறையை (account mode) ஆதரிக்கிறது, எனவே API key பயன்முறையில் அது ஒருபோதும் அழைக்கப்படுவதில்லை. நினைவக மேம்பாட்டுத் திட்டம் (memory improvement program) என்பது தனியுரிமை அமைப்புகளில் உள்ள ஒரு தனி சுவிட்ச் ஆகும்; நீங்கள் அதை ஆன் செய்யும் வரை அது ஆஃப் நிலையிலேயே இருக்கும்.

மூன்றாவது வழியை கவனிப்பது சற்று கடினம். நீங்கள் ஹோஸ்ட் செய்யப்பட்ட எம்பெடிங் வழங்குநரை (hosted embedding provider) அமைத்தால், ஒவ்வொரு நினைவகத்தின் உரையும் அந்த வழங்குநருக்கு அனுப்பப்படும், அப்போதுதான் அதை வெக்டாராக மாற்ற முடியும். உள்ளூர் சேமிப்பகம் அங்கு உதவாது. நீங்கள் சுயமாக ஹோஸ்ட் செய்யும் எம்பெடிங் எண்ட்பாயிண்ட் (embedding endpoint) மட்டுமே இதைத் தடுப்பதற்கான ஒரே வழியாகும்.

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

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

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

~/.memmy கோப்பினை நம்பும் முன் காப்புப்பிரதி எடுக்கவும்

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

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

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

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

npm run memory:serve:dev-ஐ shell-ல் இயக்கினால், shell-ஐ மூடும்போது அதுவும் நின்றுவிடும். ஒரு unit file-ஐப் பயன்படுத்தினால், reboot செய்த பிறகும் service தொடர்ந்து இயங்கும்.

[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 பயன்படுத்தினால் இது user-ன் home directory-க்குள் இருக்கும், அதை systemd கண்டறியாது. ஒரு service தொடங்கி உடனே நின்றுவிட்டால், அது npm-க்குள் தோல்வியடைந்துள்ளது என்று பொருள். journalctl -u memmy-memory -n 50 கட்டளையைப் பயன்படுத்தி அதற்கான காரணத்தைக் கண்டறியலாம். இதற்கான வழிமுறைகள் VPS-ல் உள்ள பிற systemd service-களைப் போலவே இருக்கும்.

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

  • இதில் Linux desktop build இல்லை. Packaging scripts macOS மற்றும் Windows-ஐ மட்டுமே உள்ளடக்கியுள்ளன. எனவே, workbench, அதன் onboarding wizard மற்றும் memory dashboard ஆகியவை server-ல் நேரடியாகக் கிடைக்காது.
  • 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 ஒன்று அந்த window-க்கு வெளியே இருக்கக்கூடும்.
  • Embedding, capture செய்த பிறகு நடக்கும். ஏதேனும் தோல்வி ஏற்பட்டால், அது agent-ன் செயல்பாட்டைத் தடுப்பதற்குப் பதிலாக retry queue-க்குச் செல்லும். ஒரு கணம் முன்பு சேர்க்கப்பட்ட memory, vector search மூலம் உடனடியாகக் கண்டறியப்படாமல் இருக்கலாம்.
  • ஒரு SQLite file என்பது ஒரு node-ஐக் குறிக்கும். இதில் clustering வசதி இல்லை, எனவே இரண்டாவது server என்பது தனித்தனி memory-ஆகவே இருக்கும்.

Version 1.0.4 மற்றும் ஜூலை 2026 நிலவரப்படி சுமார் 329 stars என்பது இது ஒரு புதிய project என்பதைக் காட்டுகிறது. Flags, paths மற்றும் script பெயர்கள் ஒவ்வொரு release-க்கும் மாறக்கூடும். எங்காவது நகலெடுக்கப்பட்ட கட்டளையை நம்புவதை விட, உங்கள் checkout-ல் உள்ள bin field மற்றும் npm run-ன் output-ஐப் பார்க்கவும்.

FAQ

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

18960 port-ல் எந்தச் சேவையும் இயங்கவில்லை. Failed to connect to 127.0.0.1 port 18960 உடன் கூடிய curl exit code 7, memory service இயங்கவில்லை அல்லது தொடங்கும்போதே நின்றுவிட்டது என்பதைக் குறிக்கிறது. எனவே, அது தொடங்கிய terminal அல்லது journal-ஐப் பார்க்கவும். பொதுவாக இரண்டு காரணங்கள் இருக்கலாம்: உங்கள் Node version-க்கு பொருந்தாத better-sqlite3 native module, இதை npm rebuild better-sqlite3 மூலம் சரிசெய்யலாம்; மற்றொன்று 22-க்குக் குறைவான Node version. சேவை இயங்கத் தொடங்கியதும் ss -lntp | grep 18960 மூலம் socket-ஐ உறுதிப்படுத்தவும்.

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

இது 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-ஐ வேறு வழியில் அணுகுகிறது; அதாவது, முகவரின் (agent) rules directory-ல் memmy-memory init --agent எழுதும் instruction file-ன் வழிகாட்டுதலின்படி, memmy-memory CLI-ஐ ஒரு shell கட்டளையாக இயக்குகிறது.

Memmy-ஐ இயக்குவது எனது நினைவகங்களை (memories) cloud சேவைக்கு அனுப்புமா?

Scanning மற்றும் ingestion உள்ளூர் கணினியிலேயே (locally) நடைபெறுகிறது, மேலும் நினைவகங்கள் உங்கள் வட்டில் உள்ள ~/.memmy/memory-service/memory.sqlite-ல் எழுதப்படுகின்றன. MEMMY_CLOUD_SERVICE, account mode மற்றும் trial tokens-க்காக https://memmy-api.memtensor.cn-ஐக் குறிப்பிடுகிறது. நீங்கள் செயல்படுத்தும் வரை memory improvement program முடக்கப்பட்டே இருக்கும். கவனிக்க வேண்டிய பாதை embedding provider ஆகும்: hosted embedding model, தான் vector-ஆக மாற்றும் ஒவ்வொரு நினைவகத்தின் உரையையும் (text) பெறும். எனவே, இது முக்கியம் என்றால், நீங்களே இயக்கும் endpoint-ஐப் பயன்படுத்தவும்.

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