SSD Nodes Learn 8GB RAM — $66/साल
गाइड Matt Connorलेखक: Matt Connor · अपडेट किया गया: 2026-08-01

Memmy: AI एजेंट्स के लिए लोकल मेमोरी हब कैसे सेटअप करें

अपने VPS पर Memmy इंस्टॉल करके AI एजेंट्स को साझा मेमोरी दें। Ubuntu पर सोर्स से बिल्ड करें, पोर्ट 18960 पर सर्विस चलाएं और सभी नोट्स को पूरी तरह से लोकल सुरक्षित रखें।

Memmy क्या है और यह क्या स्टोर करता है

Memmy AI एजेंटों के लिए एक लोकल मेमोरी हब है जो आपके अपने VPS (वर्चुअल प्राइवेट सर्वर) पर चलता है। यह आपके एजेंटों द्वारा सीखी गई बातों का एक SQLite डेटाबेस रखता है, और सर्वर पर मौजूद हर एजेंट उसी स्टोर से डेटा पढ़ता और लिखता है। यह प्रोजेक्ट MemTensor की ओर से memmy-agent है, MIT लाइसेंस प्राप्त है, और जुलाई 2026 तक इसका वर्ज़न 1.0.4 है।

सर्वर पर इसका केवल एक हिस्सा ही मायने रखता है। Memmy एक मेमोरी सर्विस प्रदान करता है जो http://127.0.0.1:18960 पर लिसन करती है, एक memmy-memory कमांड लाइन इंटरफेस (CLI) जो उस सर्विस से बात करता है, और एक डेस्कटॉप वर्कबेंच। वर्कबेंच केवल macOS और Windows के लिए पैकेज किया गया है, इसलिए Linux VPS पर आप केवल सर्विस और CLI चलाते हैं। Claude Code, Codex और Cursor को साझा मेमोरी देने के लिए इतना पर्याप्त है।

Memmy अपने द्वारा स्टोर किए गए डेटा को चार लेयर्स में व्यवस्थित करता है। L1 Trace रॉ टर्न है: रिक्वेस्ट, रिस्पॉन्स और टूल कॉल्स। L2 Policy उन ट्रेसेस से प्राप्त प्रक्रिया है जो उपयोगी साबित हुई हैं। L3 World Model किसी प्रोजेक्ट या वातावरण के बारे में स्थिर ज्ञान है। Skill एक कॉल करने योग्य प्रक्रिया है जो पॉलिसी से तैयार की जाती है। जब सर्विस किसी टर्न को इनजेस्ट करती है, तो वह उसे एक लेयर असाइन कर देती है, इसलिए आपको उन्हें मैन्युअल रूप से बनाने की आवश्यकता नहीं होती है।

शेयर्ड मेमोरी हब प्रति-टूल मेमोरी की तुलना में क्या बदलाव लाता है

आज हर एजेंट अपनी खुद की मेमोरी का उपयोग करता है। Claude Code निर्देश फ़ाइलों को रिपॉजिटरी में रखता है। Cursor नियमों को अपने वर्कस्पेस डेटाबेस में रखता है। Codex सत्र लॉग को ~/.codex के अंतर्गत रखता है। प्रत्येक स्टोर एक टूल से संबंधित होता है, इसलिए सोमवार को एक टूल में जो तथ्य आपने सिखाया, वह मंगलवार को दूसरे टूल में अज्ञात होता है। आप इसके लिए दो बार भुगतान करते हैं: एक बार उसी प्रोजेक्ट को दोबारा समझाने में खर्च किए गए टोकन के रूप में, और दूसरी बार गलत काम के रूप में जब कोई एजेंट ऐसी धारणा पर कार्य करता है जिसे आपने कहीं और पहले ही सुधार दिया है।

एक हब स्टोर को टूल से बाहर ले जाता है। Memmy मौजूदा स्टोर को भी पढ़ता है, इसलिए आप खाली डेटाबेस से शुरुआत नहीं करते हैं। इसका स्कैनर छह स्रोतों को जानता है: ~/.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 डेटाबेस, और ~/.hermes पर Hermes। आप एक नाम और स्थानीय पथ के साथ मैन्युअल रूप से एक स्रोत जोड़ सकते हैं।

