Jinsi ya kuweka Memmy kwenye VPS kwa mawakala wa AI

Memmy ni nini na inahifadhi nini

Memmy ni kitovu cha kumbukumbu cha ndani kwa ajili ya AI agents kinachofanya kazi kwenye VPS (virtual private server) yako mwenyewe. Inatunza database moja ya SQLite ya mambo ambayo agents wako wamejifunza, na kila agent kwenye seva hiyo husoma na kuandika kwenye hifadhi hiyo hiyo. Mradi huu ni memmy-agent kutoka MemTensor, una leseni ya MIT, na uko kwenye toleo la 1.2.401 kufikia tarehe 1 Novemba 2026; Memory ina toleo lake la pekee la 2.1.7.

Sehemu yake tu ndiyo muhimu kwenye seva. Memmy inatoa huduma ya kumbukumbu (memory service) inayolenga http://127.0.0.1:18960, kiolesura cha mstari wa amri (CLI) cha memmy-memory kinachowasiliana na huduma hiyo, na workbench ya desktop. Workbench imefungashwa kwa ajili ya macOS na Windows pekee, kwa hivyo kwenye Linux VPS unaendesha huduma hiyo na CLI. Hiyo inatosha kuipa Claude Code, Codex na Cursor kumbukumbu ya pamoja.

Memmy hupanga kile inachohifadhi katika tabaka nne. Capture kwanza huhifadhi Raw Turn tofauti, kisha huandika kipengee kimoja cha L1 Trace kwa kila hatua iliyonaswa, ikijumuisha maombi, majibu, wito wa zana (tool calls) na matokeo. L2 Policy ni utaratibu uliotokana na traces zilizothibitika kuwa na manufaa. L3 World Model ni maarifa thabiti kuhusu mradi au mazingira. Skill ni utaratibu unaoweza kuitwa (callable procedure) ulioundwa kutoka kwa sera. Capture hutengeneza L1 traces, kazi za usuli (background jobs) huboresha tabaka za juu, na uandishi wa wazi unaweza kuchagua tabaka. Ikiwa tofauti hizo zinaonekana kuwa za kufikirika, kumbukumbu ni moja ya hatua za baadaye katika njia iliyopangwa ya kujifunza kujenga agents, na tabaka hizo huwa na maana zaidi mara tu unapokuwa umeandika loop ya agent rahisi mwenyewe na kuitazama ikisahau kila kitu kati ya run moja na nyingine.

Mabadiliko yanayoletwa na kitovu cha kumbukumbu ya pamoja ikilinganishwa na kumbukumbu ya kila zana

Kila wakala (agent) kwa sasa anakuja na kumbukumbu yake binafsi. Claude Code huhifadhi faili za maelekezo ndani ya hazina (repository). Cursor huhifadhi kanuni katika hifadhidata ya workspace yake. Codex huhifadhi kumbukumbu za kikao chini ya ~/.codex. Kila hifadhi ni ya zana moja tu, kwa hivyo ukweli ulioufafanua siku ya Jumatatu katika zana moja haujulikani siku ya Jumanne katika zana nyingine. Unalipia hili mara mbili: mara ya kwanza kwa token zinazotumika kuelezea upya mradi uleule, na mara ya pili kwa kazi isiyo sahihi pale wakala anapofanya kazi kwa dhana uliyokwisha kuirekebisha mahali pengine.

Kitovu (hub) huhamisha hifadhi hiyo kutoka kwenye zana. Memmy pia husoma hifadhi zilizopo, kwa hivyo huanzi na hifadhidata tupu. Kichanganuzi chake kinajua vyanzo kumi vilivyojengwa ndani: Claude Code katika ~/.claude/projects/**/*.jsonl, Codex katika ~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-*.jsonl, OpenCode katika ~/.local/share/opencode/opencode.db, faili za state.vscdb za Cursor, hifadhidata za SQLite za OpenClaw chini ya ~/.openclaw, Hermes chini ya ~/.hermes, DeepSeek Harness chini ya ~/.dsh/sessions, WorkBuddy chini ya ~/.workbuddy/projects, Pi chini ya ~/.pi/agent/sessions na QwenWork chini ya ~/.qwenworkcn/projects. Workbench ya desktop inaweza kuongeza wakala mwingine kwa jina, na huulizia njia ya historia yake pale tu inaposhindwa kumpata wakala huyo yenyewe. Kichanganuzi cha upande wa seva (server-side scanner) hakina vyanzo maalum, kwa hivyo kwenye VPS isiyo na kiolesura (headless) unapata vile vilivyojengwa ndani.

