SSD Nodes Learn 8GB RAM — సంవత్సరానికి $66
మార్గదర్శకాలు Matt Connorద్వారా Matt Connor · అప్‌డేట్ చేయబడింది 2026-08-01

VPSపై AI agents కోసం Memmy local memory hub

Memmyతో AI agents కోసం ఒకే local SQLite memory storeను ఏర్పాటు చేయండి. Ubuntuలో source నుంచి build చేసి, memory serviceను port 18960పై నడపడం, ప్రతి noteను localగా ఉంచడం తెలుసుకోండి.

Memmy ఏమిటి, అది ఏమి నిల్వ చేస్తుంది

Memmy అనేది మీ స్వంత VPS (virtual private server)పై నడిచే AI agents కోసం స్థానిక మెమరీ హబ్. మీ agents నేర్చుకున్న సమాచారాన్ని ఒక SQLite databaseలో నిల్వ చేస్తుంది. ఆ సిస్టమ్‌లోని ప్రతి agent అదే store నుంచి డేటాను చదివి, అందులో రాస్తుంది. ఈ projectను MemTensor memmy-agent చేసింది. ఇది MIT లైసెన్స్‌లో అందుబాటులో ఉంది. July 2026 నాటికి దీని version 1.0.4.

Serverపై దీనిలో కొంత భాగం మాత్రమే అవసరం. Memmyలో http://127.0.0.1:18960పై listen చేసే memory service, ఆ serviceతో కమ్యూనికేట్ చేసే memmy-memory command line interface (CLI), అలాగే 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 నుంచి రూపొందిన callable procedure. Service ఒక turnను ingest చేసేటప్పుడు దానికి layerను కేటాయిస్తుంది. కాబట్టి మీరు వాటిని చేతితో సృష్టించాల్సిన అవసరం లేదు.

ప్రతి టూల్ మెమరీతో పోలిస్తే భాగస్వామ్య మెమరీ హబ్‌లో మార్పులు

ప్రస్తుతం ప్రతి agent తన స్వంత మెమరీని విడుదల చేస్తుంది. Claude Code రిపాజిటరీలో instruction files ఉంచుతుంది. Cursor తన workspace databaseలో rules ఉంచుతుంది. Codex session logsను ~/.codex కింద ఉంచుతుంది. ప్రతి store ఒకే టూల్‌కు చెందుతుంది. అందువల్ల సోమవారం ఒక టూల్‌లో మీరు నేర్పిన విషయం మంగళవారం మరొక టూల్‌కు తెలియదు. దీనికి మీరు రెండుసార్లు మూల్యం చెల్లిస్తారు: అదే ప్రాజెక్ట్‌ను మళ్లీ వివరించడానికి ఖర్చయ్యే tokens రూపంలో ఒకసారి, అలాగే మరెక్కడో మీరు ఇప్పటికే సరిచేసిన assumption ఆధారంగా agent తప్పుగా పని చేసినప్పుడు మరోసారి.

హబ్ storeను టూల్‌ నుంచి బయటకు మారుస్తుంది. 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 రాస్తుంది. Non-empty user content ఉండి, చివరలో non-empty assistant message ఉన్నప్పుడు ఒక turn పూర్తిగా పరిగణించబడుతుంది. అందువల్ల మధ్యలో ఆగిపోయిన session ఏదీ చేర్చబడదు. Conversation checkpoints మరియు స్థిరమైన turn IDs ద్వారా messagesకు duplicates తొలగించబడతాయి. ఒకే runలో scanned count, imported message count, మరియు new memory count వేర్వేరుగా ఉంటాయి.

ఇది ఒకే sessionలో Claude Code contextను ఎలా నిర్వహిస్తుందో వివరించే భాగానికి అనుసంధానమవుతుంది. Context management ఒకే windowలో ఏమి సరిపోతుందో నిర్ణయిస్తుంది. Memory hub ఆ window మూసిన తర్వాత ఏమి నిలిచి ఉంటుందో నిర్ణయిస్తుంది.