इंपोर्ट काउंटर मेल नहीं खाएंगे, और यह अपेक्षित है। स्कैनर संदेशों को स्रोत और वार्तालाप के अनुसार समूहित करता है, फिर प्रत्येक पूर्ण टर्न के लिए एक L1 मेमोरी लिखता है। एक टर्न को तब पूर्ण माना जाता है जब उसमें गैर-खाली उपयोगकर्ता सामग्री हो और वह एक गैर-खाली सहायक संदेश के साथ समाप्त हो, इसलिए बाधित सत्र का कोई योगदान नहीं होता है। संदेशों को वार्तालाप चेकपॉइंट्स और स्थिर टर्न ID के साथ डुप्लीकेट होने से रोका जाता है। स्कैन की गई संख्या, आयातित संदेशों की संख्या और नई मेमोरी की संख्या एक ही रन पर अलग-अलग होती है।

यह वह हिस्सा है जो Claude Code एक सत्र के भीतर संदर्भ का प्रबंधन कैसे करता है के साथ जुड़ता है। संदर्भ प्रबंधन यह तय करता है कि एक विंडो में क्या फिट बैठता है। एक मेमोरी हब यह तय करता है कि उस विंडो के बंद होने के बाद क्या सुरक्षित रहता है।

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

  • Node.js 22 या नया संस्करण। Memmy के दस्तावेज़ों के लिए यह आवश्यक है, और Ubuntu 24.04 में Node 18 आता है।
  • git और एक बिल्ड टूलचेन, क्योंकि better-sqlite3 एक नेटिव मॉड्यूल है जिसे इंस्टॉलेशन के दौरान कंपाइल करना पड़ सकता है।
  • लगभग 2 GB RAM। रूट इंस्टॉलेशन एक बड़ा वर्कस्पेस और फ्रंटएंड बिल्ड चेन डाउनलोड करता है।
  • node_modules और डेटाबेस के लिए कुछ GB खाली डिस्क स्पेस।
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 वाला चरण पूरा नहीं हुआ है, और बाद में प्रोजेक्ट के इंजन चेक पर इंस्टॉलेशन विफल हो जाएगा।

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 वर्कस्पेस को Memory/dist में कंपाइल करता है। हेडलेस सर्वर के लिए ट्री में किसी अन्य चीज़ को बिल्ड करने की आवश्यकता नहीं है। जांचें कि नेटिव मॉड्यूल लोड हुआ है या नहीं:

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

यदि वह लाइन प्रिंट करने के बजाय एरर देती है, तो नेटिव मॉड्यूल आपके Node वर्ज़न से मेल नहीं खाता है। npm rebuild better-sqlite3 चलाएं, जो बिल्कुल वही है जो प्रोजेक्ट की अपनी स्टार्ट स्क्रिप्ट किसी भी चीज़ को लॉन्च करने से पहले करती है।

README में bash scripts/dev-start.sh को एक कमांड से शुरू होने वाले विकल्प के रूप में प्रलेखित किया गया है। इसे हेडलेस VPS पर न चलाएं। यह मेमोरी सर्विस के साथ पोर्ट 19000 पर Electron डेस्कटॉप शेल और Vite डेव सर्वर को शुरू करता है, और Electron को डिस्प्ले की आवश्यकता होती है, इसलिए बिना ग्राफिकल सेशन वाले सर्वर पर स्क्रिप्ट रुक जाती है या बंद हो जाती है।

मेमोरी सर्विस शुरू करें और जांचें कि क्या यह प्रतिक्रिया दे रही है

npm run memory:serve:dev

यह सोर्स से मेमोरी सर्विस चलाने का प्रलेखित तरीका है। यह 127.0.0.1:18960 पर बाइंड होती है, डेटाबेस को ~/.memmy/memory-service/memory.sqlite पर रखती है, और ~/.memmy/config.yaml से कॉन्फ़िगरेशन पढ़ती है। जब आप इन मानों को स्पष्ट रूप से सेट करना चाहते हैं, तो README में भी यही मान दिए गए हैं:

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

दूसरे शेल से, सर्विस से पूछें कि क्या वह सक्रिय है:

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

Health एकमात्र ऐसा एंडपॉइंट है जिसके लिए कभी भी टोकन की आवश्यकता नहीं होती है, इसीलिए यह जांच के लिए सही है। यदि curl कोड 7 और Failed to connect to 127.0.0.1 port 18960 संदेश के साथ समाप्त होता है, तो इसका मतलब है कि कोई भी सर्विस लिसन नहीं कर रही है। सर्विस चलाने वाले टर्मिनल को पढ़ें, क्योंकि स्टार्टअप पर होने वाला क्रैश वहीं प्रिंट होता है, और इसका सामान्य कारण नेटिव SQLite मॉड्यूल का लोड होने में विफल होना है। सर्विस चालू होने के बाद ss -lntp | grep 18960 सॉकेट की पुष्टि करता है।