Vihesabio vya kuingiza data (import counters) havitalingana, na hilo linatarajiwa. Kichanganuzi huweka ujumbe katika makundi kulingana na chanzo na mazungumzo, kisha huandika kumbukumbu moja ya L1 kwa kila zamu (turn) iliyokamilika. Zamu huhesabiwa kuwa imekamilika pale inapokuwa na maudhui ya mtumiaji yasiyo tupu na kuishia na ujumbe wa msaidizi usio tupu, kwa hivyo zamu isiyokamilika haiongezi chochote hadi usawazishaji (sync) wa baadaye utakapoweza kuikamilisha. Ujumbe huondolewa nakala rudufu (deduplicated) kwa kutumia vituo vya ukaguzi vya mazungumzo na vitambulisho vya zamu vilivyo thabiti. Idadi iliyochanganuliwa, idadi ya ujumbe ulioingizwa, na idadi ya kumbukumbu mpya zote hutofautiana katika utekelezaji mmoja.

Hii ndiyo sehemu inayooana na jinsi Claude Code inavyosimamia muktadha ndani ya kikao kimoja. Usimamizi wa muktadha huamua kile kinachotoshea kwenye dirisha moja. Kitovu cha kumbukumbu huamua kile kinachobaki baada ya dirisha hilo kufungwa.

Mahitaji kwenye VPS yako

• Node.js 22 au toleo jipya zaidi. Nyaraka za Memmy zinahitaji hili, na Ubuntu 24.04 inakuja na Node 18.
• git na zana za ujenzi (build toolchain), kwa sababu better-sqlite3 ni moduli ya asili (native module) inayoweza kuhitaji kukusanywa (compile) wakati wa usakinishaji.
• RAM ya kutosha kwa ajili ya usakinishaji wa root workspace na mnyororo wa ujenzi wa frontend.
• Nafasi ya diski kwa ajili ya node_modules na hifadhidata.

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 inapaswa kuonyesha v22 au zaidi kwa ajili ya ujenzi wa chanzo (source build) uliokusudiwa. v18 hapa inamaanisha hatua ya NodeSource haikufanikiwa. engine-strict ya npm kwa kawaida huwa false, hivyo tamko la injini lisiloendana kwa kawaida hutoa onyo badala ya kusababisha usakinishaji kufeli moja kwa moja.

Kusakinisha Memmy kutoka kwenye source kwenye Ubuntu 24.04

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 hukusanya (compile) @memmy/memory workspace kuwa Memory/dist. Pia hujenga AgentSourceCore, kitazamaji cha kumbukumbu (memory viewer), na rasilimali za ushirikiano zinazohitajika na workspace hiyo. Hakikisha kuwa native module imepakiwa:

node -e "const Database = require('better-sqlite3'); const db = new Database(':memory:'); db.close(); console.log('better-sqlite3 loads')"

Ikiwa mstari huo utatoa hitilafu badala ya kuchapisha matokeo, soma hitilafu hiyo ili kubaini tatizo la upakiaji au kushindwa kuanzisha database. Kwa kutolingana kwa native module, endesha npm rebuild better-sqlite3, ambalo ndilo hasa ambalo script ya kuanzia ya mradi huo hufanya kabla ya kuzindua chochote.

README huorodhesha bash scripts/dev-start.sh kama amri moja ya kuanzisha. Usiiendeshe kwenye headless VPS. Inazindua Electron desktop shell na Vite dev server kwenye port 19000 kando ya huduma ya kumbukumbu, na Electron inahitaji display; kwa hivyo kwenye seva isiyo na graphical session, script hiyo hukwama au kutoka.

Matoleo ya hivi karibuni pia huambatanisha memmy-agent-linux-cli.tar.gz na install.sh kwa Linux x64 na arm64. Kisakinishi kinahitaji Node.js 22.23.4+ ndani ya 22.x, 24.22.1+ ndani ya 24.x, au 26.12.1+ ndani ya 26.x, pamoja na systemd user session; hukataa matoleo mengine makuu. Huweka vizinduzi vya memmy na memmy-memory kwenye ~/.local/bin, na kuanzisha huduma ya kumbukumbu kama user unit kwenye 127.0.0.1:18960. Mwongozo huu unadumisha ujenzi kutoka kwenye source kwa sababu ndiyo njia unayoweza kusoma kila script kabla haijaendeshwa.