VPSలో అవసరమైనవి

  • Node.js 22 లేదా అంతకంటే కొత్త వెర్షన్. Memmy డాక్యుమెంటేషన్‌కు ఇది అవసరం. Ubuntu 24.04లో Node 18 అందుబాటులో ఉంటుంది.
  • git మరియు build toolchain అవసరం. ఎందుకంటే better-sqlite3 అనేది install సమయంలో compile కావచ్చు.
  • సుమారు 2 GB RAM. root install పెద్ద workspace మరియు frontend build chain‌ను తీసుకుంటుంది.
  • node_modules మరియు database కోసం కొన్ని GB ఖాళీ 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 ఫలితం v22 లేదా అంతకంటే ఎక్కువగా ఉండాలి. ఇక్కడ v18 కనిపిస్తే NodeSource దశ సరిగా అమలు కాలేదని అర్థం. తర్వాత project యొక్క engine check వద్ద install విఫలమవుతుంది.

Ubuntu 24.04లో మూలం నుంచి 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గా కంపైల్ చేస్తుంది. హెడ్‌లెస్ సర్వర్‌కు ట్రీలోని ఇతర భాగాలను build చేయాల్సిన అవసరం లేదు. native module లోడ్ అయిందో తనిఖీ చేయండి:

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

ఆ లైన్‌ను ప్రింట్ చేయడానికి బదులుగా error ఇస్తే, native module మీ Node versionతో సరిపోలడం లేదు. npm rebuild better-sqlite3ని అమలు చేయండి. ఏదైనా ప్రారంభించే ముందు ప్రాజెక్ట్‌కి చెందిన start script కూడా ఇదే చేస్తుంది.

README, bash scripts/dev-start.shని ఒక కమాండ్‌తో ప్రారంభించే విధానంగా నమోదు చేస్తుంది. హెడ్‌లెస్ VPSలో దీన్ని అమలు చేయవద్దు. ఇది memory service పక్కన Electron desktop shellను మరియు port 19000పై Vite dev serverను ప్రారంభిస్తుంది. Electronకు display అవసరం. అందువల్ల graphical session లేని సర్వర్‌లో script నిలిచిపోవచ్చు లేదా ముగిసిపోవచ్చు.

memory serviceను ప్రారంభించి, అది ప్రతిస్పందిస్తుందో తనిఖీ చేయండి

npm run memory:serve:dev

Source నుంచి memory serviceను నడపడానికి డాక్యుమెంట్ చేసిన విధానం ఇదే. ఇది 127.0.0.1:18960కు bind అవుతుంది, databaseను ~/.memmy/memory-service/memory.sqlite వద్ద ఉంచుతుంది, అలాగే configను ~/.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

రెండో 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 message చూపితే, ఏదీ listeningలో లేదు. Service నడుస్తున్న terminalను చూడండి. Startup సమయంలో crash అయితే అక్కడే వివరాలు కనిపిస్తాయి. సాధారణ కారణం 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 queriesను నిర్వహిస్తుంది.
  • 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ను నమోదు చేస్తాయి.
  • GET /api/v1/panel/overview, /api/v1/panel/analysis మరియు /api/v1/panel/items dashboardకు డేటాను అందిస్తాయి.

Memmy portsలో ఒక blockను రిజర్వ్ చేస్తుంది. Headless విధానంలో మీరు మొదటి portలను మాత్రమే ఉపయోగిస్తారు: memory కోసం 18960, gateway health కోసం 18970, web UI మరియు admin HTTP కోసం 18980, memmy serve ప్రారంభించే OpenAI-compatible API కోసం 18990, అలాగే desktop frontend dev server కోసం 19000 మరియు 19010. మీ systemలో వీటిలో ఏదైనా 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 ను సృష్టించి, ఆ 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. అదనంగా, agents ఉపయోగించే session మరియు turn calls కూడా ఉన్నాయి; వీటిని సాధారణంగా వ్యక్తులు ఉపయోగించరు. ఒక agent ఎక్కువగా అమలు చేసేవి memmy-memory search "deploy steps" మరియు memmy-memory add "staging migrates on deploy".

Claude Codeను Memmyకి ఎలా అనుసంధానించాలి?

Claude Codeకు memory plugin interface లేదు. అందువల్ల Memmy దానికి hook అవదు. ఈ integration దానికంటే సరళంగా ఉంటుంది. Claude Code memmy-memoryను సాధారణ shell commandగా అమలు చేస్తుంది. దాన్ని ఎప్పుడు అమలు చేయాలో instruction file తెలియజేస్తుంది. Memmy documentationలోని installer ఆ fileను మీ కోసం రాస్తుంది: memmy-memory init --agent target agent యొక్క rules directoryలో memory instruction fileను ఉంచుతుంది.

