लेखक: Matt Connor 2026-07-31 · अपडेट किया गया: 2026-08-26

VPS पर Memmy local memory hub कैसे सेटअप करें

Q: हेल्थ चेक connection refused क्यों देता है?

port 18960 पर कोई भी service listening नहीं है। Failed to connect to 127.0.0.1 port 18960 के साथ curl exit code 7 का मतलब है कि memory service चल नहीं रही है या startup के समय ही बंद हो गई है, इसलिए terminal या journal को पढ़ें जहाँ इसे start किया गया था। इसके दो सामान्य कारण हैं: एक better-sqlite3 native module जो आपके Node version से मेल नहीं खाता (इसे npm rebuild better-sqlite3 से ठीक करें), और 22 से कम Node version का होना। service के start होने के बाद ss -lntp | grep 18960 के साथ socket की पुष्टि करें।

Q: 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"} print करेगा। वह file केवल npm run memory:build के बाद मौजूद होती है, क्योंकि build प्रक्रिया dist बनाती है और file को executable के रूप में mark करती है। इसे node Memory/dist/src/cli/index.js health के रूप में चलाएँ, या short name के लिए इसे /usr/local/bin में symlink करें।

Q: क्या मैं claude mcp add के साथ Memmy को Claude Code में जोड़ सकता हूँ?

नहीं। Memmy एक MCP client है, MCP server नहीं। यह ~/.memmy/config.yaml में tools.mcpServers के तहत सूचीबद्ध servers से connect होता है और उनके tools को अपने runtime के लिए उपलब्ध कराता है। Claude Code, Memmy तक विपरीत दिशा से पहुँचता है, यानी memmy-memory CLI को shell command के रूप में चलाकर, जिसे एक instruction file निर्देशित करती है जिसे memmy-memory init --agent agent की rules directory में लिखता है।

अपने AI agents के लिए Memmy का उपयोग करके एक साझा memory store बनाएं। Ubuntu पर source से build करें, service को port 18960 पर चलाएं और सभी डेटा को local रखें।

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 रखता है, और सर्वर पर मौजूद हर agent उसी store से read और write करता है। यह प्रोजेक्ट MemTensor की ओर से memmy-agent है, MIT licensed है, और जुलाई 2026 तक version 1.0.4 पर है।

सर्वर पर इसका केवल एक हिस्सा ही मायने रखता है। Memmy एक memory service के साथ आता है जो http://127.0.0.1:18960 पर listen करती है, एक memmy-memory command line interface (CLI) जो उस service से बात करता है, और एक desktop workbench। Workbench केवल macOS और Windows के लिए packaged है, इसलिए Linux VPS पर आप केवल service और CLI चलाते हैं। Claude Code, Codex और Cursor को shared memory देने के लिए इतना पर्याप्त है।

Memmy अपने द्वारा संग्रहीत सामग्री को चार layers में व्यवस्थित करता है। L1 Trace raw turn होता है: request, response और tool calls। L2 Policy उन traces से निकली procedure होती है, जो उपयोगी सिद्ध हुई हो। L3 World Model किसी project या environment के बारे में स्थिर knowledge होता है। Skill किसी policy से crystallise हुई callable procedure होती है। Service किसी turn को ingest करते समय layer निर्धारित करती है, इसलिए इन्हें manually create नहीं करना पड़ता। यदि ये distinctions abstract लगें, तो memory agents बनाना सीखने की staged path के बाद के stages में से एक है। जब आप स्वयं एक plain agent loop लिखकर देखते हैं कि runs के बीच वह सब कुछ भूल जाता है, तब ये layers अधिक स्पष्ट समझ आती हैं।

Shared memory hub, per-tool memory की तुलना में क्या बदलाव लाता है

आज हर agent अपनी खुद की memory रखता है। Claude Code instruction files को repository में रखता है। Cursor rules को अपने workspace database में रखता है। Codex session logs को ~/.codex के अंतर्गत रखता है। प्रत्येक store एक ही tool का होता है, इसलिए सोमवार को आपने एक tool में जो जानकारी दी, वह मंगलवार को दूसरे tool को पता नहीं होती। आप इसकी कीमत दो बार चुकाते हैं: एक बार उसी project को दोबारा समझाने में खर्च हुए tokens के रूप में, और दूसरी बार गलत काम के रूप में जब कोई agent ऐसी धारणा पर काम करता है जिसे आप कहीं और पहले ही सुधार चुके होते हैं।

