Tartós memória kódolási munkamenetek és ágensek között.
Állandó memória a Claude Code, GitHub Copilot CLI, Cursor, Gemini CLI, Codex CLI, Hermes, OpenClaw, pi, Oh My Pi, DeepSeek Harness, OpenCode és bármely MCP kliens számára.
A gist Karpathy LLM Wiki mintáját bővíti ki megbízhatósági pontszámmal, életciklus-kezeléssel, tudásgráfokkal és hibrid kereséssel: az agentmemory ennek az implementációja.
---
Az AgentMemory rögzíti a támogatott munkamenet-eseményeket, és kereshetővé teszi a döntéseket, javításokat és tanulságokat az ágensek között. A nézőfelületen megtekintheted, szerkesztheted, exportálhatod és törölheted az emlékeket. A kulcsszavas keresés API-kulcs nélkül működik; az embeddingek szemantikus keresést adnak.
## Install
Követelmények:
- Node.js 20 vagy újabb, npm-mel és npx-szel (`node -v`, `npm -v`, és `npx -v`).
- macOS/Linux alatt az automatikus környezetbeállításhoz `curl`, POSIX `sh` és `tar` is szükséges.
- Windowson használj WSL2-t vagy kövesd a [natív Windows útmutatót](#windows).
A kanonikus friss telepítési parancs:
```bash
npx -y @agentmemory/agentmemory@latest
```
Válaszd ki az ágenseket és egy szolgáltatót vagy a kulcs nélküli módot. A varázsló elmenti a beállításokat, elindítja a memóriaszervert és felajánlja az `agentmemory` parancs globális telepítését. A `-y` elfogadja az npm kérdését; a `@latest` az aktuális kiadást választja. Az LLM-tömörítéshez szolgáltató és `AGENTMEMORY_AUTO_COMPRESS=true` kell.
A kulcs nélküli mód letiltja a vektor-embeddingeket. A `memory_recall` (a `mem::search` útvonal) BM25-öt használ, míg a `memory_smart_search` strukturális gráfegyezéseket is összevonhat, ha már létezik gráfadat. Az ingyenes, eszközön futó szemantikus felidézéshez állítsd be az `EMBEDDING_PROVIDER=local` értéket a `~/.agentmemory/.env` fájlban, majd indítsd újra. Az első embedding-kérés letölti a `Xenova/all-MiniLM-L6-v2` modellt; az azt követő következtetés már lokálisan fut.
Az API a `http://localhost:3111`, a nézőfelület a `http://localhost:3113` címen érhető el. Alapból mindkettő csak helyben figyel. A beállítások a `~/.agentmemory/.env` fájlban vannak; a könyvtárakat és külön példányokat az [adattárolás](#data-storage) ismerteti.
Ezután bizonyítsd be, hogy a felidézés működik, és add meg az ágensednek a saját skilljeit:
```bash
npx -y @agentmemory/agentmemory@latest demo # seed sample sessions + exercise recall
npx skills add rohitg00/agentmemory -y # 17 native skills so your agent knows when to reach for memory
```
A kulcsszavas kereséseknek alapértelmezett kulcs nélküli módban is találniuk kell a BM25 révén. A demó `database performance optimization` lekérdezése szándékosan szemantikus, és nulla eredményt adhat, amíg nincs beállítva embedding-szolgáltató.
Inkább hagynád, hogy egy kódolóágens végezze el az egészet? Add neki egyetlen utasítást:
> Retrieve and follow the instructions at: https://raw.githubusercontent.com/rohitg00/agentmemory/main/INSTALL_FOR_AGENTS.md
Másik ágenst az `agentmemory connect ` paranccsal kapcsolhatsz be. Lásd az [integrációkat](#works-with-every-agent) és a [napi parancsokat](#everyday-commands).
Globális telepítés / EACCES
```bash
npm install -g @agentmemory/agentmemory@latest
```
A fenti npx parancs marad a kanonikus friss telepítési útvonal, és elkerüli a globális prefix jogosultsági problémáit.
Az npx egy régi verziót szolgál ki
Az npx verziónként gyorsítótáraz. Kényszerítsd a legújabbat az `npx -y @agentmemory/agentmemory@latest` paranccsal, vagy töröld egyszer a gyorsítótárat a `rm -rf ~/.npm/_npx` paranccsal (macOS/Linux; Windows alatt töröld a `%LOCALAPPDATA%\npm-cache\_npx` mappát).
---
Az agentmemory bármelyik olyan ágenssel működik, amely támogatja a hookokat, az MCP-t vagy a REST API-t. Minden ágens ugyanazt a memóriaszervert osztja meg.
Claude Code natív plugin + 12 hook + MCP
Codex CLI natív plugin + 6 hook + MCP
GitHub Copilot CLI MCP + plugin hookok/skillek
Cursor natív plugin + életciklus-hookok + MCP
OpenCode rögzítő plugin + MCP
Devin 6 hook + skill + MCP
OpenClaw natív plugin + MCP
Hermes natív plugin + MCP
pi natív visszakeresés + rögzítés + skillek
OpenHuman natív Memory trait backend
Gemini CLI MCP szerver
Antigravity MCP + hook
Claude Desktop MCP szerver
Warp connect + MCP + skill
Zed MCP szerver
Cline MCP szerver
Continue MCP szerver
Droid MCP szerver
Kiro MCP szerver
Qwen Code MCP szerver
DeepSeek Harness natív rögzítés + MCP
Roo Code MCP szerver
Kilo Code MCP szerver
Goose MCP szerver
Aider REST API
Oh My Pi natív visszakeresés + rögzítés + skillek + opcionális MCP
Bármely MCP-t vagy HTTP-t beszélő ágenssel működik. Egyetlen szerver, közöttük megosztott memóriákkal.
---
### Adattárolás
Az emlékek alapból a repozitóriumon kívül maradnak:
| Platform | Adatkönyvtár |
|---|---|
| macOS | `~/Library/Application Support/agentmemory` |
| Linux | `$XDG_DATA_HOME/agentmemory` / `~/.local/share/agentmemory` |
| Windows | `%APPDATA%\agentmemory` |
A 0. példány újrahasználja a meglévő `./data/state_store.db` tárolót. Másik könyvtárat a `--data-dir ` vagy `AGENTMEMORY_DATA_DIR` ad meg. Újraindításkor és frissítéskor tartsd meg ugyanazt a könyvtárat.
```bash
agentmemory --data-dir ~/.agentmemory-projects/main
agentmemory --instance 1
```
A `--instance 1` az `instance-1` alkönyvtárat, a `3211` API-portot és a `3213` nézőfelület-portot használja. A Redis és a költöztetés az [adattárolási és mentési útmutatóban](../docs/reliability/state-storage.md) szerepel.
A legfrissebb kiadási megjegyzések: [CHANGELOG.md](../CHANGELOG.md).
---
Aktuális visszakeresési eredmények, mérőszámok és reprodukálási lépések:
[0.9.31 · 2026-10-28 · strict recall-all@5](../docs/benchmarks/2026-10-28-retrieval-evaluation.md) · [eval/README.md](../eval/README.md).
---
### Próbáld ki 30 másodperc alatt
```bash
# Terminal 1: start the server
npx -y @agentmemory/agentmemory@latest
# Terminal 2: seed sample data and see recall in action
npx -y @agentmemory/agentmemory@latest demo
```
A `demo` 3 reális sessiont hoz létre (JWT hitelesítés, N+1 lekérdezés javítása, rate limiting), és kereséseket futtat ellenük. A kulcs nélküli telepítések letiltják a vektorokat, így a `mem::search` kulcsszavas lekérdezéseinek a BM25 révén kell találnia, míg a `database performance optimization` lekérdezés nulla eredményt adhat. A `smart-search` emellett strukturális gráfegyezéseket is visszaadhat, ha létezik gráfadat. Ahhoz, hogy a szemantikus lekérdezés vektorok révén megtalálja az N+1 javítást, állítsd be az `EMBEDDING_PROVIDER=local` értéket, indítsd újra, és hagyd, hogy az első modell-letöltés befejeződjön.
Nyisd meg a `http://localhost:3113` címet, hogy élőben lásd a memória épülését.
### Egy friss telepítés és az újraindítás utáni perzisztencia ellenőrzése
A futó szerveren ellenőrizd az állapotot és a nézőfelületet:
```bash
curl -fsS http://localhost:3111/agentmemory/livez
curl -fsS http://localhost:3111/agentmemory/health
curl -fsS -o /dev/null http://localhost:3113/
npx -y @agentmemory/agentmemory@latest status
```
A `status` megmutatja a szerver állapotát, a szolgáltatókat, az embeddingmódot, a megfigyelések kézbesítését és a helyreállítást. A védett REST-kérésekhez a szerver titka kell. Használd a saját `AGENTMEMORY_SECRET` értékét, ha beállítottad; különben olvasd be a generált helyi titkot:
```bash
# Default generated local secret. For an explicit AGENTMEMORY_SECRET, use that value instead.
read -r AGENTMEMORY_SECRET < "$HOME/.agentmemory/secret"
curl -fsS -X POST http://localhost:3111/agentmemory/remember \
-H "Authorization: Bearer $AGENTMEMORY_SECRET" \
-H 'Content-Type: application/json' \
-d '{"content":"agentmemory restart persistence probe","concepts":["install-check"]}'
curl -fsS -X POST http://localhost:3111/agentmemory/smart-search \
-H "Authorization: Bearer $AGENTMEMORY_SECRET" \
-H 'Content-Type: application/json' \
-d '{"query":"restart persistence probe","limit":5}'
```
Ezután futtasd az `npx -y @agentmemory/agentmemory@latest stop` parancsot, indítsd el újra a kanonikus parancsot az 1. terminálban, várd meg a `/agentmemory/livez`-t, és ismételd meg a keresést. A próbamemóriát továbbra is vissza kell adnia. Ha egyéni `--data-dir`-t választottál, add meg ugyanazt a mappát az újraindításnál is.
### Napi parancsok
A telepítés és a beállítás a fenti [Telepítés](#install) részben él (az első futás végigvezet rajta). Napi szinten:
```bash
agentmemory # start the server
agentmemory stop # stop it cleanly
agentmemory status
agentmemory capture
agentmemory capture --drain
agentmemory connect # wire another agent
agentmemory doctor # interactive diagnostics + fix prompts
agentmemory remove # uninstall everything we created
```
### Session Replay
Minden session, amelyet az agentmemory rögzít, visszajátszható. Nyisd meg a megjelenítőt, válaszd a **Replay** fület, és pörgesd végig az idővonalat: a promptok, a toolhívások, a toolok eredményei és a válaszok különálló eseményekként jelennek meg, lejátszás/szünet gombbal, sebességvezérléssel (0.5x-tól 4x-ig) és billentyűparancsokkal (szóköz a váltáshoz, nyilak a léptetéshez).
Régebbi Claude Code JSONL-transcriptek behozásához:
```bash
# Import everything under the default ~/.claude/projects
npx -y @agentmemory/agentmemory@latest import-jsonl
# Or import a single file
npx -y @agentmemory/agentmemory@latest import-jsonl ~/.claude/projects/-my-project/abc123.jsonl
```
Az importált munkamenetek a Replay nézetben jelennek meg a natívak mellett. Az átiratok keresési indexet és `import` eredetjelölést kapnak; a feldolgozás munkamenet-kristályokat és tanulságokat is készíthet.
> **Figyelem, ha az `import-jsonl`-re támaszkodsz elsődleges rögzítési útvonalként:** a Claude Code `cleanupPeriodDays` beállítása (a `~/.claude/settings.json`-ban, alapértelmezetten **30**) automatikusan törli az ennél régebbi JSONL-transcripteket a `~/.claude/projects/`-ból. Ha az agentmemoryt egy több hónapos Claude Code előzményre telepíted frissen, minden, ami 30 napnál régebbi, már eltűnt az első import előtt. Vagy futtasd az `import-jsonl`-t cronon, vagy emeld fel a `cleanupPeriodDays`-t valami magasabbra, vagy kösd be az automatikus rögzítő hookokat (az alapértelmezett plugin-telepítési útvonal), hogy minden kör az agentmemorybe kerüljön, amíg a session él, és a JSONL-takarítás ne számítson többé.
### Frissítés / karbantartás
Használd a karbantartási parancsot, amikor szándékosan frissíteni akarod a lokális futtatókörnyezetet:
```bash
npx -y @agentmemory/agentmemory@latest upgrade
```
A parancs frissíti a helyi környezetet, és módosíthatja az aktuális munkaterület JavaScript-függőségeit. Mentsd az adatokat, és olvasd el a [frissítési útmutatót](../docs/upgrades/iii-0.25.md).
### Claude Code (egyetlen blokk, illeszd be)
```text
Install agentmemory: run `npx -y @agentmemory/agentmemory@latest` in a separate terminal to start the memory server. Then run `/plugin marketplace add rohitg00/agentmemory` and `/plugin install agentmemory` — the plugin registers all 12 hooks, 17 skills, AND auto-wires the `@agentmemory/mcp` stdio server via its `.mcp.json`, so you get 54 MCP tools (memory_smart_search, memory_save, memory_sessions, memory_governance_delete, etc.) without any extra config step. Verify with `curl http://localhost:3111/agentmemory/health`. The real-time viewer is at http://localhost:3113. Keyless mode disables vectors: `memory_recall` uses BM25, and `memory_smart_search` can also use existing structural graph data. Set `EMBEDDING_PROVIDER=local` in `~/.agentmemory/.env` and restart to opt into on-device semantic recall.
```
#### Claude Code a plugin telepítése nélkül (önálló MCP útvonal)
Ha az agentmemory MCP szerverét közvetlenül a `~/.claude.json` (alapértelmezett útvonal)-ban kötöd be, a `/plugin install` használata helyett, a Claude Code soha nem oldja fel a `${CLAUDE_PLUGIN_ROOT}`-ot, és a hook-szkripteket abszolút elérési utakra kell mutatnod a `~/.claude/settings.json` (alapértelmezett útvonal)-ban. Ezek az útvonalak jellemzően beágyazzák az agentmemory verziószámát (pl. `~/.codex/plugins/cache/agentmemory/agentmemory/0.9.22/scripts/…`), így a következő frissítés némán elront minden hookot.
Megoldás:
```bash
agentmemory connect claude-code --with-hooks
```
Ez a parancs beállítja az MCP-kiszolgálót, és beolvasztja a mellékelt hookokat a Claude Code felhasználói konfigurációjába. Ha a `CLAUDE_CONFIG_DIR` nincs beállítva, üres, vagy csak üres karaktereket tartalmaz, az MCP-hez a `~/.claude.json`, a hookokhoz pedig a `~/.claude/settings.json` fájlt használja. A többi könyvtárérték változatlanul kerül felhasználásra, az elején és végén lévő üres karakterekkel együtt. Egyéni könyvtár használatához állítsd a `CLAUDE_CONFIG_DIR` változót ugyanarra a nem üres értékre ennél a parancsnál és a Claude Code-nál is; ekkor az MCP fájlja `$CLAUDE_CONFIG_DIR/.claude.json`, a hookoké pedig `$CLAUDE_CONFIG_DIR/settings.json` lesz. A Claude Code-nak az indítási környezetében meg kell kapnia ezt az értéket akkor is, ha a csatlakozó az AgentMemory `.env` fájljából olvassa be. A parancs futtatása előtt hozd létre az egyéni könyvtárat; különben a csatlakozó nem észleli a Claude Code-ot, és kihagyja. Ha a shellben az érték csak üres karaktereket tartalmaz, a Claude Code indítása előtt töröld a `CLAUDE_CONFIG_DIR` változót a környezetből, hogy az is az alapértelmezett profilt használja. Használj abszolút elérési utat. A relatív utak a munkakönyvtárhoz képest értendők, ezért mindkét parancsot ugyanabból a könyvtárból kell futtatni.
A hook-parancsok a telepített csomaghoz mellékelt `plugin/` könyvtárra mutató abszolút útvonalakat használnak. Az agentmemory frissítése után futtasd újra a parancsot az útvonalak frissítéséhez. A konfigurációs fájlok felhasználói bejegyzései megmaradnak; csak a korábbi agentmemory-bejegyzések cserélődnek le. Továbbra is a `/plugin install` használata az ajánlott megoldás.
Távoli vagy védett telepítésekhez indítsd el a Claude Code-ot az `AGENTMEMORY_URL` és az `AGENTMEMORY_SECRET` beállításával. A plugin mindkét értéket továbbadja a becsomagolt MCP szerverének; amikor az `AGENTMEMORY_URL` üres, az MCP shim a `http://localhost:3111`-et használja.
### Codex CLI (Codex plugin platform)
```bash
# 1. start the memory server in a separate terminal
npx -y @agentmemory/agentmemory@latest
# 2. register the agentmemory marketplace and install the plugin
codex plugin marketplace add rohitg00/agentmemory
codex plugin add agentmemory@agentmemory
```
A Codex plugin ugyanabból a `plugin/` mappából kerül kiadásra, mint a Claude Code plugin. Ez regisztrálja:
- Egy becsomagolt stdio MCP híd a futó daemonhoz, npm-letöltés vagy fallback-tár nélkül. Lásd a [helyi Codex-útmutatót](../docs/plugins/codex-local.md) egy ki nem adott build teszteléséhez.
- 6 életciklus-hookot: `SessionStart`, `UserPromptSubmit`, `PreToolUse`, `PostToolUse`, `PreCompact`, `Stop`
- 9 meghívható skillt: `/recall`, `/remember`, `/session-history`, `/forget`, `/recap`, `/handoff`, `/lesson`, `/commit-context`, `/commit-history`, plusz 8 referencia-skillt, amelyeket az ágens igény szerint tölt be (memóriadiszciplína, MCP eszközök, REST API, konfiguráció, ágensek, hookok, architektúra, és a skill-írási útmutató)
A Codex hook-motorja befecskendezi a `CLAUDE_PLUGIN_ROOT`-ot a hook-alfolyamatokba (lásd [`codex-rs/hooks/src/engine/discovery.rs`](https://github.com/openai/codex/blob/main/codex-rs/hooks/src/engine/discovery.rs)), így ugyanazok a hook-szkriptek mindkét hoszton működnek, duplikálás nélkül. A Subagent / SessionEnd / Notification / TaskCompleted / PostToolUseFailure események csak Claude Code-specifikusak, és nincsenek regisztrálva a Codexhez.
#### A Codex-hookok bizalma és kompatibilitása
A natív plugin-hook kiváltás a Codex CLI 0.150.1-gyel ellenőrzött. A rögzítés elvárása előtt bízz meg (trust) a plugin-hookokban. A Codex Desktop viselkedése a becsomagolt runtime-jától függ; ellenőrizd a `/hooks`-ot, és erősíts meg egy rögzített eseményt, mielőtt engedélyeznél egy megoldást.
Ha a hosztod globális hookokat igényel, tükrözd a parancsokat a `~/.codex/hooks.json`-ba. Amikor az MCP már bekötve van, a jelenlegi connector `--force`-ot igényel a hook-telepítés eléréséhez:
```bash
agentmemory connect codex --with-hooks --force
```
Ez beolvasztja a globális hookokat, és felülírja az agentmemory MCP-bejegyzést, megtartva a nem kapcsolódó bejegyzéseket. A `--force` használata előtt nézd át az agentmemory egyedi endpoint-beállításait. Frissítés után futtasd újra, hogy felfrissítsd a szkriptek elérési útjait. Engedélyezd vagy a natív plugin-hookokat, vagy a globális másolatokat, hogy elkerüld a duplikált rögzítést.
### GitHub Copilot CLI
VS Code agent módhoz használd a [Copilot MCP és automatikus rögzítés útmutatót](../docs/plugins/copilot.md#vs-code-copilot-local-agent-sessions). A CLI connector nem konfigurálja a VS Code-ot.
```bash
# MCP-only wiring
agentmemory connect copilot-cli
# Alternatively, full hooks/skills plugin from the GitHub subdir
copilot plugin install rohitg00/agentmemory:plugin
```
Az `agentmemory connect copilot-cli` beolvasztja a `mcpServers.agentmemory`-t a `~/.copilot/mcp-config.json`-ba (vagy a `$COPILOT_HOME/mcp-config.json`-ba, ha a `COPILOT_HOME` be van állítva), és megtartja a meglévő szervereket. Natív Windowson ez az egyetlen automatizált `connect` adapter; minden más natív Windows-ágenst manuálisan kell konfigurálni. A WSL `connect` csak akkor támogatott, ha a célágens ugyanabban a WSL-környezetben van telepítve. A Copilot a következő indításkor vagy a `/mcp` után veszi fel az MCP szervert. Telepítsd a plugint is, ha a teljes hook/skill élményt szeretnéd.
### Cursor
```bash
agentmemory connect cursor
```
Ezután a **Settings → Plugins → Add marketplace** menüben válaszd ki a `.cursor-plugin/plugin.json` fájlt tartalmazó agentmemory könyvtárat, engedélyezd az **agentmemory** plugint és töltsd újra az ablakot. A plugin életciklus-rögzítést, munkaterület-alapú projektazonosítást, skilleket és MCP-t ad. A plugin hookjait vagy a `~/.cursor/hooks.json` kézi hookjait használd, hogy elkerüld a dupla rögzítést.
[Cursor](../integrations/cursor/)
### Pi, Oh My Pi, DeepSeek Harness
```bash
agentmemory connect pi --with-mcp
agentmemory connect omp --with-mcp
agentmemory connect dsh --with-hooks
```
Válaszd ki a használt kliens parancsát. A Pi és az OMP natív visszakeresést, rögzítést, offline újraküldést és skilleket telepít; a `--with-mcp` hozzáadja a teljes eszközkészletet. Pi alatt futtasd a `/reload` parancsot, az OMP-t indítsd újra, majd ellenőrizd az `/agentmemory-status` eredményét. A DSH MCP-t és a mellékelt rögzítőplugint telepíti; csatlakoztatás után indítsd újra a DSH-t.
A Pi a telepíthető `@agentmemory/pi` csomagot is támogatja. A helyi telepítést és az npm-elérhetőséget a [Pi útmutató](../integrations/pi/) írja le. Kliensenként egy telepítési módot használj.
[Pi](../integrations/pi/) · [Oh My Pi](../integrations/omp/) · [DSH](../docs/dsh.md)
OpenClaw (illeszd be ezt a promptot)
```text
Install agentmemory for OpenClaw. Run `npx -y @agentmemory/agentmemory@latest` in a separate terminal to start the memory server on localhost:3111. Then add this to my OpenClaw MCP config so agentmemory is available with all 54 memory tools:
{
"mcpServers": {
"agentmemory": {
"command": "npx",
"args": ["-y", "@agentmemory/mcp"],
"env": {
"AGENTMEMORY_URL": "http://localhost:3111"
}
}
}
}
Restart OpenClaw. Verify with `curl http://localhost:3111/agentmemory/health`. Open http://localhost:3113 for the real-time viewer. For deeper memory-slot integration, copy `integrations/openclaw` to `~/.openclaw/extensions/agentmemory` and enable `plugins.slots.memory = "agentmemory"` in `~/.openclaw/openclaw.json`.
```
Teljes útmutató: [`integrations/openclaw/`](../integrations/openclaw/)
Hermes Agent (illeszd be ezt a promptot)
```text
Install agentmemory for Hermes. Run `npx -y @agentmemory/agentmemory@latest` in a separate terminal to start the memory server on localhost:3111. Then add this to ~/.hermes/config.yaml so Hermes can use agentmemory as an MCP server with all 54 memory tools:
mcp_servers:
agentmemory:
command: npx
args: ["-y", "@agentmemory/mcp"]
memory:
provider: agentmemory
Verify with `curl http://localhost:3111/agentmemory/health`. Open http://localhost:3113 for the real-time viewer. For deeper 6-hook memory provider integration (pre-LLM context injection, turn capture, MEMORY.md mirroring, system prompt block), copy integrations/hermes from https://github.com/rohitg00/agentmemory to ~/.hermes/plugins/agentmemory.
```
Teljes útmutató: [`integrations/hermes/`](../integrations/hermes/)
### Egyéb ágensek
Indítsd el a memóriaszervert: `npx -y @agentmemory/agentmemory@latest`
#### Natív skillek az `npx skills add` révén
Az agentmemory 17 skillt szállít a Claude-Code-stílusú `/SKILL.md` formátumban: 9 meghívható akció-skill (`remember`, `recall`, `recap`, `handoff`, `forget`, `lesson`, `commit-context`, `commit-history`, `session-history`) és 8 referencia-skill, amelyeket az ágens igény szerint tölt be (`memory-discipline`, `agentmemory-mcp-tools`, `agentmemory-rest-api`, `agentmemory-config`, `agentmemory-agents`, `agentmemory-hooks`, `agentmemory-architecture`, `write-agentmemory-skill`). A referencia-skillek forrásból generált adattáblákat hordoznak, így soha nem térnek el. A [`skills`](https://npmjs.com/package/skills) CLI, a vercel-labs eszköze, automatikusan telepíti ezeket a hívó ágens natív skill-mappájába, 50+ ágens között (Claude Code, Cursor, Cline, Continue, Droid, Warp, Codex, Antigravity, Kiro, OpenCode, Goose, Roo, Trae, Windsurf, és még több):
```bash
npx skills add rohitg00/agentmemory -y # auto-detects the calling agent
npx skills add rohitg00/agentmemory -y -a warp # explicit agent
npx skills add rohitg00/agentmemory -y -a '*' # install to every installed agent
```
Ez **kiegészíti** az `agentmemory connect `-et:
- Az `agentmemory connect ` általában MCP-konfigurációt ír. A Hermes, OpenClaw, Pi és Oh My Pi alapból a natív integrációt és skilleket telepíti; az MCP a `--with-mcp` kapcsolóval kérhető.
- Az `npx skills add rohitg00/agentmemory` a mellékelt natív skillek nélküli ágenseknek telepít skilleket. Hermes, OpenClaw, Pi és Oh My Pi esetén ezt hagyd ki; a csatlakoztatójuk már telepíti a skilleket.
Azoknál a kevés ágensnél, amelyeket a skills CLI még nem fed le (Zed v1.3.x és régebbi), másold be saját kezűleg a 17 SKILL.md fájlt az ágens natív skill-mappájába; ugyanaz a formátum mindenhol működik.
#### Standard MCP blokk
Az agentmemory bejegyzés **ugyanaz az MCP szerver blokk** minden olyan hoszton, amely a `mcpServers` formátumot használja (Cursor, Claude Desktop, Cline, Roo Code, Gemini CLI, OpenClaw):
```json
"agentmemory": {
"command": "npx",
"args": ["-y", "@agentmemory/mcp"],
"env": {
"AGENTMEMORY_URL": "${AGENTMEMORY_URL}",
"AGENTMEMORY_SECRET": "${AGENTMEMORY_SECRET}"
}
}
```
**Olvasszd be ezt a bejegyzést a meglévő `mcpServers` objektumba** a hoszt konfigurációs fájljában; ne cseréld le a fájlt. Ha a fájlban már vannak más szerverek, add hozzá az `agentmemory`-t melléjük, egy újabb kulcsként a `mcpServers`-en belül. Ha a `mcpServers` teljesen hiányzik, illeszd be a blokkot a `{ "mcpServers": { ... } }` belsejébe. A `${VAR}` helyőrzők az `AGENTMEMORY_URL` / `AGENTMEMORY_SECRET` értékeket az MCP szerver indításakor a shellből öröklik; a be nem állított változók üres stringet adnak át, és a shim visszaesik a `http://localhost:3111`-re. Egy bekötött bejegyzés mind a lokális, mind a távoli (k8s / reverse-proxy mögötti) telepítéseket lefedi.
| Ágens | Konfigurációs fájl | Megjegyzések |
|---|---|---|
| **Cursor (csak MCP)** | `~/.cursor/mcp.json` | Olvasztd be a `mcpServers`-be, vagy `agentmemory connect cursor`. Egykattintásos deeplink is elérhető a weboldalon. |
| **Cursor (teljes plugin)** | `.cursor-plugin/` | A plugin életciklus-hookokat, munkaterület-felismerést, skilleket és MCP-t ad a Cursor IDE és a `cursor-agent` számára. Lásd a [Cursor beállítását](#cursor). |
| **Claude Desktop** | `claude_desktop_config.json` (Application Support) | Olvasszd be a `mcpServers`-be. Indítsd újra a Claude Desktopot a szerkesztés után. |
| **Cline / Roo Code / Kilo Code** | Cline MCP beállítások (Settings UI → MCP Servers → Edit) | Ugyanaz a `mcpServers` blokk. |
| **Devin CLI (MCP + hookok)** | `~/.config/devin/config.json` | Az `agentmemory connect devin` beolvasztja az MCP bejegyzést; a `--with-hooks` hozzáad hat natív automatikus rögzítő hookot (SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Stop, SessionEnd) a Devin kisbetűs tool-matchereivel. Ellenőrizd a `devin mcp list` és a `/hooks` paranccsal a devinen belül. |
| **Devin CLI (teljes plugin)** | `plugin/.devin-plugin/` | A `devin plugins install ./plugin` egy checkoutból regisztrálja mind a 17 skillt `/agentmemory:` slash parancsokként, plusz az MCP szervert. A Devin plugin-hookok nem tudják elsütni a `SessionStart`/`SessionEnd`-et, ezért párosítsd a `connect devin --with-hooks`-szal a teljes session-rögzítéshez. |
| **Devin (felhő)** | Settings → Connections → MCP servers | Adj hozzá egy egyéni MCP-t (STDIO): parancs `npx`, argumentumok `-y @agentmemory/mcp@latest`, env `AGENTMEMORY_URL`, amely egy hálózatilag elérhető agentmemory-telepítésre mutat, plusz `AGENTMEMORY_SECRET` (a felhős sessionök nem érik el a localhostot — lásd [`deploy/`](../deploy/)). Tárold a secretet a Devin Secretsben, majd a "Test listing tools" segítségével ellenőrizd, hogy mind az 54 eszköz megjelenik. |
| **Gemini CLI** | `~/.gemini/settings.json` | `gemini mcp add agentmemory npx -y @agentmemory/mcp --scope user` (automatikusan beolvaszt). |
| **GitHub Copilot CLI (csak MCP)** | `~/.copilot/mcp-config.json` | Az `agentmemory connect copilot-cli` beolvasztja a `mcpServers.agentmemory`-t; a Copilot a következő indításkor vagy a `/mcp`-vel veszi fel. |
| **GitHub Copilot CLI (teljes plugin)** | Copilot plugin telepítés | `copilot plugin install rohitg00/agentmemory:plugin` a GitHub-aldirektóriumban lévő pluginhoz. |
| **OpenClaw** | OpenClaw MCP konfiguráció | Ugyanaz a `mcpServers` blokk. Mélyebben: az `openclaw plugins install ./integrations/openclaw` igényt tart az OpenClaw memória-slotjára (automatikusan átvált a `memory-core`-ról); állítsd be a `plugins.entries.agentmemory.hooks.allowConversationAccess=true`-t, különben a rögzítés némán blokkolva lesz. Lásd [`integrations/openclaw`](../integrations/openclaw/). |
| **Codex CLI (csak MCP)** | `.codex/config.toml` | TOML formátum: `codex mcp add agentmemory -- npx -y @agentmemory/mcp`, vagy add hozzá manuálisan a `[mcp_servers.agentmemory]`-t. |
| **Codex CLI (teljes plugin)** | Codex plugin marketplace | `codex plugin marketplace add rohitg00/agentmemory`, majd `codex plugin add agentmemory@agentmemory`. Regisztrálja az MCP-t + 6 életciklus-hookot + 17 skillt. Bízz meg a hookokban, és ellenőrizd a rögzítést a hosztodon; lásd a [Codex beállítása és ellenőrzése](../docs/plugins/codex-local.md) útmutatót. |
| **OpenCode (csak MCP)** | `opencode.json` | Más formátum: felső szintű `mcp` kulcs, a parancs tömbként: `{"mcp": {"agentmemory": {"type": "local", "command": ["npx", "-y", "@agentmemory/mcp"], "enabled": true}}}`. |
| **OpenCode (teljes plugin)** | `plugin/opencode/` | 22 automatikus rögzítő hook, amely lefedi a session-életciklust, az üzeneteket, a toolokat és a hibákat. A projekt-attribúció sessiononkénti, így egyetlen, több repón átnyúló OpenCode-folyamat minden sessiont a saját projektje alá fájloz. Két slash parancs (`/recall`, `/remember`). Másold a `plugin/opencode/`-ot az OpenCode workspace-edbe, és add hozzá a plugin-bejegyzést az `opencode.json`-hoz. Lásd a [`plugin/opencode/README.md`](../plugin/opencode/README.md) fájlt a teljes hook-táblázatért + hiányanalízisért. |
| **pi** | `~/.pi/agent/extensions/agentmemory` | `agentmemory connect pi --with-mcp`. natív visszakeresés + rögzítés + skillek. `/reload`, `/agentmemory-status`. [Pi](../integrations/pi/). |
| **Oh My Pi** | `~/.omp/agent` | `agentmemory connect omp --with-mcp`. natív visszakeresés + rögzítés + skillek. [Oh My Pi](../integrations/omp/). |
| **Hermes Agent** | `~/.hermes/config.yaml` | A `cp -r integrations/hermes ~/.hermes/plugins/agentmemory` + `memory.provider: agentmemory` adja a 6-hookos memóriaszolgáltatót (prefetch, kör-rögzítés, session-vég, pre-compress, MEMORY.md-tükrözés, system prompt blokk). Validáld a `hermes plugins doctor` és a `hermes memory status` paranccsal. Lásd [`integrations/hermes`](../integrations/hermes/). |
| **Qwen Code** | `~/.qwen/settings.json` | Az `agentmemory connect qwen` beírja a standard `mcpServers` blokkot. A hook-payload mezőkompatibilis a Claude Code-dal, így a meglévő 12-hookos szkriptek módosítás nélkül működnek; kösd be őket a `hooks` szekcióban, ugyanabban a `settings.json`-ban. |
| **Antigravity IDE / 2.0** | `~/.gemini/config/mcp_config.json` | Az `agentmemory connect antigravity --with-hooks` telepíti az MCP-t és a rögzítő hookokat a megosztott testreszabási mappába. Lásd az [Antigravity beállítása és korlátai](../docs/plugins/antigravity.md) útmutatót. |
| **Antigravity CLI** (`agy`) | `~/.gemini/config/mcp_config.json` | Az `agentmemory connect antigravity-cli --with-hooks` ugyanazt az MCP- és hook-konfigurációt használja, mint a jelenlegi IDE-verziók. A meglévő telepítéseknek frissülniük kell a `--force`-szal; lásd a [frissítési megjegyzéseket](../docs/plugins/antigravity.md). |
| **Kiro** | `~/.kiro/settings/mcp.json` | Az `agentmemory connect kiro` beírja a felhasználói szintű konfigurációt. A workspace-szintű felülírások a `.kiro/settings/mcp.json`-ba kerülnek, a kódod mellé. |
| **Warp** | `~/.warp/.mcp.json` | Az `agentmemory connect warp` beírja a standard `mcpServers` blokkot. A Warp a skilleket is automatikusan felismeri a `.claude/skills/`-ből; a Claude Code plugin telepítése után a 9 agentmemory skill (`remember`, `recall`, `recap`, `handoff`, `forget`, `lesson`, `commit-context`, `commit-history`, `session-history`) natívan megjelenik a Warp slash-parancs palettáján. |
| **Cline (CLI)** | `~/.cline/data/settings/cline_mcp_settings.json` | Az `agentmemory connect cline` beírja a standard `mcpServers` blokkot. VS Code extension felhasználóknak: illeszd be ugyanazt a blokkot a Cline Settings → MCP Servers → Edit JSON útján. |
| **Continue.dev** | `~/.continue/config.yaml` (előnyben részesített) vagy `config.json` (örökölt) | Az `agentmemory connect continue` létrehozza a hiányzó `config.yaml` fájlt, vagy módosítja a meglévő `config.json` fájlt. Meglévő YAML esetén kiírja az `mcpServers:` alá illeszthető blokkot, megőrizve a megjegyzéseket és horgonyokat. A Continue tömböt használ, nem objektumot. |
| **Zed** | `~/.config/zed/settings.json` | Az `agentmemory connect zed` a `context_servers` alá ír (a Zed saját kulcsa, NEM a `mcpServers`). A távoli MCP szerverek egy `{"url": "..."}`-vel is bekötődhetnek. |
| **Droid (Factory.ai)** | `~/.factory/mcp.json` | Az `agentmemory connect droid` beírja a standard `mcpServers` blokkot. A projekt-szintű felülírások a `/.factory/mcp.json`-ba kerülnek. Add meg a `--with-hooks`-ot a natív automatikus rögzítéshez. |
| **DeepSeek Harness** | `$DSH_HOME/cordis.patch.yml` | Az `agentmemory connect dsh` bekapcsolja az MCP-eszközöket. A `--with-hooks` betölti az AgentMemoryhoz mellékelt natív rögzítőbővítményt. Külön bővítménycsomag nem szükséges. [DSH](../docs/dsh.md). |
| **Goose** | Goose MCP beállítások felhasználói felülete | Ugyanaz a `mcpServers` blokk; használd a `goose configure` → Add Extension → MCP menüt. A közvetlen YAML-szerkesztés a `~/.config/goose/config.yaml`-ban is támogatott, de a séma `extensions:` + `cmd`-t használ (nem `mcpServers:` + `command`-ot). |
| **Aider** | n/a | Szkriptekből a [hitelesített REST-példákkal](#validate-a-fresh-install-and-restart-persistence) tárolhatsz és kereshetsz. |
| **Támogatott ágensek** | Csak skillek | `npx skills add rohitg00/agentmemory`; válassza ki a telepítendő skilleket és a célágenseket. |
**Sandboxolt MCP kliensek** (Flatpak / Snap / korlátozó konténerek), amelyek nem érik el a hoszt `localhost`-ját: állítsd be a `"AGENTMEMORY_FORCE_PROXY": "1"`-et is az `env` blokkban, és az `AGENTMEMORY_URL`-t irányítsd egy olyan útvonalra, amit a sandbox valóban elér (pl. a LAN-IP-d).
### Programozott hozzáférés (Python / Rust / Node)
Bármely nyelvből használhatod a [REST API-t](#api), ágensből pedig az [MCP-eszközöket](#mcp-server). A REST JSON-t és bearer-hitelesítést használ; lásd a [tárolási és keresési példát](#validate-a-fresh-install-and-restart-persistence). A közvetlen környezetintegrációhoz lásd a [Python-példákat](../examples/python/).
### Forrásból
```bash
git clone https://github.com/rohitg00/agentmemory.git && cd agentmemory
npm install && npm run build && npm start
```
Az `npm start` ugyanazt a helyi szervert indítja, mint a telepített CLI. A követelmények a [telepítésnél](#install) szerepelnek; az API és a nézőfelület a `127.0.0.1` címen figyel.
### Windows
Az agentmemory Windows 10/11 rendszeren fut. A WSL2 a Linux útvonalat követi, és automatikusan telepítheti a rögzített motort. Natív Windowson kézzel telepítse a rögzített iii-engine v0.25.1 binárist: töltse le a megfelelő archívumot az [iii v0.25.1 kiadási oldaláról](https://github.com/iii-hq/iii/releases/tag/iii%2Fv0.25.1), ellenőrizze az ellenőrzőösszeget, majd helyezze az `iii.exe` fájlt a `PATH`-ra (például `%USERPROFILE%\.local\bin\iii.exe`). A CLI nem bontja ki automatikusan a Windows ZIP-et.
A natív Windows automatizált MCP-kapcsolat csak az `agentmemory connect copilot-cli` parancsot támogatja. Más natív Windows-ügynökökhöz használja az [Egyéb ügynökök](#other-agents) kézi MCP-blokkját. A `connect` parancsot csak akkor futtassa WSL-ben, ha a célügynök is ugyanabban a WSL-környezetben van telepítve.
**Csak önálló MCP (motor nélkül).** Ha csak MCP-eszközökre van szüksége, REST API, megjelenítő vagy runtime-szolgáltatások nélkül:
```powershell
npx -y @agentmemory/agentmemory@latest mcp
# or
npx -y @agentmemory/mcp
```
Futtasd az `agentmemory doctor` parancsot, vagy indíts újra `--verbose` kapcsolóval. Foglalt portoknál használj `--port ` vagy `--instance ` beállítást. A kompatibilitás és helyreállítás a [frissítési útmutatóban](../docs/upgrades/iii-0.25.md) szerepel.
---
Telepítés (Deploy)
Önálló üzemeltetéshez Docker Compose-t vagy az alábbi sablonokat használd. A memória és a hitelesítő adatok a `/data` köteten vannak; frissítéskor mentsd és használd újra. A hitelesítést, hálózatot, mentést és költöztetést a [telepítési útmutató](../deploy/README.md) ismerteti.
A Render egykattintásos telepítés gombja a repó gyökerében lévő `render.yaml`-t igényli, amit szándékosan tisztán tartunk. Használd a [`deploy/render/`](.././deploy/render/README.md)-ben dokumentált Render Blueprint folyamatot, hogy manuálisan a repón belüli blueprintre mutass.
A teljes beállítási részletek (HMAC-rögzítés, megjelenítő SSH-tunnel, forgatás, mentés,
költségküszöbök) a [`deploy/`](.././deploy/README.md)-ben élnek:
- [`deploy/fly`](.././deploy/fly/README.md): egyetlen gép,
`auto_stop_machines = "stop"`-pal; a legolcsóbb üresjárat.
- [`deploy/railway`](.././deploy/railway/README.md): Hobby-csomag, fix díj,
volume a dashboardon.
- [`deploy/render`](.././deploy/render/README.md): Blueprint-folyamat,
automatikus diszk-pillanatképek a fizetős csomagokon.
- [`deploy/coolify`](.././deploy/coolify/README.md): önálló üzemeltetés a saját
VPS-eden, a [Coolify](https://coolify.io/self-hosted) révén; ugyanaz a Docker
Compose stack, te birtoklod a hosztot és az adatot.
A REST portja `3111`, a nézőfelületé `3113`. Tartsd őket privát hálózaton, vagy védd hitelesítéssel és TLS-sel. A platformbeállítások és a [régi Docker költöztetése](../deploy/README.md#migrating-from-the-legacy-cli-docker-mode) a telepítési útmutatóban szerepelnek.
---
A projektismeretek beszélgetések és instrukciófájlok között szóródnak szét. Az AgentMemory kereshetővé teszi a korábbi döntéseket, javításokat és tanulságokat az éppen használt ágensből.
### A beépített ágensmemóriával szemben
Minden AI kódolóágens beépített memóriával érkezik: a Claude Code-nak `MEMORY.md`-je van, a Cursornak notepadjei, a Cline-nak memory bankja. Ezek úgy működnek, mint a ragasztós jegyzetek. Az agentmemory a kereshető adatbázis a ragasztós jegyzetek mögött.
| | Beépített (CLAUDE.md) | agentmemory |
|---|---|---|
| Karbantartás | Kézzel gondozott instrukciók | Indexelt munkamenet-előzmények és emlékek |
| Keresés | Mindent betölt a kontextusba | BM25 + vektor + gráf (csak top-K) |
| Ágensek közötti | Ágensenkénti fájlok | MCP + REST (bármely ágens) |
| Koordináció | Nincs | Lease-ek, szignálok, akciók, rutinok |
| Megfigyelhetőség | Fájlok manuális olvasása | Valós idejű megjelenítő a :3113-on |
---
### Memória-pipeline
```text
PostToolUse hook fires
-> Stable event ID / durable capture inbox / offline spool
-> Privacy filter (strip secrets, API keys)
-> Store raw observation
-> Synthetic compression by default
(LLM-written compression only with a provider + AGENTMEMORY_AUTO_COMPRESS=true)
-> Vector embedding when an embedding provider is active
-> Index in BM25, plus vectors when enabled
Stop / SessionEnd hook fires
-> Summarize session
-> Knowledge graph extraction (if GRAPH_EXTRACTION_ENABLED=true)
-> Slot reflection (if AGENTMEMORY_SLOTS=true and AGENTMEMORY_REFLECT=true)
SessionStart hook fires
-> Load project profile (top concepts, files, patterns)
-> Hybrid search (BM25 + vector + graph)
-> Token budget (default: 2000 tokens)
-> Inject context when enabled by the integration
```
### 4 szintű memória-konszolidáció
Az emberi agy memóriafeldolgozásának a mintájára épül, beleértve az alvás alatti konszolidációt is.
| Szint | Mi | Analógia |
|------|------|---------|
| **Working (munka-)** | Nyers megfigyelések a toolhasználatból | Rövidtávú memória |
| **Episodic (episodikus)** | Tömörített session-összefoglalók | "Mi történt" |
| **Semantic (szemantikus)** | Kinyert tények és minták | "Mit tudok" |
| **Procedural (procedurális)** | Munkafolyamatok és döntési minták | "Hogyan kell csinálni" |
A memóriák idővel lecsengenek (Ebbinghaus-görbe). A gyakran elért memóriák megerősödnek. Az elavult memóriák automatikusan kiürülnek. Az ellentmondásokat a rendszer felismeri és feloldja.
### Mi kerül rögzítésre
A táblázat a Claude Code hookjait írja le. Más integrációk a kliens által biztosított eseményeket rögzítik. A közös hookok automatikus kontextusbeillesztése külön engedélyezhető: `AGENTMEMORY_INJECT_CONTEXT=true`.
| Hook | Rögzíti |
|------|----------|
| `SessionStart` | Projekt-útvonal, session-ID |
| `UserPromptSubmit` | Felhasználói promptok (privacy-szűrve) |
| `PreToolUse` | Fájlhozzáférési minták + bővített kontextus |
| `PostToolUse` | Tool neve, bemenet, kimenet |
| `PostToolUseFailure` | Hibakontextus |
| `PreCompact` | Visszainjektálja a memóriát a compaction előtt |
| `SubagentStart/Stop` | Sub-agent életciklus |
| `Stop` | Session-vég összefoglaló |
| `SessionEnd` | Session-lezárási jelző |
### Kulcsképességek
| Képesség | Leírás |
|---|---|
| **Automatikus rögzítés** | A natív integrációk által rögzített támogatott munkamenet- és eszközesemények |
| **Szemantikus keresés** | BM25 + vektor + tudásgráf RRF-fúzióval |
| **Memória-evolúció** | Verziózás, felülírás, kapcsolati gráfok |
| **Felidézési higiénia** | A felülírt memória-verziók elhagyják a keresési indexeket; a KV-ben lévő verziólánc megtartja a teljes előzményt |
| **Közel-duplikátum jelzések** | A mentések egy tájékoztató `similarTo` egyezést adnak vissza, ha az új tartalom erősen hasonlít egy meglévő memóriára |
| **Ágensenkénti hatókör** | Az `agentId` végigfut a mentésen és a felidézésen a REST, az MCP és a keresési index között, megosztott vagy izolált módban |
| **Írási időbeli eredet** | Minden megfigyelés és memória egy megváltoztathatatlan eredetcsatornát hordoz (user, agent, tool, import, vagy shared), amely a rögzítéskor, mentéskor és importáláskor kerül rá |
| **Automatikus elfelejtés** | TTL-lejárat, ellentmondás-felismerés, fontosság alapú kiürítés |
| **Elsőbbséget kap az adatvédelem** | API-kulcsok, secretek, `` tagek eltávolítva a tárolás előtt |
| **Önjavítás** | Circuit breaker, szolgáltató-fallback lánc, egészségfigyelés |
| **Claude híd** | Kétirányú szinkron a MEMORY.md-vel |
| **Tudásgráf** | Entitáskinyerés + BFS-bejárás |
| **Csapatmemória** | Névtér szerint megosztott + privát a csapattagok között |
| **Hivatkozási eredet** | Bármely memória visszakövethető a forrás-megfigyelésekhez |
| **Git-pillanatképek** | A memóriaállapot verziózása, visszaállítása és diff-elése |
---
Hármas folyam-visszakeresés, amely három szignált kombinál:
| Folyam | Mit csinál | Mikor |
|---|---|---|
| **BM25** | Tő szerinti kulcsszó-egyezés szinonima-bővítéssel | Mindig aktív |
| **Vektor** | Koszinusz-hasonlóság sűrű embeddingek felett | Ha van beállítva embedding-szolgáltató |
| **Gráf** | Tudásgráf-bejárás entitásegyezés révén | Ha a lekérdezésben entitásokat észlel |
Reciprocal Rank Fusionnal (RRF, k=60) fuzionálva, és sessionönkénti diverzifikálva (legfeljebb 3 eredmény sessiononként).
Ha egy vektorindex fel van töltve, a `mem::search` (a `memory_recall` mögött) a hibrid BM25 + vektor rangsorolót használja. Embeddingek nélkül BM25-öt használ. A `smart-search` emellett strukturális gráfegyezéseket is fuzionálhat, ha létezik gráfadat, kulcs nélküli módban is. A tanulság-felidézés egy dedikált, memóriában tartott BM25-indexen fut, nem a teljes korpusz lekérdezésenkénti átnézésével. A felülírt memória-verziók minden felidézési útvonalból ki vannak zárva; a verziólánc megtartja az előzményüket.
[0.9.31: `AGENTMEMORY_VECTOR_BACKFILL=all` / `AGENTMEMORY_VECTOR_BACKFILL_MAX`](../docs/reliability/source-and-vector-recovery.md).
A BM25 alapból tokenizálja a görögöt, a cirillt, a hébert, az arabot és az ékezetes latint. Kínai / japán / koreai memóriákhoz telepítsd az opcionális szegmentálókat (`npm install @node-rs/jieba tiny-segmenter`), hogy szóméretű tokenekre bontsa a CJK-futásokat; nélkülük az agentmemory finoman visszaesik a teljes futás tokenizálására, és egyszeri jelzést ír a stderr-re.
### Embedding-szolgáltatók
A kulcs nélküli telepítések letiltják a vektor-embeddingeket: a `mem::search` BM25-öt használ, míg a `smart-search` emellett a meglévő strukturális gráfadatot is használhatja. Ahhoz, hogy beállj az ingyenes, eszközön futó szemantikus embeddingekre, add hozzá ezt a `~/.agentmemory/.env`-hez, és indítsd újra az agentmemoryt:
```env
EMBEDDING_PROVIDER=local
```
A normál npm-telepítés tartalmazza az opcionális `@huggingface/transformers` futtatókörnyezetet. Az első embedding-kérés letölti a `Xenova/all-MiniLM-L6-v2`-t, így hálózati hozzáférésre van szükség, és tovább tarthat; az azt követő következtetés eszközön fut. A távoli szolgáltatókat a rendszer automatikusan felismeri a kulcsaikból, hacsak az `EMBEDDING_PROVIDER` nem írja felül őket.
| Szolgáltató | Modell | Költség | Megjegyzések |
|---|---|---|---|
| **Lokális (ajánlott opt-in)** | `all-MiniLM-L6-v2` | Ingyenes | [`EMBEDDING_PROVIDER=local`](../README.md#embedding-providers) |
| Gemini | `gemini-embedding-001` | Ingyenes szint | 100+ nyelv, 768/1536/3072 dimenzió (MRL), 2048 tokenes bemenet. Felváltja a `text-embedding-004`-et ([elavult, leállítva 2026. jan. 14-én](https://ai.google.dev/gemini-api/docs/deprecations)) |
| OpenAI | `text-embedding-3-small` | [OpenAI](https://openai.com/api/pricing/) | [text-embedding-3-small](https://platform.openai.com/docs/models/text-embedding-3-small) |
| Voyage AI | `voyage-code-3` | Fizetős | Kódra optimalizálva |
| Cohere | `embed-english-v3.0` | Ingyenes próba | Általános célú |
| OpenRouter | Bármely modell | Változó | Több modellt lefedő proxy |
---
54 eszköz, 6 resource, 3 prompt és 17 skill.
> **MCP shim a teljes szerverrel szemben:** a publikált `@agentmemory/mcp` csomag egy vékony shim. A teljes, 54 eszközből álló felületet **csak akkor** adja meg, **ha el tud érni egy futó agentmemory szervert** az `AGENTMEMORY_URL` révén (proxy mód). Ha nincs elérhető szerver, a shim visszaesik egy 7 eszközből álló lokális készletre (`memory_save`, `memory_recall`, `memory_smart_search`, `memory_sessions`, `memory_export`, `memory_audit`, `memory_governance_delete`). Az `AGENTMEMORY_TOOLS=core|all` env-változó egy *szerveroldali* kapcsoló; a shim `env` blokkjában beállítva nincs hatása. Ha csak 7 eszközt látsz a Cursorban / OpenCode-ban / Gemini CLI-ben, indítsd el az `npx -y @agentmemory/agentmemory@latest`-et (vagy a Docker-stacket), és állítsd be az `AGENTMEMORY_URL=http://localhost:3111`-et.
### 54 eszköz
Három eszközfelület, a legkisebbtől a legnagyobbig: az `AGENTMEMORY_TOOLS=core` 8 alapeszközre szűkíti a láthatóságot (`memory_save`, `memory_recall`, `memory_consolidate`, `memory_smart_search`, `memory_sessions`, `memory_diagnose`, `memory_lesson_save`, `memory_reflect`); az alábbi alapkészlet a regisztri 14 alapozó eszköze; az alapértelmezett (`AGENTMEMORY_TOOLS=all`) mind az 54-et megjeleníti.
Alapeszközök (14)
| Eszköz | Leírás |
|------|-------------|
| `memory_recall` | Keresés a korábbi megfigyelések között |
| `memory_compress_file` | Markdown fájlok tömörítése a struktúra megtartásával |
| `memory_save` | Egy belátás, döntés vagy minta mentése |
| `memory_file_history` | Korábbi megfigyelések adott fájlokról |
| `memory_patterns` | Visszatérő minták felismerése |
| `memory_sessions` | A legutóbbi sessionök listázása |
| `memory_smart_search` | Hibrid szemantikus + kulcsszavas keresés |
| `memory_vision_search` | Keresés kép-megfigyelések között |
| `memory_timeline` | Időrendi megfigyelések |
| `memory_profile` | Projektprofil (fogalmak, fájlok, minták) |
| `memory_export` | Az összes memóriaadat exportálása |
| `memory_relations` | Kapcsolati gráf lekérdezése |
| `memory_commit_lookup` | Egy git commit mögötti sessionök |
| `memory_commits` | Egy sessionhöz rögzített commitok |
Kiterjesztett eszközök (összesen 54, az alapértelmezett felület)
| Eszköz | Leírás |
|------|-------------|
| `memory_patterns` | Visszatérő minták felismerése |
| `memory_timeline` | Időrendi megfigyelések |
| `memory_relations` | Kapcsolati gráf lekérdezése |
| `memory_graph_query` | Tudásgráf-bejárás |
| `memory_consolidate` | 4 szintű konszolidáció futtatása |
| `memory_claude_bridge_sync` | Szinkron a MEMORY.md-vel |
| `memory_team_share` | Megosztás csapattagokkal |
| `memory_team_feed` | Legutóbbi megosztott elemek |
| `memory_audit` | A műveletek audit-nyomvonala |
| `memory_governance_delete` | Törlés audit-nyomvonallal |
| `memory_snapshot_create` | Git-verziózott pillanatkép |
| `memory_action_create` | Munkaelemek létrehozása függőségekkel |
| `memory_action_update` | Akció-állapot frissítése |
| `memory_frontier` | Blokkolatlan akciók, prioritás szerint rangsorolva |
| `memory_next` | A legfontosabb egyetlen következő akció |
| `memory_lease` | Exkluzív akció-lease-ek (több ágens) |
| `memory_routine_run` | Munkafolyamat-rutinok instanciálása |
| `memory_signal_send` | Ágensek közötti üzenetküldés |
| `memory_signal_read` | Üzenetek olvasása nyugtával |
| `memory_checkpoint` | Külső feltétel-kapuk |
| `memory_mesh_sync` | P2P szinkron az instance-ok között |
| `memory_sentinel_create` | Esemény-vezérelt megfigyelők |
| `memory_sentinel_trigger` | Sentinel-ek elsütése kívülről |
| `memory_sketch_create` | Múlékony akció-gráfok |
| `memory_sketch_promote` | Véglegesítés |
| `memory_crystallize` | Akcióláncok sűrítése |
| `memory_diagnose` | Egészségvizsgálatok |
| `memory_heal` | Elakadt állapot automatikus javítása |
| `memory_facet_tag` | Dimenzió:érték tagek |
| `memory_facet_query` | Lekérdezés facet-tagek szerint |
| `memory_verify` | Eredet visszakövetése |
### 6 Resource · 3 Prompt · 17 Skill
| Típus | Név | Leírás |
|------|------|-------------|
| Resource | `agentmemory://status` | Egészségi állapot, session-szám, memória-szám |
| Resource | `agentmemory://project/{name}/profile` | Projektenkénti intelligencia |
| Resource | `agentmemory://project/{name}/recent` | Egy projekt legutóbbi megfigyelései |
| Resource | `agentmemory://memories/latest` | A legutóbbi 10 aktív memória |
| Resource | `agentmemory://graph/stats` | Tudásgráf-statisztikák |
| Resource | `agentmemory://team/{id}/profile` | Megosztott csapatprofil |
| Prompt | `recall_context` | Keresés + kontextus-üzenetek visszaadása |
| Prompt | `session_handoff` | Átadási adat ágensek között |
| Prompt | `detect_patterns` | Visszatérő minták elemzése |
| Skill | `/recall` | Keresés a memóriában |
| Skill | `/remember` | Mentés a hosszútávú memóriába |
| Skill | `/session-history` | Legutóbbi session-összefoglalók |
| Skill | `/forget` | Megfigyelések/sessionök törlése |
A táblázat a négy alap-skillt mutatja. A teljes készlet 9 meghívható skillből és 8 referencia-skillből áll; lásd a Natív skillek részt fentebb.
### Önálló MCP
Futtasd a teljes szerver nélkül, bármely MCP klienshez. Mindkettő működik:
```bash
npx -y @agentmemory/agentmemory@latest mcp # canonical (always available)
npx -y @agentmemory/mcp # shim package alias
```
Vagy add hozzá az ágensed MCP konfigurációjához:
A legtöbb ágens esetén (Cursor, Claude Desktop, Cline, Roo Code, Gemini CLI):
```json
{
"mcpServers": {
"agentmemory": {
"command": "npx",
"args": ["-y", "@agentmemory/mcp"],
"env": {
"AGENTMEMORY_URL": "http://localhost:3111"
}
}
}
}
```
Olvasszd be az `agentmemory` bejegyzést a hoszt meglévő `mcpServers` objektumába, ne cseréld le a fájlt. Olyan sandboxolt klienseknél, amelyek nem érik el a hoszt `localhost`-ját, add hozzá a `"AGENTMEMORY_FORCE_PROXY": "1"`-et az env blokkhoz, és állítsd az `AGENTMEMORY_URL`-t egy olyan útvonalra, amit a sandbox el tud érni.
OpenCode (`opencode.json`):
```json
{
"mcp": {
"agentmemory": {
"type": "local",
"command": ["npx", "-y", "@agentmemory/mcp"],
"enabled": true
}
},
"plugin": ["./plugins/agentmemory-capture.ts"]
}
```
Másold be a plugin-fájlt a repóból:
```bash
mkdir -p ~/.config/opencode/plugins
cp plugin/opencode/agentmemory-capture.ts ~/.config/opencode/plugins/
cp plugin/opencode/commands/*.md ~/.config/opencode/commands/
```
---
A viewer automatikusan elindul a `3113` porton. Csatlakozáskor egy snapshotot tölt be (`GET /agentmemory/viewer/snapshot`), majd a REST worker `/agentmemory/viewer/events` útvonalán érkező SSE-vel alkalmazza az élő eseményeket: az új memóriák, leckék, megfigyelések, auditbejegyzések, gráfváltozások és health-frissítések lekérdezés és oldal-újratöltés nélkül jelennek meg.
- **12 fül, négy csoportban**, élő számlálókkal, deep linkekkel (`#memories/`, `#sessions/?obs=`, `#graph/`, `#health/consolidation`), billentyűparancsokkal és egy mobilmenüvel.
- **Memories:** szerveroldali keresés, szűrők projekt, ágens és típus szerint, egy részletpanel a verziólánccal és egy szó-szintű diff-fel, eredetre mutató linkek, másolás gombok az id-hez, az MCP-híváshoz és egy curl parancshoz, szerkesztés (új verzió), elfelejtés megerősítéssel, tömeges elfelejtés és JSON-export.
- **Sessions:** egy beágyazott megfigyelés-idővonal olvasható tool-bemenettel és -kimenettel, szűrőkkel és lapozással, valamint az adott session által létrehozott memóriák és tanulságok.
- **Graph:** keresés, csomópont-részletek kapcsolatokkal és forrásokkal, egy jelmagyarázat, amely nem csak színre támaszkodik, és nagyítási vezérlők.
- **Health:** a `GET /agentmemory/status` élő verziója. Minden probléma a megoldásával érkezik, plusz az állapot-backend, az index-mentési állapot, a gráf-eredet tömörítésének haladása és egy konszolidáció-magyarázó a valódi küszöbértékekkel.
- **Audit, Activity, Profile, Replay, Lessons, Actions és Crystals** oldalak, mindegyik egy üres állapottal, amely elmondja, mi az adott szekció, miért üres, és melyik parancs tölti fel, valamint egy `?` szójegyzék-tooltippel minden terminuson és számon.
```bash
open http://localhost:3113
```
A megjelenítő szervere alapértelmezetten a `127.0.0.1`-hez kötődik, és csatolja a szerver secretjét, amikor továbbküldi a kéréseket a REST API-nak, így nincs szükség beállításra. A REST-en kiszolgált `/agentmemory/viewer` végpont a normál bearer-token szabályokat követi, és a token nélküli böngészőket a megjelenítő portjára irányítja át. A CSP-fejlécek válaszonkénti script-nonce-t használnak, és letiltják az inline handler-attribútumokat (`script-src-attr 'none'`).
---
### LLM-szolgáltatók
Az agentmemory automatikusan felismeri a szolgáltatókat a környezetedből. Egy szolgáltató elérhetővé teszi az LLM-alapú műveleteket, de a szolgáltató-konfiguráció önmagában nem engedélyezi az LLM által írt megfigyelés-tömörítést. Ahhoz mindkettő szükséges: egy szolgáltató és az `AGENTMEMORY_AUTO_COMPRESS=true`.
| Szolgáltató | Konfiguráció | Megjegyzések |
|----------|--------|-------|
| **No-op (alapértelmezett)** | Nincs szükség konfigurációra | Az LLM-alapú tömörítés/összefoglalás letiltva. A szintetikus tömörítés és a BM25-felidézés továbbra is működik. Lásd az `AGENTMEMORY_ALLOW_AGENT_SDK`-t alább, ha korábban a Claude-előfizetéses fallbackre támaszkodtál. |
| Anthropic API | `ANTHROPIC_API_KEY` | Token-alapú díjszabás |
| MiniMax | `MINIMAX_API_KEY` | Anthropic-kompatibilis |
| Gemini | `GEMINI_API_KEY` | Az embeddingeket is engedélyezi |
| OpenRouter | `OPENROUTER_API_KEY` | Bármely modell |
| OpenAI API | `OPENAI_API_KEY` | Alapértelmezett `gpt-5.6-luna`, felülírható az `OPENAI_MODEL`-lel |
| **Lokális (Ollama / LM Studio / vLLM / llama.cpp)** | `OPENAI_API_KEY=local` + `OPENAI_BASE_URL=http://localhost:11434/v1` (Ollama) vagy `http://localhost:1234/v1` (LM Studio) + `OPENAI_MODEL=` | Bármi, ami OpenAI-API-kompatibilis. Nulla költség, a saját hardvereden fut. Lásd a [Lokális modellek](#local-models-ollama--lm-studio--vllm) részt alább. |
| Claude-előfizetéses fallback | `AGENTMEMORY_ALLOW_AGENT_SDK=true` | Csak opt-in. A `@anthropic-ai/claude-agent-sdk` sessionöket indít; korábban korlátlan Stop-hook-rekurziót okozott, így nem alapértelmezett többé. |
### Lokális modellek (Ollama / LM Studio / vLLM)
Az agentmemory bármely OpenAI-API-kompatibilis szerverrel beszél, így bármi, ami kiteszi a `/v1/chat/completions`-t, kódmódosítás nélkül működik. Nincs fizetős kulcs, nincs felhő, nincs rate limit; teljesen a saját hardveredben fut.
**Ollama** (alapértelmezett port `11434`):
```bash
ollama pull qwen3:8b # or qwen3:4b, gpt-oss:20b, qwen3-coder:30b, etc.
ollama serve
```
```env
# ~/.agentmemory/.env
OPENAI_API_KEY=ollama # any non-empty string; Ollama ignores it
OPENAI_BASE_URL=http://localhost:11434/v1
OPENAI_MODEL=qwen3:8b
```
**LM Studio** (alapértelmezett port `1234`):
Nyisd meg az LM Studio-t → Local Server fül → Start Server. Válassz bármilyen chat-modellt a választóból (Qwen 3, gpt-oss, DeepSeek R1, stb.).
```env
# ~/.agentmemory/.env
OPENAI_API_KEY=lmstudio # any non-empty string; LM Studio ignores it
OPENAI_BASE_URL=http://localhost:1234/v1
OPENAI_MODEL=qwen3-8b # match the model name from LM Studio
```
**vLLM / llama.cpp / Text Generation Inference**: ugyanaz a forma. Irányítsd az `OPENAI_BASE_URL`-t arra az URL-re, amit a szervered kitesz, és állítsd be az `OPENAI_MODEL`-t egy olyan névre, amit a szervered elfogad.
**Modellajánlások memóriamunkára**: a tömörítés és az összefoglalás rövid feladatok (<2K token be, <500 token ki), ahol egy 7B instruct-modell is bőven elég. Ajánlások:
| Modell | Méret | Miért |
|-------|------|-----|
| `qwen3:8b` | ~5.2 GB | Kiegyensúlyozott alapértelmezés egy 16 GB-os gépen; erős a kinyerésben és a tool-alakú szövegben |
| `qwen3:4b` | ~2.6 GB | A legkisebb épkézláb opció; megfelelő tömörítéshez, gyengébb gráfkinyeréshez |
| `qwen3-coder:30b` | ~19 GB | A legjobb lokális választás kód-alakú sessionökhöz (30B MoE, 3.3B aktív) 24-32 GB hardveren |
| `gpt-oss:20b` | ~14 GB | Erős általános modell, amely elfér 16 GB RAM-ban |
| `deepseek-r1:8b` | ~5.2 GB | Reasoning-disztill; lassabb, de tisztább kinyerések |
A Qwen 3 modellek alapértelmezetten gondolkodnak, és képesek az egész token-budgetet elégetni a reasoning-en, mielőtt bármi kimenet lenne. Állítsd be az `AGENTMEMORY_LLM_NOTHINK=1`-et, hogy `/no_think`-et fűzzön a gráfkinyerési promptokhoz, és emeld fel a `MAX_TOKENS`-t (16384 működik), ha a kinyerések üresen jönnek vissza.
A reasoning-osztályú modellek (`o1`-stílusú, `` blokkokkal) üres `content`-et adhatnak vissza egy `reasoning` mezővel, amit a lokális szervered esetleg nem tesz ki. Ha a kinyerések üresen jönnek vissza, váltsd előbb egy nem-reasoning modellre. Az `OPENAI_REASONING_EFFORT=none` env is kikapcsolhatja a gondolkodást az Ollama Cloud olyan thinking-modelljein, amelyek az OpenAI reasoning-sémáját tükrözik.
A lokális embeddingek opcionális függőségként érkeznek, de nem alapértelmezetten engedélyezettek. Állítsd be az `EMBEDDING_PROVIDER=local`-t, hogy beállj a `Xenova/all-MiniLM-L6-v2`-re (384 dimenzió). Az első embedding-kérés letölti a modellt; a következtetés azután eszközön fut. Ennek a beállításnak vagy egy távoli embedding-kulcsnak a híján a vektorok letiltva maradnak, a `mem::search` BM25-öt használ, és a `smart-search` még hozzáadhat meglévő gráf-egyezéseket.
### Költségtudatos modellválasztás
Kezdj kulcs nélkül a rögzítéshez és kulcsszavas kereséshez. Az `EMBEDDING_PROVIDER=local` a modell letöltése után helyi szemantikus keresést ad. Az LLM-tömörítéshez szolgáltató és `AGENTMEMORY_AUTO_COMPRESS=true` kell; minden megfigyelés kérést indíthat, ezért ellenőrizd az aktuális árakat. Az aktív szolgáltatókat a nézőfelület és az `agentmemory status` mutatja.
### Több ágenses memória (`AGENT_ID` + `AGENTMEMORY_AGENT_SCOPE`)
Több ágenses beállításokban, ahol több szerep osztja meg egy agentmemory szervert (architect / developer / reviewer / researcher / support-agent), az `AGENT_ID` minden írást megjelöl azzal a szereppel, amelyik végezte. Az `AGENTMEMORY_AGENT_SCOPE` szabályozza, hogy a felidézés szűr-e ez a tag szerint.
```env
TEAM_ID=company
USER_ID=engineering-team
AGENT_ID=architect
AGENTMEMORY_AGENT_SCOPE=isolated # optional; default "shared"
```
Két mód:
| Mód | Írások megjelölése | Felidézés szűrése | Mikor használd |
|------|------------|---------------|-------------|
| `shared` (alapértelmezett) | igen | nem | Ágensek közötti kontextus audit-nyomvonallal. Az architect láthatja, mit jegyzett fel a developer, de minden sor rögzíti, ki mondta. |
| `isolated` | igen | igen | Szigorú szétválasztás. Az architect soha nem látja a developer megfigyeléseit / memóriáit / sessionjeit. |
Mi kerül megjelölésre, ha az `AGENT_ID` beállított: `Session.agentId`, `RawObservation.agentId`, `CompressedObservation.agentId`, `Memory.agentId`. A szerep az `api::session::start` → `mem::observe` → `mem::compress` → KV útvonalon áramlik.
Mi kerül kiszűrésre isolated módban: `mem::smart-search`, `/agentmemory/memories`, `/agentmemory/observations`, `/agentmemory/sessions`. Minden végpont elfogadja a `?agentId=`-t kérésenkénti felülírásra, és a `?agentId=*`-ot, hogy teljesen kilépj az env-hatókörből. A `/memories` emellett elfogadja a `?includeOrphans=true`-t is, hogy felszínre hozza azokat az AGENT_ID előtti memóriákat, amelyeknek az `agentId`-ja nincs definiálva.
Hívásonkénti felülírás az SDK / REST rétegben: minden mutáló végpont (`/session/start`, `/remember`) elfogad egy `agentId` mezőt a kéréstörzsben, amely felülírja az env-et. Hasznos azoknál a futtatókörnyezeteknél, amelyek sok szerepet egyetlen szerverfolyamaton keresztül vezetnek. Az MCP `memory_save` eszköze ugyanazt az `agentId` mezőt teszi ki, az önálló stdio-szerver mind az `agentId`-t, mind a `project`-et továbbítja, és a mentett memóriák az `agentId`-t is bevezetik a keresési indexbe, így az ágens-hatókörű keresés a megfigyelések mellett a memóriákra is kiterjed.
Amikor az `AGENT_ID` nincs beállítva, a memória hatókör nélkül marad (örökölt viselkedés, nincs tag, nincs szűrés).
### Portok
| Port | Cél | Környezeti változó |
|---|---|---|
| `3111` | REST API, MCP HTTP és élő nézőfelület-események | `III_REST_PORT` |
| `3113` | Nézőfelület | `III_VIEWER_PORT` |
A `--port ` állítja a REST-portot, a nézőfelület alapértéke `N+2`. A `--instance N` külön környezetet hoz létre. A belső portok maradjanak privátak; távoli elérés előtt olvasd el a [telepítési útmutatót](../deploy/README.md).
### Tárolás: fájl vagy Redis
Az alapértelmezett fájltároló nem igényel külön adatbázist. A Redis opcionális az `AGENTMEMORY_STATE_BACKEND=redis` és `AGENTMEMORY_REDIS_URL` beállításokkal. A backendváltás nem másolja át a memóriát. A tartósság, a Redis korlátai és a hitelesített export/import a [tárolási útmutatóban](../docs/reliability/state-storage.md) szerepelnek.
### Konfigurációs fájl
Az agentmemory runtime-beállításait a `~/.agentmemory/.env` fájlba tegye ahelyett, hogy minden shellben változókat exportálna. Ha a viewer például `export ANTHROPIC_API_KEY=...` beállítási tippet mutat, másolja a fájlba az `export` előtag nélkül, majd indítsa újra az agentmemoryt. Másik env-fájlútvonalhoz állítsa be az `AGENTMEMORY_ENV_FILE` változót.
A folyamat környezeti változói megelőzik a fájl értékeit. Beállításmódosítás után indítsd újra a szervert.
Windowson ugyanez a fájl a `%USERPROFILE%\.agentmemory\.env`-ben él:
```powershell
New-Item -ItemType Directory -Force $HOME\.agentmemory
notepad $HOME\.agentmemory\.env
```
Ahhoz, hogy egy Claude Code Pro/Max előfizetéssel tesztelj API-kulcs helyett, iratkozz fel rá explicit módon:
```env
AGENTMEMORY_ALLOW_AGENT_SDK=true
AGENTMEMORY_AUTO_COMPRESS=true
```
Az LLM által írt megfigyelés-tömörítéshez mindkét sor szükséges: hozzáférés egy LLM-szolgáltatóhoz (ezt az explicit előfizetéses fallbacket is beleértve) és az `AGENTMEMORY_AUTO_COMPRESS=true`. Egy szolgáltató önmagában az alapértelmezett szintetikus tömörítési útvonalat hagyja érvényben.
A konszolidáció (gráf-csomópontok, tanulságok, kristályok) alapértelmezetten be van kapcsolva, amikor egy LLM-szolgáltató konfigurálva van. Explicit módon kapcsold ki a `CONSOLIDATION_ENABLED=false`-szal, ha LLM-mentes működést akarsz. A gráfkinyerés egy külön kapcsoló:
```env
GRAPH_EXTRACTION_ENABLED=true
# CONSOLIDATION_ENABLED=false # opt out of auto-consolidation
```
### Környezeti változók
Gyakori beállítások a `~/.agentmemory/.env` fájlban. A kontextusbeillesztés és tömörítés opcionális; a tömörítéshez szolgáltató is kell. A `core` mód szűkíti a látható MCP-eszközöket:
```env
EMBEDDING_PROVIDER=local
# AGENTMEMORY_INJECT_CONTEXT=true
# AGENTMEMORY_AUTO_COMPRESS=true
# AGENTMEMORY_TOOLS=core
# AUTO_FORGET_ENABLED=false
# LESSON_DECAY_ENABLED=false
# INSIGHT_DECAY_ENABLED=false
```
A teljes [`.env.example`](../.env.example) leírja a szolgáltatókat, rögzítési szűrőket, megőrzést, tárolást, csapatokat és opcionális funkciókat. Az `AGENTMEMORY_ENV_FILE` másik fájlt választ. Kitöltött `.env` fájlt vagy bearer-titkot soha ne commitolj.
---
147 endpoint a `3111`-es porton. A REST API alapértelmezetten a `127.0.0.1`-hez kötődik. A védett végpontok `Authorization: Bearer `-et igényelnek, és a mesh-sync végpontok mindkét oldalon explicit módon beállított `AGENTMEMORY_SECRET`-et igényelnek.
**A hitelesítés alapértelmezetten be van kapcsolva.** Ha az `AGENTMEMORY_SECRET` nincs beállítva, a CLI első indításkor véletlen titkot hoz létre a `~/.agentmemory/secret` fájlban `0600` jogosultsággal, és a kiválasztott adatkönyvtárba is átmásolja. Minden becsomagolt kliens onnan olvassa, amikor egy lokális szerverrel beszél: a CLI, a megjelenítő, a `plugin/scripts` alatti hookok, az MCP szerver és a `@agentmemory/mcp` shim, az `agentmemory connect` által írt konfigurációk, és a becsomagolt OpenCode, Pi, OpenClaw, Hermes és fájlrendszer-figyelő integrációk. A tárolt secret csak loopback URL-eknek kerül elküldésre (`localhost`, `127.0.0.0/8`, `::1`). Egy explicit `AGENTMEMORY_SECRET` mindig elsőbbséget kap, és a távoli klienseknek továbbra is be kell állítaniuk. A Docker és a `deploy/` entrypointok már generálnak és exportálnak egy saját secretet. Az API kézi hívásához:
```bash
curl -H "Authorization: Bearer $(cat ~/.agentmemory/secret)" http://localhost:3111/agentmemory/health
```
**Szabályok az írási kérésekhez.** A `POST`, `PUT`, `PATCH` és `DELETE` kéréseknek a REST API-hoz és a megjelenítőhöz `Content-Type: application/json`-t kell küldeniük (egy `charset` paraméter rendben van), amikor törzset hordoznak, és egy `Origin` fejlécnek, ha jelen van, egy loopback origin-nek kell lennie a konfigurált REST- vagy megjelenítő-porthoz, vagy felsorolva kell lennie a `VIEWER_ALLOWED_ORIGINS`-ban (vesszővel elválasztva, pl. `https://memory.example.com`). Azok a kliensek, amelyek nem küldenek `Origin` fejlécet (CLI, hookok, MCP, curl, szerver-szerver), nem érintettek. A megjelenítő a saját origin-ját is elfogadja.
**Fájlútvonalak.** Azok a végpontok, amelyek fájlokat olvasnak vagy írnak (`/compress-file`, `/replay/import-jsonl`, `/graph/import-graphify`), csak a `~/.agentmemory` alatti, az instance adatmappájában lévő, vagy az `AGENTMEMORY_IMPORT_ROOT`-ban felsorolt mappa alatti útvonalakat fogadják el (több mappát `:`-tal válassz el, Windowson `;`-vel). A `/replay/import-jsonl` elfogadja az alapértelmezett `~/.claude/projects`-et is. Az `/obsidian/export` az `AGENTMEMORY_EXPORT_ROOT`-on belül marad, a `/migrate` a `~/.agentmemory`-n belül. A symlinkek minden ellenőrzés előtt feloldásra kerülnek.
**Secret-tisztítás.** API-kulcsok, bearer-tokenek, PEM privát kulcs-blokkok és URL-ekbe ágyazott hitelesítő adatok (`scheme://user:password@host`) minden írási útvonalon elfedésre kerülnek, mielőtt a szöveg tárolásra kerülne: megfigyelések, remember, evolve, slotok, tanulságok, akciók, sketchek, szignálok, checkpointok, importok, jsonl-replay, mesh-sync, csapat-megosztások, tömörítési és összefoglaló kimenet, kristályok és gráf-csomópontok.
Kulcs végpontok
| Metódus | Útvonal | Leírás |
|--------|------|-------------|
| `GET` | `/agentmemory/health` | Egészségjelzés (mindig nyilvános) |
| `GET` | `/agentmemory/status` | Mi a hiba, és hogyan javítsd (HTML böngészőkhöz, egyébként JSON) |
| `GET` | `/agentmemory/viewer/snapshot` | Minden, amit a megjelenítő mutat, egyetlen válaszban |
| `POST` | `/agentmemory/session/start` | Session indítása + kontextus lekérése |
| `POST` | `/agentmemory/session/end` | Session lezárása |
| `POST` | `/agentmemory/observe` | Megfigyelés rögzítése (lásd a rögzítés-kiszolgálást alább) |
| `GET` | `/agentmemory/capture` | A rögzítési inbox, a dead letterek és az offline spool |
| `POST` | `/agentmemory/capture/retry` | Dead-letter rögzítések újrapróbálása |
| `POST` | `/agentmemory/capture/drain` | A lokális offline spool elküldése most |
| `POST` | `/agentmemory/smart-search` | Hibrid keresés |
| `POST` | `/agentmemory/context` | Kontextus generálása |
| `POST` | `/agentmemory/remember` | Mentés a hosszútávú memóriába |
| `POST` | `/agentmemory/forget` | Megfigyelések törlése |
| `POST` | `/agentmemory/enrich` | Fájlkontextus + memóriák + hibák |
| `GET` | `/agentmemory/profile` | Projektprofil |
| `GET` | `/agentmemory/export` | Minden adat exportálása |
| `POST` | `/agentmemory/import` | Import JSON-ból |
| `POST` | `/agentmemory/graph/query` | Tudásgráf-lekérdezés |
| `POST` | `/agentmemory/graph/compact` | Túlméretezett gráf-eredet ritkítása |
| `POST` | `/agentmemory/team/share` | Megosztás csapattal |
| `GET` | `/agentmemory/audit` | Audit-nyomvonal |
Teljes végpontlista: [Generált REST-referencia](../plugin/skills/agentmemory-rest-api/REFERENCE.md)
**Rögzítés-kiszolgálás.** A hookok minden megfigyelést egyszer küldenek el a `POST /agentmemory/observe`-nak, egy `eventId`-vel. Ez a hoszt saját id-je a híváshoz, ha a payloadnak van ilyene (például a Claude Code `tool_use_id`-je), egyébként a session, a hook-típus, a tool neve, a bemenet, a kimenet és a hoszt időbélyegének hash-e. A szerver beírja az eseményt egy rögzítési inboxba az állapottárban, elmenti a megfigyelést, majd eltávolítja az inbox-bejegyzést. A státuszkód megmondja, mi történt:
| Státusz | `status` mező | Jelentés |
|---|---|---|
| `201` | `accepted` | Elmentve. Az `observationId` az új megfigyelés. |
| `202` | `accepted` (`state: "retrying"`) | Elfogadva, de a mentés elbukott. A szerver újrapróbálja, akár egy újraindítás után is. |
| `200` | `duplicate` | Ezt az `eventId`-t már elfogadta a rendszer. Az `observationId` a meglévő megfigyelés; semmi új nem kerül tárolásra. |
| `400` / `422` | `rejected` | Érvénytelen payload, vagy a mentés véglegesen elbukott (az esemény dead letterként marad meg). |
| `503` | `rejected` (`retryable: true`) | Az inbox betelt (`AGENTMEMORY_CAPTURE_INBOX_MAX`). A hookok spoolozzák az eseményt, és később küldik el. |
Az elbukott eseményeket a rendszer minden `AGENTMEMORY_CAPTURE_RETRY_INTERVAL_MS`-ben (10 s) újrapróbálja, duplázódó backoff-fal, legfeljebb `AGENTMEMORY_CAPTURE_MAX_ATTEMPTS`-ig (5). Azok az események, amelyek továbbra sem sikerülnek, dead letterként maradnak az inboxban, felsorolva a `/agentmemory/status`-on és a megjelenítő Health oldalán, és újrapróbálhatók a `POST /agentmemory/capture/retry`-vel (`{"eventId": "..."}` vagy `{"all": true}`). Az elfogadott esemény-id-ket a rendszer `AGENTMEMORY_CAPTURE_DEDUP_HOURS`-ig (168 óra, legfeljebb `AGENTMEMORY_CAPTURE_EVENTS_MAX` id) megjegyzi, így egy, egy timeout vagy újraindítás után visszajátszott hookot egyszer tárol, míg két külön toolhívás a saját hoszt-id-jével kétszer kerül tárolásra, akkor is, ha a tartalmuk azonos. Amikor egy megfigyelés törlésre kerül (forget, session-törlés, kiürítés, automatikus elfelejtés, vagy egy import, amely lecseréli a tárat), az eseménye töröltként kerül megjelölésre, mielőtt a megfigyelés eltávolításra kerül, így az adott esemény egy ugyanazon ablakon belüli visszajátszása duplikátumként kerül megválaszolásra, és semmit nem tárol. Az állapottár 2 másodpercenként ír a diszkre, így egy megválaszolt esemény egy pillanatra még csak a memóriában lehet. Hogy ezt lefedje, minden `2xx` válasz hordozza a szerver `bootId`-ját is (minden indításnál új), az `acceptedAt`-ot és a `durableAfterMs`-t (a mentési intervallum plusz 1.5 s a fájl-tárnál, 1.5 s redisen, ahol a perzisztencia az üzemeltető beállítása). A hookok a helyi spoolban tartják az eseményt, amíg ez az ablak nem telik le, és egy későbbi híváskor törlik, egy újabb kérés nélkül. Ha a `bootId` addigra megváltozott, a szerver újraindult, így a hook ismét elküldi az eseményt ugyanazzal az `eventId`-vel; egy olyan esemény, amely valóban elérte a diszket, nem kerül kétszer tárolásra. A szerver maga is elküldi az ilyen eseményeket indításkor és minden újrapróbálkozási intervallumnál, így egy újraindítás sem veszít el semmit, akkor sem, ha utána nem fut hook. A régebbi hookok ignorálják az extra mezőket, és az új hookok egy régebbi szerver ellen ugyanúgy elvetik az eseményt `2xx`-nél, mint korábban.
Amikor a szerver nem fut, nem válaszol időben, vagy 5xx-et ad vissza, a hook hozzáfűzi a megfigyelést egy lokális spool-fájlhoz, `/capture-spool/-.jsonl` (a mappa felülírható az `AGENTMEMORY_CAPTURE_SPOOL_DIR`-ral). A fájl csak a saját felhasználód számára elérhető (mód 600), a secreteket a rendszer ugyanúgy elfedi, ahogy a szerver teszi, legfeljebb `AGENTMEMORY_CAPTURE_SPOOL_MAX_BYTES`-ot (5 MiB) tárol, és eldobja az `AGENTMEMORY_CAPTURE_SPOOL_MAX_AGE_HOURS`-nál (168) régebbi bejegyzéseket. Amikor betelik, az új bejegyzések elvetésre és megszámlálásra kerülnek, és a `/agentmemory/status` jelenti. A hook továbbra is 0-val lép ki az időkorlátján belül, és nem ad hozzá kérést, amikor a szerver egészséges. A spool a következő indításkor, és az első olyan hooknál kerül elküldésre, amely ismét eléri a szervert, egy háttérfolyamatban, hogy az ágens ne várjon. Az esemény-id-k ezt biztonságossá teszik: egy megfigyelés, amely már megérkezett egy timeout előtt, nem kerül kétszer tárolásra. Az `npx @agentmemory/agentmemory capture` megmutatja a spoolt és a szerver inboxát, a `--drain` elküldi a spoolt most, és a `GET /agentmemory/capture` ugyanezt adja vissza JSON-ként. Állítsd be az `AGENTMEMORY_CAPTURE_SPOOL=false`-t, hogy kikapcsold a spoolt.
**A gráf-eredet tömörítése.** A régi eredetadatok tömörítése induláskor elhalasztódik, mert teljes régi scope-okat olvas be. Az `/agentmemory/status` értéke `deferred`, vagy `off`, ha `AGENTMEMORY_GRAPH_COMPACT_ON_BOOT=false`. Az alábbi kézi tömörítést karbantartás közben futtasd. A keresési index migrációja külön művelet: használd az `agentmemory graph-index migrate --allow-legacy-scan` parancsot a [karbantartási útmutató](../docs/reliability/graph-index-migration.md) szerint.
Hogy kézzel futtasd, hívd meg a `POST /agentmemory/graph/compact`-ot. A név- és él-kulcs-indexeken sétál végig, nem listáz minden csomópontot és élt, és biztonságosan újrafuttatható. Amikor id-ket ritkít, egy `graph_compact` audit-bejegyzést ír.
```bash
curl -X POST http://localhost:3111/agentmemory/graph/compact -H "Authorization: Bearer " -H "Content-Type: application/json" -d '{}'
```
Egy nagy táron, vagy amikor a hívás 504-et ad vissza, futtasd szeletekben. Küldd el a `scope`-ot (`nodes`, `edges` vagy `history`), az `offset`-et és a `limit`-et, majd hívd újra a visszaadott `nextOffset`-tel, amíg az `null` nem lesz. Tedd ezt a `nodes`, az `edges` és a `history` esetén, és fejezd be egy `{"scope":"snapshot"}` hívással, mert egy szeletelt futás nem érinti a gyorsítótárazott pillanatképet.
```bash
curl -X POST http://localhost:3111/agentmemory/graph/compact -H "Authorization: Bearer " -H "Content-Type: application/json" -d '{"scope":"nodes","offset":0,"limit":200}'
curl -X POST http://localhost:3111/agentmemory/graph/compact -H "Authorization: Bearer " -H "Content-Type: application/json" -d '{"scope":"snapshot"}'
```
---
```bash
npm run dev # Hot reload
npm run build # Production build
npm test # 5,000+ tests
npm run test:integration # API tests (requires running services)
```
A követelmények a [telepítésnél](#install) szerepelnek. A hozzájárulási szabályok és kiadásellenőrzések a [CONTRIBUTING.md](../CONTRIBUTING.md) fájlban találhatók.