Instructionను ఒకసారి చేతితో రాయండి. అప్పుడు agentకు ఖచ్చితంగా ఏమి చెప్పారో మీకు తెలుస్తుంది. Claude Code ప్రతి session ప్రారంభంలో project root నుంచి CLAUDE.mdను చదువుతుంది. అందువల్ల ఈ క్రింది విభాగం మొత్తం integrationగా సరిపోతుంది:

## 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 integration. కాబట్టి model commandను అమలు చేయాలని నిర్ణయించినప్పుడు మాత్రమే ఇది పనిచేస్తుంది. లేకపోతే పనిచేయదు. ఆ callను ఏదీ తప్పనిసరి చేయదు. add లేకుండానే session ముగిస్తే ఏదీ సేవ్ కాదు. తదుపరి సారి search చేసినప్పుడు కనిపించే ఏకైక సంకేతం ఖాళీ result. ఇది Claude Code స్వంత memory filesతో ఉన్నదే trade-off. అయితే ఒక తేడా ఉంది: store sharedగా ఉంటుంది. అందువల్ల అదే machineలోని Codex మరియు Cursorకూ ఆ note అందుతుంది.

వ్యతిరేక దిశకు ఎలాంటి setup అవసరం లేదు. Memmy scanner ఇప్పటికే ~/.claude/projects/**/*.jsonlను చదువుతుంది. Claude Code తన session transcriptsను అక్కడే రాస్తుంది. మీరు tmux sessionలో Claude Codeను అమలు చేసే అదే serverలో Memmyని అమలు చేస్తే, ఎలాంటి configuration లేకుండానే నిన్నటి పని memoryగా మారుతుంది.

Memmy, Claude Code కోసం MCP serverగా పనిచేస్తుందా?

లేదు. ఈ దిశను తెలుసుకుంటే అనవసరమైన సమయం ఆదా అవుతుంది. MCP (model context protocol)లో clients మరియు servers ఉంటాయి. Memmy ఒక client. ఇది MCP servers‌కు కనెక్ట్ అయి, వాటి tools‌ను తన agent runtime‌కు అందిస్తుంది. ఇది claude mcp add కనెక్ట్ చేయగల MCP endpoint‌ను ప్రచురించదు. Repositoryలోని ఏకైక MCP bridge desktop local APIలోని Composio integrationకు చెందినది. ఆ API 127.0.0.1పై random portకు, తన స్వంత x-memmy-mcp-token header వెనుక bind అవుతుంది.

Client వైపు configuration ~/.memmy/config.yamlలో ఉంటుంది. MEMMY_CONFIG సూచించే ఫైల్‌లో, tools.mcpServers కింద ఈ configuration ఉంటుంది:

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గా నడవాలి. మీరు ఇప్పటికే VPSలో నడుస్తున్న MCP servers నిర్వహిస్తుంటే, ఇక్కడ జాబితా చేయాల్సినవి అవే.

మెమరీ స్టోర్‌ను ప్రైవేట్‌గా ఉంచడం

Memmy నిర్వహించే ప్రతిదీ ~/.memmy కింద ఉంటుంది: config.yaml, workspace, memory-service/memory.sqlite మరియు runtime ఫైళ్లు. స్కానింగ్ మరియు ingestion స్థానికంగానే జరుగుతాయి. మెమరీలు స్థానిక SQLite ఫైల్‌లో వ్రాయబడతాయి. అందువల్ల డిఫాల్ట్ విధానం నిజంగా స్థానికంగానే ఉంటుంది.

రెండు మార్గాలు network‌ను చేరుతాయి. MEMMY_CLOUD_SERVICE డిఫాల్ట్‌గా https://memmy-api.memtensor.cn కు సెట్ అవుతుంది. ఇది trial tokensతో account mode‌ను అమలు చేస్తుంది. కాబట్టి API key mode దీనిని ఎప్పుడూ పిలవదు. Memory improvement program privacy settingsలోని వేరే toggle. మీరు దాన్ని ఆన్ చేసే వరకు అది ఆఫ్‌లో ఉంటుంది.

మూడవ మార్గాన్ని గుర్తించడం కొంత కష్టం. మీరు hosted embedding provider‌ను configure చేస్తే, ప్రతి మెమరీలోని టెక్స్ట్ vector‌గా మార్చడానికి ఆ provider‌కు పంపబడుతుంది. Local storage దీనిని నివారించదు. మీరు స్వయంగా host చేసే embedding endpoint మాత్రమే ఈ మార్గాన్ని పూర్తిగా మూసివేయగలదు.