एक hub store को tool से बाहर निकाल देता है। Memmy मौजूदा stores को भी पढ़ता है, इसलिए आप खाली database से शुरुआत नहीं करते। इसका scanner छह sources को जानता है: ~/.claude/projects/**/*.jsonl पर Claude Code, ~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-*.jsonl पर Codex, ~/.local/share/opencode/opencode.db पर OpenCode, Cursor की state.vscdb files, ~/.openclaw के अंतर्गत OpenClaw की SQLite databases, और ~/.hermes पर Hermes। आप एक नाम और local path के साथ मैन्युअल रूप से एक source जोड़ सकते हैं।

Import counters मेल नहीं खाएंगे, और यह अपेक्षित है। Scanner messages को source और conversation के आधार पर समूहबद्ध करता है, फिर प्रत्येक पूर्ण turn के लिए एक L1 memory लिखता है। एक turn तब पूर्ण मानी जाती है जब उसमें non-empty user content हो और वह एक non-empty assistant message के साथ समाप्त हो, इसलिए एक बाधित session में कुछ भी योगदान नहीं होता। Messages को conversation checkpoints और stable turn IDs के साथ deduplicate किया जाता है। एक ही run पर scanned count, imported message count और new memory count सभी अलग-अलग होते हैं।

यह वह हिस्सा है जो Claude Code एक session के भीतर context को कैसे manage करता है के साथ जुड़ता है। Context management यह तय करता है कि एक single window में क्या फिट बैठता है। एक memory hub यह तय करता है कि उस window के बंद होने के बाद क्या सुरक्षित रहता है।

VPS पर आपको क्या चाहिए

Node.js 22 या उससे नया वर्ज़न। Memmy docs के लिए यह आवश्यक है, और Ubuntu 24.04 में Node 18 आता है।
git और एक build toolchain, क्योंकि better-sqlite3 एक native module है जिसे install के दौरान compile होने की आवश्यकता हो सकती है।
लगभग 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 या उससे अधिक output देना चाहिए। यहाँ v18 आने का मतलब है कि NodeSource वाला चरण पूरा नहीं हुआ है, और बाद में project के engine check पर install विफल हो जाएगा।

Ubuntu 24.04 पर source से Memmy install करना

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 सर्वर के लिए tree में किसी अन्य चीज़ को build करने की आवश्यकता नहीं है। जाँचें कि native module load हुआ है या नहीं:

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

यदि वह line print करने के बजाय error देती है, तो native module आपके Node version से मेल नहीं खाता है। npm rebuild better-sqlite3 चलाएँ, जो कि project की अपनी start script द्वारा launch करने से पहले किया जाने वाला कार्य है।

README में bash scripts/dev-start.sh को एक command से start करने के रूप में document किया गया है। इसे headless VPS पर न चलाएँ। यह memory service के साथ port 19000 पर Electron desktop shell और Vite dev server को start करता है, और Electron को display की आवश्यकता होती है। इसलिए, बिना graphical session वाले सर्वर पर यह script रुक जाती है या exit हो जाती है।

Memory service को start करें और जाँचें कि क्या यह response दे रहा है

npm run memory:serve:dev

source से memory service को चलाने का यह दस्तावेजीकृत तरीका है। यह 127.0.0.1:18960 पर bind होता है, database को ~/.memmy/memory-service/memory.sqlite पर रखता है, और ~/.memmy/config.yaml से config पढ़ता है। जब आप इन values को स्पष्ट रूप से सेट करना चाहते हैं, तो README में भी यही values दी गई हैं:

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

दूसरे shell से, service से पूछें कि क्या वह active है:

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

Health एकमात्र ऐसा endpoint है जिसके लिए कभी token की आवश्यकता नहीं होती, इसीलिए यह जांचने के लिए सबसे उपयुक्त है। यदि curl code 7 और Failed to connect to 127.0.0.1 port 18960 संदेश के साथ exit होता है, तो इसका मतलब है कि कोई भी service listening mode में नहीं है। उस terminal को पढ़ें जहाँ service चल रही है, क्योंकि startup के दौरान होने वाला crash वहीं print होता है, और इसका सामान्य कारण native SQLite module का load न हो पाना है। 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 एक entry को पढ़ते और हटाते हैं।
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 को record करते हैं।
GET /api/v1/panel/overview, /api/v1/panel/analysis और /api/v1/panel/items dashboard को data प्रदान करते हैं।

