SSD Nodes Learn 🎉 VPS $5.50/माह से
गाइड Matt Connorलेखक: Matt Connor · अपडेट किया गया: 2026-08-07

Memmy AI agents के लिए local memory hub कैसे सेटअप करें

अपने VPS पर Memmy को source से build करें और port 18960 पर memory service चलाएं। यह टूल आपके AI agents को एक साझा SQLite database प्रदान करता है ताकि सभी notes 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 रखता है, और उस box पर मौजूद हर agent उसी store से read और write करता है। यह project MemTensor से memmy-agent है, MIT licensed है, और July 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 से प्राप्त एक ऐसी प्रक्रिया है जो उपयोगी साबित हुई है। L3 World Model किसी project या environment के बारे में स्थिर जानकारी है। Skill एक callable प्रक्रिया है जो policy से तैयार होती है। जब service किसी turn को ingest करती है, तो वह उसे एक layer assign कर देती है, इसलिए आपको उन्हें हाथ से बनाने की आवश्यकता नहीं होती है।

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

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

एक hub store को टूल से बाहर निकाल देता है। Memmy मौजूदा stores को भी पढ़ता है, इसलिए आप खाली 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 memory लिखता है। एक turn को तब पूर्ण माना जाता है जब उसमें गैर-रिक्त (non-empty) उपयोगकर्ता सामग्री हो और वह एक गैर-रिक्त सहायक संदेश के साथ समाप्त हो, इसलिए बाधित सत्र का कोई योगदान नहीं होता है। संदेशों को वार्तालाप checkpoints और स्थिर turn IDs के साथ deduplicate किया जाता है। स्कैन की गई संख्या, आयातित संदेशों की संख्या और नई memory की संख्या एक ही run पर अलग-अलग होती है।

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

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

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

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 server के लिए 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 वाले server पर यह 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 में भी यही मान दिए गए हैं:

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 होता है, तो इसका मतलब है कि कोई भी port पर listening नहीं है। उस terminal को पढ़ें जहाँ service चल रही है, क्योंकि startup के समय होने वाला crash वहीं print होता है, और इसका सामान्य कारण native SQLite module का load न हो पाना है। service के up होने के बाद 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 को bracket करते हैं।
  • 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 पर इनमें से किसी 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 कॉल भी हैं जिनका उपयोग लोग नहीं बल्कि 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 एक सामान्य shell command के रूप में memmy-memory को चलाता है, और एक 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 तक भी पहुँच जाता है।

दूसरी दिशा के लिए किसी 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 127.0.0.1 पर एक random port bind करता है जो उसके अपने x-memmy-mcp-token header के पीछे होता है।

Client side को ~/.memmy/config.yaml में configure किया जाता है, जिस file की ओर MEMMY_CONFIG 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 खोने का मतलब है आपकी हर मेमोरी का नुकसान, और मशीन पर कहीं भी इसकी दूसरी कॉपी मौजूद नहीं होती है।

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

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

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

  • इसमें कोई Linux desktop build नहीं है। packaging scripts केवल macOS और Windows के लिए हैं, इसलिए workbench, इसका onboarding wizard और memory dashboard सर्वर पर उपलब्ध नहीं हैं।
  • memory:serve:dev, TypeScript entry point को tsx के माध्यम से चलाता है, जो एक development path है। repository में compiled output के लिए memory:serve भी शामिल है। यह देखने के लिए कि आपके checkout में कौन सी scripts उपलब्ध हैं, बिना किसी 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 file का अर्थ है एक node। इसमें कोई clustering नहीं है, इसलिए दूसरा सर्वर एक दूसरी, अलग memory है।

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

FAQ

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

पोर्ट 18960 पर कोई भी सर्विस listening मोड में नहीं है। 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 चलाने से मेरी यादें (memories) क्लाउड सर्विस पर जाती हैं?

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

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