Port 18960ను loopback addressలోనే ఉంచండి. దీనికి firewall rule అవసరం లేదు. ఎందుకంటే 127.0.0.1 కు bind చేసిన serviceను ఆ కంప్యూటర్ వెలుపలి నుంచి అసలు చేరుకోలేరు. బదులుగా SSH ద్వారా మీ laptop నుంచి దాన్ని చేరుకోండి:

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

మీరు ఎప్పుడైనా దాన్ని విస్తృత addressపై bind చేస్తే, ముందుగా token సెట్ చేయండి. Configలో storage.token సెట్ చేయడం, లేదా MEMMY_MEMORY_TOKEN లేదా MEMORY_SERVICE_TOKEN environment variableను సెట్ చేయడం వల్ల health endpoint మినహా ప్రతి endpointకు bearer token అవసరం అవుతుంది. Config విలువలు ${ENV_NAME} referencesకు మద్దతు ఇస్తాయి. కాబట్టి token మరియు మీ model API keys ఫైల్‌లోనే ఉండవు. ఇది మిగతా చోట్ల కూడా AI agents నుంచి secretsను దూరంగా ఉంచడం అనే అదే అలవాటు. భవిష్యత్ version దాని default bind addressను మార్చితే, default deny ufw policy మీ చివరి రక్షణగా ఉంటుంది.

మీరు దానిని నమ్మే ముందు ~/.memmy ని బ్యాకప్ చేయండి

memory.sqlite మొత్తం డేటా స్టోర్. sqlite-vec extension ద్వారా వెక్టర్లు కూడా అదే ఫైల్లో ఉంటాయి. కాబట్టి ఆ ఒక్క ఫైలే బ్యాకప్. సర్వీస్ ఫైల్లో రాస్తున్న సమయంలో cp తో కాపీ చేస్తే database అసంపూర్ణంగా కాపీ కావచ్చు. SQLite స్వంత backup command ను ఉపయోగించండి:

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

సర్వీస్ నడుస్తూనే ఉండగా ఇది consistent copy ని సృష్టిస్తుంది. షెడ్యూల్ ప్రకారం దాన్ని ఈ యంత్రం వెలుపలికి పంపండి. ఇందుకోసమే ఆఫ్-సైట్ storage కు restic ఉపయోగిస్తారు. config.yaml కోల్పోతే provider settings ను మళ్లీ టైప్ చేయాలి. memory.sqlite కోల్పోతే ప్రతి memory కోల్పోతారు. ఈ యంత్రంలో మరెక్కడా రెండో కాపీ ఉండదు.

systemd కింద memory service ను అమలు చేయండి

షెల్‌లోని npm run memory:serve:dev షెల్‌తో పాటు ముగుస్తుంది. 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లో ఉంచవద్దు. దాన్ని /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 కింద ఉన్న ఏదో మార్గంలో ఉంటుంది. ఆ మార్గాన్ని systemd కనుగొనలేదు. Unit ప్రారంభమైన వెంటనే ముగిస్తే, లోపం npmలో సంభవించినట్లు అర్థం. కారణాన్ని journalctl -u memmy-memory -n 50 చూపిస్తుంది. VPSలో ఏ ఇతర systemd serviceనైనా నిర్వహించే విధానం ఇదే.

Memmy ప్రస్తుతం చేయలేనివి

  • Linux డెస్క్‌టాప్ బిల్డ్ లేదు. ప్యాకేజింగ్ స్క్రిప్ట్‌లు macOS మరియు Windows‌ను మాత్రమే కవర్ చేస్తాయి. అందువల్ల workbench, దాని onboarding wizard మరియు memory dashboard సర్వర్‌లోనే అందుబాటులో ఉండవు.
  • memory:serve:dev, tsx ద్వారా TypeScript entry point‌ను అమలు చేస్తుంది. ఇది development path. కంపైల్ చేసిన output కోసం repositoryలో memory:serve కూడా ఉంది. మీ checkoutలో వాస్తవంగా ఏ స్క్రిప్ట్‌లు ఉన్నాయో చూడటానికి ఎటువంటి arguments లేకుండా npm run అమలు చేయండి.
  • Retrieval తన search windowను తాజా 2,000 vector rows నుంచి నిర్మిస్తుంది. ఆ windowలోనే Top-K selectionను వర్తింపజేస్తుంది. చాలా పెద్ద storeలో పాత memory ఈ window వెలుపల ఉండవచ్చు.
  • Capture తర్వాత embedding జరుగుతుంది. విఫలమైతే agent turnను ఆపకుండా retry queueకి పంపుతుంది. కొద్దిసేపటి క్రితం జోడించిన memory vector searchలో ఇంకా కనుగొనబడకపోవచ్చు.
  • ఒక SQLite file అంటే ఒక node. Clustering లేదు. అందువల్ల రెండవ serverకు ప్రత్యేకమైన, వేరే memory ఉంటుంది.