बाकी HTTP API (एप्लिकेशन प्रोग्रामिंग इंटरफ़ेस) /api/v1 के अंतर्गत स्थित है।

  • POST /api/v1/memory/add मेमोरी लिखता है और POST /api/v1/memory/search क्वेरी करता है।
  • GET /api/v1/memory/:id और DELETE /api/v1/memory/:id एक प्रविष्टि को पढ़ते और हटाते हैं।
  • POST /api/v1/sessions/open और POST /api/v1/sessions/:sessionId/close एक एजेंट सत्र को ब्रैकेट करते हैं।
  • POST /api/v1/turns/start और POST /api/v1/turns/:turnId/complete एक टर्न रिकॉर्ड करते हैं।
  • GET /api/v1/panel/overview, /api/v1/panel/analysis और /api/v1/panel/items डैशबोर्ड को डेटा प्रदान करते हैं।

Memmy पोर्ट्स का एक ब्लॉक आरक्षित करता है, और हेडलेस मोड में आप केवल पहले पोर्ट का उपयोग करते हैं: मेमोरी के लिए 18960, गेटवे हेल्थ के लिए 18970, वेब UI और एडमिन HTTP के लिए 18980, OpenAI-संगत API के लिए 18990 जिसे memmy serve शुरू करता है, फिर डेस्कटॉप फ्रंटएंड के डेव सर्वर के लिए 19000 और 19010। यदि आपके सिस्टम पर कोई अन्य प्रक्रिया इनमें से किसी पोर्ट का उपयोग कर रही है, तो आपको इसी सूची में जांच करनी चाहिए।

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

आमतौर पर पहला इंस्टॉलेशन यहीं गलत होता है, इसलिए अनुमान लगाने के बजाय इसे पैकेज से पढ़ें। कमांड का नाम रिपॉजिटरी के नाम से संबंधित नहीं है। यह वर्कस्पेस के bin फ़ील्ड से आती है जो इसे परिभाषित करता है:

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

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

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

यदि आप अपने PATH पर छोटा नाम चाहते हैं, तो उसी फ़ाइल को लिंक करें:

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

CLI डिफ़ॉल्ट रूप से http://127.0.0.1:18960 पर सेट होता है और --url, --token, --config, --source और --user-id को स्वीकार करता है। इसके सब-कमांड init, health, search, add, get और delete हैं, साथ ही सेशन और टर्न कॉल भी हैं जिनका उपयोग लोग नहीं बल्कि एजेंट करते हैं। memmy-memory search "deploy steps" और memmy-memory add "staging migrates on deploy" वे दो कमांड हैं जिन्हें एक एजेंट सबसे अधिक चलाता है।

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

Claude Code में कोई मेमोरी प्लगइन इंटरफ़ेस नहीं है, इसलिए Memmy इसमें सीधे हुक नहीं करता है। इसका एकीकरण इससे अधिक सरल है। Claude Code एक सामान्य शेल कमांड के रूप में memmy-memory को चलाता है, और एक इंस्ट्रक्शन फ़ाइल इसे बताती है कि कब ऐसा करना है। Memmy का डॉक्यूमेंटेड इंस्टॉलर आपके लिए वह फ़ाइल लिखता है: memmy-memory init --agent टारगेट एजेंट की रूल्स डायरेक्टरी में एक मेमोरी इंस्ट्रक्शन फ़ाइल डाल देता है।

इंस्ट्रक्शन को एक बार मैन्युअल रूप से लिखें, क्योंकि इससे आपको पता होगा कि एजेंट को वास्तव में क्या निर्देश दिए गए थे। Claude Code हर सेशन की शुरुआत में प्रोजेक्ट रूट से CLAUDE.md को पढ़ता है, इसलिए इस तरह का एक सेक्शन ही पूरा एकीकरण है:

## Memory

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

यह स्पष्ट रखें कि इससे आपको क्या लाभ मिलता है। यह इंस्ट्रक्शन-लेवल का एकीकरण है, इसलिए यह तभी काम करता है जब मॉडल कमांड चलाने का निर्णय लेता है, अन्यथा नहीं। कॉल करने के लिए कोई बाध्यता नहीं है। यदि कोई सेशन add के बिना समाप्त होता है, तो कुछ भी सेव नहीं होता है, और अगली बार सर्च करने पर केवल एक खाली परिणाम ही संकेत के रूप में मिलता है। यह Claude Code की अपनी मेमोरी फ़ाइलों जैसा ही ट्रेड-ऑफ है, बस एक अंतर के साथ: स्टोर साझा किया जाता है, इसलिए नोट उसी मशीन पर Codex और Cursor तक भी पहुँच जाता है।

