agentmemory: állandó memória AI kódolóágensek számára

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.

🇬🇧 English • 🇨🇳 简体中文 • 🇹🇼 繁體中文 • 🇯🇵 日本語 • 🇰🇷 한국어 • 🇵🇹 Português • 🇧🇷 Português (Brasil) • 🇪🇸 Español • 🇩🇪 Deutsch • 🇫🇷 Français • 🇮🇹 Italiano • 🇳🇱 Nederlands • 🇵🇱 Polski • 🇨🇿 Čeština • 🇷🇴 Română • 🇭🇺 Magyar • 🇬🇷 Ελληνικά • 🇸🇪 Svenska • 🇩🇰 Dansk • 🇳🇴 Norsk • 🇫🇮 Suomi • 🇷🇺 Русский • 🇺🇦 Українська • 🇹🇷 Türkçe • 🇮🇱 עברית • 🇸🇦 العربية • 🇮🇳 हिन्दी • 🇧🇩 বাংলা • 🇵🇰 اردو • 🇹🇭 ไทย • 🇻🇳 Tiếng Việt • 🇮🇩 Bahasa Indonesia • 🇵🇭 Tagalog

rohitg00/agentmemory | Trendshift

Dokumentum: 1.7k csillag / 240 fork a gist-en

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.

npm verzió CI Licenc Csillagok skills.sh installs

54 MCP eszköz 12 automatikus hook 0 külső adatbázis 5,000+ sikeres teszt

agentmemory demó

Telepítés • Gyors indítás • Benchmarkok • Versenytársakkal szemben • Ágensek • Hogyan működik • MCP • Megjelenítő • Konfiguráció • API

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

Működik minden ágenssel

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
Claude Code
natív plugin + 12 hook + MCP
Codex CLI
Codex CLI
natív plugin + 6 hook + MCP
GitHub Copilot CLI
GitHub Copilot CLI
MCP + plugin hookok/skillek
Cursor
Cursor
natív plugin + életciklus-hookok + MCP
OpenCode
OpenCode
rögzítő plugin + MCP
Devin
Devin
6 hook + skill + MCP
OpenClaw
OpenClaw
natív plugin + MCP
Hermes
Hermes
natív plugin + MCP
pi
pi
natív visszakeresés + rögzítés + skillek
OpenHuman
OpenHuman
natív Memory trait backend
Gemini CLI
Gemini CLI
MCP szerver
Antigravity
Antigravity
MCP + hook
Claude Desktop
Claude Desktop
MCP szerver
Warp
Warp
connect + MCP + skill
Zed
Zed
MCP szerver
Cline
Cline
MCP szerver
Continue
Continue
MCP szerver
Droid
Droid
MCP szerver
Kiro
Kiro
MCP szerver
Qwen Code
Qwen Code
MCP szerver
DeepSeek Harness
DeepSeek Harness
natív rögzítés + MCP
Roo Code
Roo Code
MCP szerver
Kilo Code
Kilo Code
MCP szerver
Goose
Goose
MCP szerver
Aider
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). ---

Benchmarkok

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

Versenytársakkal szemben

A termékek és telepítési lehetőségek frissített összehasonlítása, forrásokkal: [AgentMemory / Mem0 / Supermemory / Zep / Letta / Cognee / claude-mem](../benchmark/COMPARISON.md) · 2026-10-28. ---

Gyors indítás

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

Telepítés a fly.io-ra Telepítés a Railway-re

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

Miért agentmemory

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

Hogyan működik

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

MCP szerver

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/ ``` ---

Valós idejű megjelenítő

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'`). ---

Konfiguráció

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

API

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"}' ``` ---

Fejlesztés

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

Licenc

[Apache-2.0](../LICENSE)