2026 July నాటికి Version 1.0.4 మరియు సుమారు 329 stars ఈ project ఇంకా ప్రారంభ దశలో ఉందని చూపిస్తున్నాయి. Releases మధ్య flags, paths మరియు script names మారవచ్చు. ఎక్కడి నుంచైనా, దీనిలోని commandను కాపీ చేయడంపై ఆధారపడకుండా, మీ స్వంత checkoutలోని bin field మరియు npm run outputను చదవండి.

FAQ

ఆరోగ్య తనిఖీకి connection refused ఎందుకు వస్తుంది?

18960 పోర్ట్‌పై ఏదీ listening చేయడం లేదు. Failed to connect to 127.0.0.1 port 18960తో వచ్చిన curl exit code 7 అంటే memory service నడవడం లేదని లేదా startup సమయంలో ఆగిపోయిందని అర్థం. అందువల్ల అది ప్రారంభమైన terminal లేదా journal‌ను చదవండి. సాధారణంగా రెండు కారణాలు ఉంటాయి. ఒకటి, మీ Node version‌కు సరిపోని better-sqlite3 native module. దీన్ని npm rebuild better-sqlite3తో సరిచేయవచ్చు. మరొకటి, Node version 22 కంటే తక్కువగా ఉండటం. service ప్రారంభమైన తర్వాత ss -lntp | grep 18960తో socket‌ను నిర్ధారించండి.

source నుంచి build చేసిన తర్వాత memmy-memory command ఎక్కడి నుంచి వస్తుంది?

ఇది repository name నుంచి కాదు. @memmy/memory workspace package‌లోని bin field నుంచి వస్తుంది. checkout లోపల node -p "JSON.stringify(require('./Memory/package.json').bin)"ను run చేస్తే అది {"memmy-memory":"./dist/src/cli/index.js"}ను ముద్రిస్తుంది. npm run memory:build తర్వాత మాత్రమే ఆ file ఉంటుంది. ఎందుకంటే build distను సృష్టించి, ఆ file‌ను executable‌గా గుర్తిస్తుంది. దీన్ని node Memory/dist/src/cli/index.js healthగా run చేయండి లేదా చిన్న పేరుగా ఉపయోగించడానికి /usr/local/binలోకి symlink చేయండి.

claude mcp addతో Memmyని Claude Codeకు జోడించవచ్చా?

లేదు. Memmy ఒక MCP client, MCP server కాదు. ఇది ~/.memmy/config.yamlలోని tools.mcpServers కింద జాబితా చేసిన servers‌కు outbound connections ఏర్పాటు చేసి, వాటి tools‌ను తన runtime‌కు అందిస్తుంది. Claude Code దీనికి విరుద్ధమైన విధానంలో Memmyని చేరుతుంది. ఇది memmy-memory CLIని shell command‌గా run చేస్తుంది. దీనికి memmy-memory init --agent agent rules directoryలో రాసే instruction file మార్గనిర్దేశం చేస్తుంది.

Memmyని run చేస్తే నా memories cloud serviceకు పంపబడతాయా?

Scanning మరియు ingestion స్థానికంగానే జరుగుతాయి. Memories మీ స్వంత diskలోని ~/.memmy/memory-service/memory.sqliteకు రాయబడతాయి. Account mode మరియు trial tokens కోసం MEMMY_CLOUD_SERVICE, https://memmy-api.memtensor.cnను సూచిస్తుంది. మీరు దాన్ని enable చేసే వరకు memory improvement program నిలిపి ఉంటుంది. గమనించాల్సిన మార్గం embedding provider. ఇది ప్రతి memoryని vector‌గా మార్చేటప్పుడు, ఆ memoryలోని text మొత్తాన్ని hosted embedding modelకు పంపుతుంది. ఇది ముఖ్యమైతే, మీరు స్వయంగా నడిపే endpoint‌ను ఉపయోగించండి.

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