Memmy ports का एक block reserve करता है, और headless mode में आप केवल पहले का उपयोग करते हैं: memory के लिए 18960, gateway health के लिए 18970, web UI और admin HTTP के लिए 18980, OpenAI-compatible API के लिए 18990 जिसे memmy serve start करता है, और फिर desktop frontend के dev server के लिए 19000 और 19010। यदि आपके system पर पहले से ही कोई service इनमें से किसी port का उपयोग कर रही है, तो समस्या का समाधान खोजने के लिए इसी सूची को देखें।

memmy-memory कमांड वास्तव में कहाँ से आती है

आमतौर पर पहली बार install करते समय यहीं गलती होती है, इसलिए अनुमान लगाने के बजाय package से इसे पढ़ें। कमांड का नाम repository के नाम से संबंधित नहीं है। यह workspace के bin field से आती है जो इसे परिभाषित करता है:

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

यह {"memmy-memory":"./dist/src/cli/index.js"} प्रिंट करता है। इसलिए, built entry point Memory/dist/src/cli/index.js है, और यह केवल npm run memory:build के बाद मौजूद होता है, क्योंकि build ही dist को बनाती है और file को executable के रूप में चिह्नित करती है। इसे सीधे चलाएँ:

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

यदि आप अपने PATH पर छोटा नाम चाहते हैं, तो उसी file को 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 हैं, साथ ही session और turn calls भी हैं जिनका उपयोग लोग नहीं बल्कि agents करते हैं। memmy-memory search "deploy steps" और memmy-memory add "staging migrates on deploy" वे दो कमांड हैं जिन्हें एक agent सबसे अधिक चलाता है।

Claude Code को Memmy से कैसे कनेक्ट करें?

Claude Code में कोई memory plugin interface नहीं है, इसलिए Memmy इसके साथ सीधे तौर पर नहीं जुड़ता है। इनका एकीकरण इससे कहीं अधिक सरल है। Claude Code, memmy-memory को एक सामान्य shell command के रूप में चलाता है, और एक instruction file इसे बताती है कि ऐसा कब करना है। Memmy का documented installer आपके लिए वह file लिख देता है: memmy-memory init --agent, target agent की rules directory में एक memory instruction file डाल देता है।

instruction को एक बार स्वयं लिखकर देखें, क्योंकि इससे आपको पता चल जाएगा कि agent को क्या निर्देश दिए गए हैं। Claude Code हर session की शुरुआत में project root से CLAUDE.md को पढ़ता है, इसलिए इस तरह का एक section ही पूरा एकीकरण है:

## 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 को चलाने का निर्णय लेता है, अन्यथा नहीं। कोई भी चीज़ इस call को बाध्य नहीं करती है। यदि कोई session add के बिना समाप्त होता है, तो कुछ भी save नहीं हुआ, और अगली बार search करने पर केवल एक empty result ही संकेत के रूप में मिलता है। यह Claude Code की अपनी memory files के समान ही trade-off है, बस एक अंतर के साथ: store साझा (shared) है, इसलिए वह note उसी machine पर Codex और Cursor तक भी पहुँच जाता है। एक ऐसा harness जो वास्तविक plugin interface प्रदान करता है, वह अनुरोध करने के बजाय इस कमी को दूर करता है, यही कारण है कि durable memory, budget caps और permission rules के साथ-साथ install करने योग्य DeepSeek Harness plugins में शामिल है।

दूसरी दिशा के लिए किसी setup की आवश्यकता नहीं है। Memmy का scanner पहले से ही ~/.claude/projects/**/*.jsonl को पढ़ता है, जहाँ Claude Code अपनी session transcripts लिखता है। Memmy को उसी server पर चलाएं जहाँ आप tmux session के अंदर Claude Code चलाते हैं, और बिना किसी configuration के कल का काम आपकी memory बन जाएगा।

क्या Memmy, Claude Code के लिए एक MCP server के रूप में काम करता है?

नहीं, और इस दिशा की जानकारी होने से आपका समय बचेगा। MCP (model context protocol) में clients और servers होते हैं। Memmy एक client है। यह MCP servers से connect होता है और उनके tools को अपने स्वयं के agent runtime को उपलब्ध कराता है। यह कोई ऐसा MCP endpoint publish नहीं करता है जिसकी ओर claude mcp add point कर सके। 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.yaml में configure किया जाता है, जिसे MEMMY_CONFIG file point करती है, और यह 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 उसी box पर मौजूद होनी चाहिए और उसी user के रूप में चलनी चाहिए। यदि आप पहले से ही MCP servers को VPS पर चला रहे हैं, तो उन्हें ही यहाँ list करना चाहिए।