दूसरी दिशा के लिए किसी सेटअप की आवश्यकता नहीं है। Memmy का स्कैनर पहले से ही ~/.claude/projects/**/*.jsonl को पढ़ता है, जहाँ Claude Code अपने सेशन ट्रांसक्रिप्ट लिखता है। Memmy को उसी सर्वर पर चलाएं जहाँ आप tmux सेशन के अंदर Claude Code चलाते हैं और कल का काम बिना किसी कॉन्फ़िगरेशन के मेमोरी बन जाता है।

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

नहीं, और इस दिशा की जानकारी होने से आपका एक दोपहर का समय बच सकता है। MCP (model context protocol) में क्लाइंट और सर्वर होते हैं। Memmy एक क्लाइंट है। यह MCP सर्वरों से कनेक्ट होता है और उनके टूल्स को अपने स्वयं के एजेंट रनटाइम के लिए उपलब्ध कराता है। यह कोई ऐसा MCP एंडपॉइंट पब्लिश नहीं करता है जिसकी ओर claude mcp add इशारा कर सके। रिपॉजिटरी में एकमात्र MCP ब्रिज डेस्कटॉप लोकल API के भीतर Composio इंटीग्रेशन का है, और वह 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 सर्वर, Memmy की चाइल्ड प्रोसेस के रूप में चलता है, जिसका अर्थ है कि इसकी कमांड उसी बॉक्स पर मौजूद होनी चाहिए और उसी यूजर के रूप में चलनी चाहिए। यदि आप पहले से ही VPS पर MCP सर्वर चला रहे हैं, तो उन्हें ही यहाँ लिस्ट करना चाहिए।

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

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

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

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

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

~/.memmy का बैकअप लें, इससे पहले कि आप इस पर भरोसा करें

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

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

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

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

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

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

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

[Install]
WantedBy=multi-user.target

टोकन को unit file से बाहर रखें। इसे /etc/memmy/memory.env में रखें, जिसका स्वामी root हो और मोड 600 हो:

MEMMY_CONFIG=/home/memmy/.memmy/config.yaml
MEMMY_MEMORY_TOKEN=replace-this-with-a-long-random-string
sudo systemctl daemon-reload
sudo systemctl enable --now memmy-memory
systemctl status memmy-memory --no-pager
curl -sS http://127.0.0.1:18960/api/v1/health

status आउटपुट में status=203/EXEC का अर्थ है कि systemd ExecStart को बिल्कुल भी नहीं चला सका, इसलिए which npm की जाँच करें: NodeSource इंस्टॉलेशन पर यह /usr/bin/npm होता है और nvm पर यह उपयोगकर्ता की home डायरेक्टरी के अंतर्गत होता है, जिसे systemd नहीं ढूंढ पाएगा। जो unit शुरू होकर तुरंत बंद हो जाती है, वह npm के भीतर विफल हुई है, और journalctl -u memmy-memory -n 50 इसका कारण प्रिंट करता है। इसकी कार्यप्रणाली VPS पर किसी भी अन्य systemd सेवा के समान ही है।

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

  • Linux डेस्कटॉप बिल्ड उपलब्ध नहीं है। पैकेजिंग स्क्रिप्ट केवल macOS और Windows को कवर करती हैं, इसलिए workbench, इसका ऑनबोर्डिंग विज़ार्ड और मेमोरी डैशबोर्ड सर्वर पर उपलब्ध नहीं हैं।
  • memory:serve:dev, TypeScript एंट्री पॉइंट को tsx के माध्यम से चलाता है, जो एक डेवलपमेंट पाथ है। रिपॉजिटरी कंपाइल किए गए आउटपुट के लिए memory:serve भी प्रदान करती है। यह देखने के लिए कि आपके चेकआउट में कौन सी स्क्रिप्ट मौजूद हैं, बिना किसी तर्क (argument) के npm run चलाएं।
  • रिट्रीवल अपनी सर्च विंडो को नवीनतम 2,000 वेक्टर पंक्तियों से बनाता है, फिर उस विंडो के भीतर Top-K चयन लागू करता है। बहुत बड़े स्टोर पर, एक पुरानी मेमोरी इसके बाहर रह सकती है।
  • एम्बेडिंग कैप्चर के बाद होती है, और विफलता होने पर यह एजेंट के टर्न को ब्लॉक करने के बजाय एक रिट्राई क्यू (retry queue) में चली जाती है। अभी कुछ क्षण पहले जोड़ी गई मेमोरी शायद वेक्टर सर्च द्वारा अभी खोजने योग्य न हो।
  • एक SQLite फ़ाइल का अर्थ है एक नोड। इसमें क्लस्टरिंग नहीं है, इसलिए दूसरा सर्वर एक दूसरी, अलग मेमोरी है।