Anzisha huduma ya memory na uhakikishe inajibu

npm run memory:serve:dev

Hiyo ndiyo njia iliyoandikwa kwenye nyaraka ya kuendesha huduma ya memory kutoka kwenye source. Inajifunga kwenye 127.0.0.1:18960, inahifadhi database kwenye ~/.memmy/memory-service/memory.sqlite, na inasoma usanidi kutoka ~/.memmy/config.yaml. Seva inakubali thamani zilezile kama flags pale unapotaka ziwe wazi:

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

Kutoka kwenye shell ya pili, iulize huduma kama iko hai:

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

Health haiulizii token, ndiyo maana ndiyo probe sahihi. Ikiwa curl itatoka na code 7 na ujumbe wa Failed to connect to 127.0.0.1 port 18960, muunganisho umefeli; hilo pekee halithibitishi kama kuna listener. Kagua anwani, port na firewall ya ndani, na usome terminal inayoendesha huduma hiyo kwa ajili ya makosa ya kuanza. ss -lntp | grep 18960 inathibitisha socket pindi huduma inapokuwa juu.

Sehemu nyingine ya HTTP API (application programming interface) ipo chini ya /api/v1.

• POST /api/v1/memory/add inaandika memory na POST /api/v1/memory/search inafanya query.
• GET /api/v1/memory/:id na DELETE /api/v1/memory/:id zinasoma na kufuta ingizo moja.
• POST /api/v1/sessions/open na POST /api/v1/sessions/:sessionId/close zinaweka mabano kwenye session ya agent.
• POST /api/v1/turns/start na POST /api/v1/turns/:turnId/complete zinarekodi zamu moja.
• GET /api/v1/panel/overview, /api/v1/panel/analysis na /api/v1/panel/items zinalisha dashboard.

Memmy inatenga kundi la ports, na ukiwa kwenye seva ya headless unatumia ya kwanza pekee: 18960 kwa ajili ya memory, 18970 kwa ajili ya afya ya gateway, 18980 kwa ajili ya web UI na admin HTTP, 18990 kwa ajili ya API inayooana na OpenAI ambayo memmy serve inaiwasha, kisha 19000 kwa ajili ya Vite dev server ya desktop frontend na 19001 kwa ajili ya socket yake ya hot reload. Ukurasa wa ports wa mradi bado unaorodhesha 19010 kwa ajili ya hot reload, lakini usanidi wa Vite unaweka 19001. Ikiwa kitu kwenye mashine yako tayari kinatumia mojawapo ya hizo, orodha hiyo ndiyo mahali pa kuangalia.

Mahali ambapo amri ya memmy-memory inatoka kihalisi

Hapa ndipo usakinishaji wa kwanza unapokwama mara nyingi, kwa hivyo isome kutoka kwenye kifurushi badala ya kukisia. Jina la amri halina uhusiano wowote na jina la hazina (repository). Inatoka kwenye uwanja wa bin wa workspace inayoiainisha:

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

Hiyo huchapisha {"memmy-memory":"./dist/src/cli/index.js"}. Kwa hivyo, sehemu ya kuingilia (entry point) iliyojengwa ni Memory/dist/src/cli/index.js, na ipo tu baada ya npm run memory:build, kwa sababu ujenzi (build) ndio unaounda dist na kuifanya faili hiyo iweze kutekelezeka (executable). Iendeshe moja kwa moja:

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

Ikiwa unataka jina fupi kwenye PATH yako, unganisha (link) faili hiyo hiyo:

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

CLI hii hutumia http://127.0.0.1:18960 kama chaguo-msingi na inakubali --url, --token, --config, --source na --user-id. Amri zake ndogo (subcommands) ni init, health, search, add, get na delete, pamoja na wito wa session na turn ambao hutumiwa na mawakala (agents) badala ya watu, na install, upgrade, service na stop kwa ajili ya kusimamia huduma yenyewe. memmy-memory search "deploy steps" na memmy-memory add "staging migrates on deploy" ndizo mbili ambazo wakala huendesha mara nyingi zaidi.

Je, unaunganishaje Claude Code na Memmy?