मेमोरी स्टोर को निजी रखना

Memmy के स्वामित्व वाली हर चीज़ ~/.memmy के अंतर्गत रहती है: config.yaml, वर्कस्पेस, memory-service/memory.sqlite और रनटाइम फाइलें। स्कैनिंग और इनजेशन स्थानीय रूप से होते हैं, और मेमोरीज उस स्थानीय SQLite फाइल में लिखी जाती हैं, इसलिए डिफ़ॉल्ट स्थिति पूरी तरह से स्थानीय है।

दो रास्ते नेटवर्क तक पहुँचते हैं। MEMMY_CLOUD_SERVICE डिफ़ॉल्ट रूप से https://memmy-api.memtensor.cn पर सेट होता है और अपने ट्रायल टोकन के साथ अकाउंट मोड को सपोर्ट करता है, इसलिए API की मोड इसे कभी कॉल नहीं करता। मेमोरी इम्प्रूवमेंट प्रोग्राम प्राइवेसी सेटिंग्स में एक अलग टॉगल है, जो आपके द्वारा चालू करने तक बंद रहता है।

तीसरा रास्ता चूकना आसान है। यदि आप एक होस्टेड एम्बेडिंग प्रदाता कॉन्फ़िगर करते हैं, तो प्रत्येक मेमोरी का टेक्स्ट उस प्रदाता को भेजा जाता है ताकि उसे वेक्टर में बदला जा सके। स्थानीय स्टोरेज वहां मदद नहीं करता। इसे बंद करने का एकमात्र तरीका एक ऐसा एम्बेडिंग एंडपॉइंट है जिसे आप स्वयं होस्ट करते हैं।

पोर्ट 18960 को लूपबैक एड्रेस पर रखें। इसके लिए किसी फायरवॉल नियम की आवश्यकता नहीं है, क्योंकि 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 एनवायरनमेंट वेरिएबल का उपयोग करना, हेल्थ एंडपॉइंट को छोड़कर हर एंडपॉइंट के लिए बेयरर टोकन अनिवार्य कर देता है। कॉन्फ़िगरेशन वैल्यूज ${ENV_NAME} रेफरेंस को सपोर्ट करती हैं, इसलिए टोकन और आपके मॉडल API की फाइल से बाहर रहते हैं। यह हर जगह AI एजेंट्स से सीक्रेट्स दूर रखने जैसी ही आदत है, और डिफ़ॉल्ट डिनाई ufw पॉलिसी आपका बैकस्टॉप है यदि भविष्य का कोई वर्जन अपना डिफ़ॉल्ट बाइंड एड्रेस बदल देता है।

भरोसा करने से पहले ~/.memmy का बैकअप लें

memory.sqlite पूरा स्टोर है। वेक्टर्स उसी फाइल में sqlite-vec एक्सटेंशन के माध्यम से रहते हैं, इसलिए एक ही फाइल बैकअप के लिए पर्याप्त है। जब सर्विस डेटा लिख रही हो, उस समय cp के साथ इसे कॉपी करने से डेटाबेस करप्ट (torn) हो सकता है। SQLite के अपने बैकअप कमांड का उपयोग करें:

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

यह सर्विस के चलते रहने के दौरान एक कंसिस्टेंट कॉपी तैयार करता है। इसे एक शेड्यूल के अनुसार सर्वर से बाहर भेजें, जिसके लिए restic to off-site storage का उपयोग किया जाता है। config.yaml खोने पर आपको केवल प्रोवाइडर सेटिंग्स दोबारा टाइप करनी होंगी। memory.sqlite खोने का मतलब है आपकी हर मेमोरी का नुकसान, और मशीन पर कहीं और इसकी दूसरी कॉपी मौजूद नहीं होती है।

memory service को systemd के अंतर्गत चलाएं

npm run memory:serve:dev को shell में चलाने पर, shell बंद होते ही वह भी बंद हो जाता है। एक unit file सेवा को reboot के बाद भी चालू रखती है।