जुलाई 2026 तक वर्जन 1.0.4 और लगभग 329 स्टार्स एक नए प्रोजेक्ट को दर्शाते हैं। फ्लैग्स, पाथ और स्क्रिप्ट के नाम रिलीज़ के साथ बदलते रहते हैं। कहीं से भी कॉपी किए गए कमांड पर भरोसा करने के बजाय, अपने स्वयं के चेकआउट में bin फ़ील्ड और npm run के आउटपुट को पढ़ें।

FAQ

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

पोर्ट 18960 पर कोई भी सर्विस लिसन नहीं कर रही है। Failed to connect to 127.0.0.1 port 18960 के साथ curl का एग्जिट कोड 7 आने का मतलब है कि मेमोरी सर्विस चल नहीं रही है या स्टार्टअप के दौरान बंद हो गई है, इसलिए उस टर्मिनल या जर्नल को पढ़ें जहाँ इसे शुरू किया गया था। इसके दो सामान्य कारण हैं: एक better-sqlite3 नेटिव मॉड्यूल जो आपके Node वर्जन से मेल नहीं खाता (इसे npm rebuild better-sqlite3 से ठीक करें), और Node का 22 से कम वर्जन होना। सर्विस शुरू होने के बाद ss -lntp | grep 18960 से सॉकेट की पुष्टि करें।

सोर्स से बिल्ड करने के बाद memmy-memory कमांड कहाँ से आती है?

यह रिपॉजिटरी के नाम से नहीं, बल्कि @memmy/memory वर्कस्पेस पैकेज के bin फील्ड से आती है। चेकआउट के अंदर node -p "JSON.stringify(require('./Memory/package.json').bin)" चलाएं, यह {"memmy-memory":"./dist/src/cli/index.js"} प्रिंट करेगा। वह फाइल केवल npm run memory:build के बाद मौजूद होती है, क्योंकि बिल्ड प्रक्रिया dist बनाती है और फाइल को एग्जीक्यूटेबल के रूप में मार्क करती है। इसे node Memory/dist/src/cli/index.js health के रूप में चलाएं, या छोटे नाम के लिए इसे /usr/local/bin में सिमलिंक (symlink) करें।

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

नहीं। Memmy एक MCP क्लाइंट है, MCP सर्वर नहीं। यह ~/.memmy/config.yaml में tools.mcpServers के तहत सूचीबद्ध सर्वरों से कनेक्ट होता है और उनके टूल्स को अपने रनटाइम के लिए उपलब्ध कराता है। Claude Code इसके विपरीत काम करता है, जहाँ यह memmy-memory CLI को एक शेल कमांड के रूप में चलाता है, जिसे एक इंस्ट्रक्शन फाइल निर्देशित करती है जिसे memmy-memory init --agent एजेंट की रूल्स डायरेक्टरी में लिखता है।

क्या Memmy चलाने से मेरी यादें क्लाउड सर्विस पर भेजी जाती हैं?

स्कैनिंग और इनजेशन स्थानीय रूप से चलते हैं, और यादें आपकी अपनी डिस्क पर ~/.memmy/memory-service/memory.sqlite में लिखी जाती हैं। MEMMY_CLOUD_SERVICE अकाउंट मोड और ट्रायल टोकन के लिए https://memmy-api.memtensor.cn की ओर इशारा करता है, और मेमोरी इम्प्रूवमेंट प्रोग्राम तब तक बंद रहता है जब तक आप इसे इनेबल नहीं करते। जिस पाथ पर नजर रखनी है वह एम्बेडिंग प्रोवाइडर है: एक होस्टेड एम्बेडिंग मॉडल उस हर मेमोरी का टेक्स्ट प्राप्त करता है जिसे वह वेक्टर में बदलता है, इसलिए यदि यह महत्वपूर्ण है तो ऐसे एंडपॉइंट का उपयोग करें जिसे आप स्वयं चलाते हैं।

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