Memmy haijisajili kama seva ndani ya Claude Code. Inaunganishwa kupitia faili ambazo Claude Code tayari inazisoma, na uwezo wake unategemea memmy-memory unayoiendesha. Kutoka kwenye source checkout, memmy-memory init --agent claude huandika Skill ya memmy-memory ndani ya ~/.claude/skills/ na block ya kumbukumbu iliyotiwa alama ndani ya ~/.claude/CLAUDE.md, kisha Claude Code huendesha memmy-memory kama amri ya kawaida ya shell wakati maelekezo hayo yanapoiambia ifanye hivyo. Kizinduzi (launcher) ambacho kisakinishi cha Linux kukiweka ndani ya ~/.local/bin kinaenda mbali zaidi: amri hiyo hiyo pia inasajili hooks ndani ya ~/.claude/settings.json kwa ajili ya SessionStart, UserPromptSubmit, Stop, PostCompact na SessionEnd, ambazo huingiza kumbukumbu husika na kuhifadhi kila hatua iliyokamilika bila mfano (model) kulazimika kuamua kufanya hivyo.

Andika maelekezo hayo kwa mkono mara moja, kwa sababu hapo utajua hasa kile ambacho wakala (agent) aliambiwa. Claude Code inasoma CLAUDE.md kutoka kwenye mzizi wa mradi (project root) mwanzoni mwa kila kipindi (session), kwa hivyo sehemu kama hii ndiyo muunganisho mzima kwenye njia ya source:

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

Kuwa wazi kuhusu kile unachopata kwa kufanya hivyo. Bila hooks, huu ni muunganisho wa kiwango cha maelekezo, kwa hivyo hufanya kazi wakati mfano unapoamua kuendesha amri, na si vinginevyo. Hakuna kinacholazimisha wito huo. Ikiwa kipindi kitaisha bila add, maelekezo yenyewe hayakuhifadhi chochote; uchunguzi wa historia baadaye bado unaweza kuingiza hatua iliyokamilika. Huo ni ubadilishano (trade-off) uleule kama faili za kumbukumbu za Claude Code zenyewe, isipokuwa kwa tofauti moja: hifadhi inashirikiwa, kwa hivyo dokezo hilo pia hufika kwenye Codex na Cursor kwenye mashine hiyo hiyo. Hooks huziba pengo badala ya kuomba kwa upole, jambo ambalo pia ndiyo sababu kumbukumbu ya kudumu (durable memory) inakaa pamoja na vikomo vya bajeti na sheria za ruhusa miongoni mwa plugins za DeepSeek Harness zinazofaa kusakinishwa.

Upande mwingine hauhitaji usanidi wowote. Scanner ya Memmy tayari inasoma ~/.claude/projects/**/*.jsonl, ambapo Claude Code huandika nakala za vipindi vyake (session transcripts). Endesha Memmy kwenye seva hiyo hiyo unapoendesha Claude Code ndani ya tmux session na kazi ya jana inakuwa kumbukumbu bila wewe kusanidi chochote.

Je, Memmy inafanya kazi kama seva ya MCP kwa ajili ya Claude Code?

Hapana, na kufahamu mwelekeo huu kutakuokoa muda mwingi. MCP (model context protocol) ina wateja (clients) na seva. Memmy ni mteja. Huunganisha kwenye seva za MCP na kutoa zana zake kwa runtime ya wakala wake. Haichapishi endpoint ya MCP ambayo claude mcp add inaweza kuelekezwa kwayo. Daraja pekee la MCP katika hazina hii ni lile la ushirikiano wa Composio ndani ya API ya ndani ya desktop, na API hiyo hufunga port ya nasibu kwenye 127.0.0.1 nyuma ya header yake yenyewe ya x-memmy-mcp-token.

Upande wa mteja umesanidiwa katika ~/.memmy/config.yaml, faili ambalo MEMMY_CONFIG linaelekeza kwalo, chini ya tools.mcpServers:

tools:
  mcpServers:
    example:
      type: stdio
      command: npx
      args:
        - "-y"
        - "your-mcp-server"
      toolTimeout: 30
      enabledTools:
        - "*"

type inakubali stdio, sse na streamableHttp. Seva ya stdio huendeshwa kama mchakato mtoto (child process) wa Memmy, jambo linalomaanisha kuwa amri yake lazima iwepo kwenye mashine hiyo hiyo na iendeshwe na mtumiaji yule yule. Ikiwa tayari unadumisha seva za MCP zinazoendeshwa kwenye VPS, hizo ndizo unazopaswa kuziorodhesha hapa.