[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 नहीं ढूंढ पाएगा। जो unit शुरू होकर तुरंत बंद हो जाती है, वह npm के भीतर विफल हुई है, और journalctl -u memmy-memory -n 50 उसका कारण print करता है। इसकी कार्यप्रणाली VPS पर किसी भी अन्य systemd service के समान ही है।

Memmy जो अभी नहीं करता है

इसमें Linux डेस्कटॉप बिल्ड उपलब्ध नहीं है। पैकेजिंग स्क्रिप्ट्स केवल macOS और Windows को कवर करती हैं, इसलिए workbench, इसका onboarding wizard और memory dashboard सर्वर पर उपलब्ध नहीं हैं।
memory:serve:dev, TypeScript entry point को tsx के माध्यम से चलाता है, जो एक development path है। रिपॉजिटरी में compiled output के लिए memory:serve भी शामिल है। यह देखने के लिए कि आपके checkout में कौन सी स्क्रिप्ट्स मौजूद हैं, बिना किसी argument के npm run चलाएँ।
Retrieval अपनी search window को नवीनतम 2,000 vector rows से बनाता है, और फिर उस window के भीतर Top-K selection लागू करता है। बहुत बड़े store पर, एक पुरानी memory इसके बाहर रह सकती है।
Embedding, capture के बाद होती है, और विफलता होने पर यह agent के turn को ब्लॉक करने के बजाय एक retry queue में चली जाती है। अभी-अभी जोड़ी गई memory शायद vector search द्वारा तुरंत खोजने योग्य न हो।
एक SQLite फाइल का मतलब एक node है। इसमें clustering नहीं है, इसलिए दूसरा सर्वर एक दूसरी, अलग memory है।

Version 1.0.4 और जुलाई 2026 तक लगभग 329 stars यह दर्शाते हैं कि यह एक नया प्रोजेक्ट है। Flags, paths और script के नाम releases के बीच बदलते रहते हैं। कहीं से भी कॉपी किए गए कमांड पर भरोसा करने के बजाय, अपने स्वयं के checkout में bin field और npm run के output को पढ़ें।

FAQ

हेल्थ चेक connection refused क्यों देता है?

port 18960 पर कोई भी service listening नहीं है। Failed to connect to 127.0.0.1 port 18960 के साथ curl exit code 7 का मतलब है कि memory service चल नहीं रही है या startup के समय ही बंद हो गई है, इसलिए terminal या journal को पढ़ें जहाँ इसे start किया गया था। इसके दो सामान्य कारण हैं: एक better-sqlite3 native module जो आपके Node version से मेल नहीं खाता (इसे npm rebuild better-sqlite3 से ठीक करें), और 22 से कम Node version का होना। service के start होने के बाद ss -lntp | grep 18960 के साथ socket की पुष्टि करें।

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"} print करेगा। वह file केवल npm run memory:build के बाद मौजूद होती है, क्योंकि build प्रक्रिया dist बनाती है और file को executable के रूप में mark करती है। इसे node Memory/dist/src/cli/index.js health के रूप में चलाएँ, या short name के लिए इसे /usr/local/bin में symlink करें।

क्या मैं `claude mcp add` के साथ Memmy को Claude Code में जोड़ सकता हूँ?

नहीं। Memmy एक MCP client है, MCP server नहीं। यह ~/.memmy/config.yaml में tools.mcpServers के तहत सूचीबद्ध servers से connect होता है और उनके tools को अपने runtime के लिए उपलब्ध कराता है। Claude Code, Memmy तक विपरीत दिशा से पहुँचता है, यानी memmy-memory CLI को shell command के रूप में चलाकर, जिसे एक instruction file निर्देशित करती है जिसे memmy-memory init --agent agent की rules directory में लिखता है।

क्या Memmy चलाने से मेरी यादें (memories) cloud service पर जाती हैं?

Scanning और ingestion स्थानीय रूप से चलते हैं, और यादें आपकी अपनी disk पर ~/.memmy/memory-service/memory.sqlite में लिखी जाती हैं। MEMMY_CLOUD_SERVICE, account mode और trial tokens के लिए https://memmy-api.memtensor.cn की ओर इशारा करता है, और memory improvement program तब तक बंद रहता है जब तक आप इसे enable न करें। जिस path पर ध्यान देना है वह embedding provider है: एक hosted embedding model हर उस text को प्राप्त करता है जिसे वह vector में बदलता है, इसलिए यदि यह आपके लिए महत्वपूर्ण है तो ऐसे endpoint का उपयोग करें जिसे आप स्वयं run करते हैं।

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