Kuweka hifadhi ya kumbukumbu kuwa ya faragha

Kila kitu kinachomilikiwa na Memmy kipo chini ya ~/.memmy: config.yaml, workspace, memory-service/memory.sqlite na faili za runtime. Uchanganuzi na uingizaji wa data hufanyika ndani ya seva (locally), na kumbukumbu huandikwa kwenye faili hiyo ya SQLite ya ndani, kwa hivyo hali ya kawaida ni ya ndani kabisa.

Muunganisho wa cloud ni njia moja ya kuifuatilia. MEMMY_CLOUD_SERVICE hutaja asili ya cloud. Kanuni (code) haiweki thamani chaguo-msingi kwa ajili yake, lakini .env.example, ambayo hatua za usakinishaji hunakili kwenye .env, huiweka kuwa https://api.memmy.cn. Hii huwezesha hali ya akaunti (account mode) pamoja na token zake za majaribio, na wakati wowote inapowekwa, kanuni ya analytics ya Memmy pia hutuma matukio ya matumizi huko, hata katika hali ya API key: majina ya matukio na amri, matoleo, na kitambulisho cha usakinishaji (installation ID). CLI huripoti maneno ya amri yaliyowekwa pekee, kamwe haitumi hoja za utafutaji au maandishi ya kumbukumbu, na kanuni ya analytics haitumi chochote wakati thamani hiyo haijawekwa. Kwa hivyo, kwenye seva inayotumia API keys pekee, futa mstari huo katika .env kabla ya kuanza chochote. Programu ya uboreshaji wa kumbukumbu ni swichi tofauti katika mipangilio ya faragha.

Miito ya modeli (model calls) ni njia nyingine. Ukisanidi mtoa huduma wa embedding anayehifadhiwa kwenye cloud, maandishi ya kumbukumbu yanayofanyiwa embedding hutumwa kwa mtoa huduma huyo ili yaweze kugeuzwa kuwa vector. Hifadhi ya ndani haisaidii katika hali hiyo. Tumia mtoa huduma wa embedding wa ndani (built-in) au endpoint ya embedding unayojiendeshea mwenyewe ili kufunga njia hiyo. Modeli za muhtasari, mageuzi, na uchujaji wa umuhimu (relevance-filter) zinazohifadhiwa kwenye cloud pia hupokea maudhui ya kumbukumbu wakati kazi hizo zinapoendeshwa, kwa hivyo kagua mipangilio hiyo ya modeli pia.

Weka port 18960 kwenye loopback address. Haihitaji sheria ya firewall, kwa sababu huduma iliyofungwa kwenye 127.0.0.1 haipatikani kabisa kutoka nje ya seva. Ifikie kutoka kwenye laptop yako kupitia SSH badala yake:

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

Huduma ya sasa ya kumbukumbu hukataa anwani za bind zisizo za loopback. Kuweka storage.token katika usanidi, au kutumia MEMMY_MEMORY_TOKEN au MEMORY_SERVICE_TOKEN kama environment variable, hulinda miito ya kawaida ya API ya kumbukumbu kwa kutumia bearer token; afya ya huduma (health) haihitaji uthibitisho, na kivinjari cha kutazama (browser viewer) hutumia ukaguzi tofauti kwa maombi ya ndani. Thamani za usanidi huunga mkono marejeleo ya ${ENV_NAME}, kwa hivyo token na API keys za modeli yako hubaki nje ya faili yenyewe. Hiyo ni tabia sawa na kuweka siri nje ya AI agents kwingineko, na sera ya ufw ya kuzuia kila kitu kwa chaguo-msingi ni kinga yako ya mwisho ikiwa toleo la baadaye litabadilisha anwani yake ya bind ya chaguo-msingi.

Hifadhi nakala ya ~/.memmy kabla ya kuitegemea

memory.sqlite ndilo hifadhi nzima. Vektari hukaa kwenye faili hilo hilo kupitia kiendelezi cha sqlite-vec, kwa hivyo faili moja ndilo hifadhi nakala. Kunakili faili hilo kwa cp wakati huduma inaandika kunaweza kusababisha database kuharibika. Tumia amri ya hifadhi nakala ya SQLite yenyewe:

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

Hiyo hutengeneza nakala thabiti wakati huduma inaendelea kufanya kazi. Ihamishe kutoka kwenye seva hiyo kwa ratiba, jambo ambalo ndilo kusudi la restic kwa hifadhi ya nje. Kupoteza config.yaml kunakugharimu mipangilio ya mtoa huduma ambayo unaweza kuandika upya. Kupoteza memory.sqlite kunakugharimu kumbukumbu zilizorekodiwa tangu hifadhi nakala yako ya mwisho inayoweza kutumika; huduma pia hutengeneza hifadhi nakala ya ndani kabla ya mabadiliko ya schema, lakini hiyo si nakala ya sasa ya nje ya seva.

Endesha huduma ya memory chini ya systemd

npm run memory:serve:dev katika shell hufa shell inapofungwa. Faili la unit huweka huduma ikiwa hai baada ya reboot. Huduma huendeshwa kama mtumiaji memmy, kutoka kwenye checkout katika /opt/memmy, ikiwa na configuration yake katika home directory ya mtumiaji huyo. Simamisha nakala inayokimbia kwenye shell yako, kisha hamisha checkout na configuration, na uelekeze upya link ya memmy-memory:

sudo useradd -m -s /bin/bash memmy
sudo mkdir -p /opt/memmy
sudo mv ~/memmy-agent /opt/memmy/memmy-agent
sudo chown -R memmy:memmy /opt/memmy
sudo ln -sfn /opt/memmy/memmy-agent/Memory/dist/src/cli/index.js /usr/local/bin/memmy-memory
sudo install -d -o memmy -g memmy -m 700 /home/memmy/.memmy
sudo install -o memmy -g memmy -m 600 ~/.memmy/config.yaml /home/memmy/.memmy/config.yaml
sudo install -d -m 755 /etc/memmy

Huduma huhifadhi database yake chini ya /home/memmy/.memmy, kwa hivyo huanza na hifadhi tupu.

[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

Weka token nje ya unit. Iweke katika /etc/memmy/memory.env, inayomilikiwa na root, ikiwa na 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=203/EXEC katika matokeo ya status inamaanisha systemd haikuweza kuendesha ExecStart hata kidogo, kwa hivyo kagua which npm: ni /usr/bin/npm kwenye usakinishaji wa NodeSource na kitu fulani chini ya home ya mtumiaji kwenye nvm, ambacho systemd haitakipata. Unit inayoanza na kuzima mara moja inahitaji exit status na journal yake ikaguliwe: code 0 ni kuzima kwa usahihi, wakati matokeo mengine yanajumuisha exit zisizo za sifuri, signals na timeouts. Endesha journalctl -u memmy-memory -n 50 kwa ajili ya matokeo ya huduma hiyo. Mbinu hizi ni sawa na huduma nyingine yoyote ya systemd kwenye VPS.

Mradi sasa unatoa njia mbadala mbili za kiwango cha mtumiaji. Njia ya README kwa ajili ya source build ni memmy-memory install --service-only, ambayo hupakua runtime ya Memory iliyopangwa na kusajili huduma ya mtumiaji, na kisakinishi cha Linux huweka memmy-memory.service kama unit ya systemd --user. Hakuna inayowezesha linger, kwa hivyo endesha sudo loginctl enable-linger <user> ili kuweka meneja wa huduma wa mtumiaji huyo akiwa anaendelea kukimbia baada ya logout na kuianzisha wakati wa boot.

Mambo ambayo Memmy haijafanya bado

• Hakuna build ya desktop ya Linux. Script za upakiaji zinashughulikia macOS na Windows pekee, kwa hivyo workbench na wizard yake ya onboarding hazipatikani kwenye seva yenyewe. Huduma ya memory sasa inajumuisha browser viewer katika http://127.0.0.1:18960/viewer/, inayoweza kufikiwa kupitia SSH tunnel iliyo hapo juu. Linux hupata CLI tarball na install.sh badala yake.
• memory:serve:dev huendesha TypeScript entry point kupitia tsx, ambayo ni njia ya maendeleo (development path). Repository pia husafirisha memory:serve kwa ajili ya output iliyokusanywa (compiled output). Endesha npm run bila hoja (arguments) ili kuona ni script zipi ambazo checkout yako inazo kwa sasa.
• Retrieval hujenga dirisha lake la utafutaji kutoka kwa safu 2,000 za mwisho za vector, kisha hutumia uteuzi wa Top-K ndani ya dirisha hilo. Kwenye hifadhi kubwa sana, kumbukumbu ya zamani inaweza kubaki nje ya dirisha hilo.
• Embedding hutokea baada ya kunasa (capture), na hitilafu hupelekwa kwenye foleni ya kujaribu tena (retry queue) badala ya kuzuia zamu ya agent. Kumbukumbu iliyoongezwa muda mfupi uliopita inaweza isiweze kupatikana kwa utafutaji wa vector bado.
• Seva ya pili yenye database yake ya ndani ya SQLite ina kumbukumbu tofauti.

Toleo la 1.2.401 kufikia tarehe 1 Novemba 2026 bado linaelezea mradi mchanga unaoendelea kwa kasi. Flag, path, na majina ya script hubadilika kati ya releases. Soma sehemu ya bin na output ya npm run katika checkout yako mwenyewe badala ya kuamini amri iliyonakiliwa kutoka popote, ikiwemo hapa.

FAQ

Kwa nini health check inarudisha connection refused?

Exit code 7 ya curl pamoja na Failed to connect to 127.0.0.1 port 18960 inaashiria kuwa muunganisho umeshindwa, haionyeshi kama Memmy imesimama, imekwama, inasikiliza kwenye port nyingine, au haipatikani. Hakikisha anwani na port ni sahihi, endesha ss -lntp | grep 18960, na usome terminal au journal ambapo huduma ilianzishwa. Ikiwa logi inaripoti kutolingana kwa native SQLite module, endesha npm rebuild better-sqlite3. Angalia pia toleo lako la Node: nyaraka za chanzo zinahitaji Node 22 au mpya zaidi, wakati kisakinishi cha Linux kinakubali tu Node.js 22.23.4+ ndani ya 22.x, 24.22.1+ ndani ya 24.x, au 26.12.1+ ndani ya 26.x.

Amri ya memmy-memory inatoka wapi baada ya kujenga kutoka kwenye chanzo?

Inatoka kwenye sehemu ya bin ya kifurushi cha workspace cha @memmy/memory, si kutoka kwa jina la repository. Endesha node -p "JSON.stringify(require('./Memory/package.json').bin)" ndani ya checkout na itachapisha {"memmy-memory":"./dist/src/cli/index.js"}. Faili hiyo ipo tu baada ya npm run memory:build, kwa sababu ujenzi hutengeneza dist na kuweka alama ya faili hiyo kuwa executable. Iendeshe kama node Memory/dist/src/cli/index.js health, au tengeneza symlink kwenye /usr/local/bin ili kutumia jina fupi.

Je, ninaweza kuongeza Memmy kwenye Claude Code kwa kutumia claude mcp add?

Hapana. Memmy ni MCP client, si MCP server. Inaunganisha kwenye seva zilizoorodheshwa chini ya tools.mcpServers katika ~/.memmy/config.yaml na kutoa zana zao kwa runtime yake yenyewe. Claude Code hufikia Memmy kwa njia nyingine, kwa kuendesha CLI ya memmy-memory kama amri ya shell. memmy-memory init --agent claude huandika Skill na block ya CLAUDE.md inayoiambia wakati wa kuitumia, na launcher kutoka kwa kisakinishi cha Linux pia huongeza hooks za Claude Code zinazohifadhi zamu kiotomatiki.

Je, kuendesha Memmy kunatuma kumbukumbu zangu kwenye huduma ya wingu?

Uchanganuzi na uingizaji data hufanyika ndani ya kifaa chako, na kumbukumbu huandikwa kwenye ~/.memmy/memory-service/memory.sqlite kwenye diski yako mwenyewe. MEMMY_CLOUD_SERVICE, iliyowekwa kuwa https://api.memmy.cn katika .env.example, inahudumia hali ya akaunti na tokeni za majaribio na kupokea takwimu za matumizi bila maandishi ya kumbukumbu wakati imewekwa, kwa hivyo iache wazi ikiwa unatumia API keys pekee. Programu ya kuboresha kumbukumbu ina swichi tofauti ya faragha. Model ya embedding inayohudumiwa hupokea maandishi ya kumbukumbu inayoyageuza kuwa vector; tumia mtoa huduma wa ndani (local provider) au endpoint unayoiendesha mwenyewe ili kuweka usindikaji huo ndani ya kifaa chako. Model za muhtasari, mageuzi, na vichujio vya umuhimu vinavyohudumiwa pia hupokea maudhui ya kumbukumbu wakati kazi hizo zinapoendeshwa.