Beständigt minne mellan kodningssessioner och agenter.
Beständigt minne för Claude Code, GitHub Copilot CLI, Cursor, Gemini CLI, Codex CLI, Hermes, OpenClaw, pi, Oh My Pi, DeepSeek Harness, OpenCode och alla MCP-klienter.
---
AgentMemory registrerar kodningssessioner och gör beslut, lösningar och lärdomar sökbara. Dela ett gemensamt lager mellan agenter, granska det sparade innehållet och välj hur mycket kontext modellen får.
## Installation
Krav:
- Node.js 20 eller nyare med npm och npx (`node -v`, `npm -v` och `npx -v`).
- På macOS/Linux kräver automatisk installation också `curl`, en POSIX-`sh` och `tar`.
- Använd WSL2 på Windows eller följ [installationen för native Windows](#windows).
Det kanoniska kommandot för en ny installation:
```bash
npx -y @agentmemory/agentmemory@latest
```
Välj agenter och en leverantör, eller använd läget utan nyckel. Installationen skriver konfigurationen, startar minnesservern och erbjuder en global installation av kommandot `agentmemory`. `-y` godkänner npm-frågan; `@latest` väljer aktuell version. LLM-komprimering är valfri och kräver en leverantör samt `AGENTMEMORY_AUTO_COMPRESS=true`.
Nyckelfritt läge inaktiverar vektor-embeddings. `memory_recall` (vägen `mem::search`) använder BM25, medan `memory_smart_search` också kan sammanfoga strukturella grafmatchningar när grafdata redan finns. För kostnadsfri semantisk återkallning på enheten, sätt `EMBEDDING_PROVIDER=local` i `~/.agentmemory/.env` och starta om. Den första embedding-förfrågan laddar ner `Xenova/all-MiniLM-L6-v2`; efter den initiala modellnedladdningen körs inferensen lokalt.
API:t finns på `http://localhost:3111` och viewern på `http://localhost:3113`. Båda lyssnar som standard på loopback. Konfigurationen finns i `~/.agentmemory/.env`; se [datalagring](#data-storage) för sökvägar och separata instanser.
Bevisa sedan att återkallning fungerar och ge din agent dess skills:
```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
```
Nyckelordssökningarna bör träffa i standardläget utan nyckel via BM25. Demots fråga `database performance optimization` är avsiktligt semantisk och kan ge noll resultat förrän en embedding-leverantör har konfigurerats.
Föredrar du att låta en kodningsagent sköta hela installationen? Ge den en enda instruktion:
> Retrieve and follow the instructions at: https://raw.githubusercontent.com/rohitg00/agentmemory/main/INSTALL_FOR_AGENTS.md
Anslut en annan agent med `agentmemory connect `. Se [integrationer](#works-with-every-agent) och [vardagskommandon](#everyday-commands).
Global installation / EACCES
```bash
npm install -g @agentmemory/agentmemory@latest
```
npx-kommandot ovan är fortfarande den kanoniska vägen för en ny installation och undviker behörighetsproblem med den globala prefix-katalogen.
npx levererar en gammal version
npx cachar per version. Tvinga fram den senaste med `npx -y @agentmemory/agentmemory@latest`, eller rensa cachen en gång med `rm -rf ~/.npm/_npx` (macOS/Linux; på Windows, radera `%LOCALAPPDATA%\npm-cache\_npx`).
---
agentmemory fungerar med alla agenter som stöder hooks, MCP eller REST API. Alla agenter delar samma minnesserver.
Claude Code inbyggd plugin + 12 hooks + MCP
Codex CLI inbyggd plugin + 6 hooks + MCP
GitHub Copilot CLI MCP + plugin-hooks/skills
Cursor inbyggt tillägg + livscykel-hooks + MCP
OpenCode insamlingsplugin + MCP
Devin 6 hooks + skills + MCP
OpenClaw inbyggd plugin + MCP
Hermes inbyggd plugin + MCP
pi inbyggd sökning + registrering + skills
OpenHuman inbyggd Memory-trait-backend
Gemini CLI MCP-server
Antigravity MCP + hooks
Claude Desktop MCP-server
Warp connect + MCP + skills
Zed MCP-server
Cline MCP-server
Continue MCP-server
Droid MCP-server
Kiro MCP-server
Qwen Code MCP-server
DeepSeek Harness inbyggd registrering + MCP
Roo Code MCP-server
Kilo Code MCP-server
Goose MCP-server
Aider REST API
Oh My Pi inbyggd sökning + registrering + skills + Valfri MCP
Fungerar med alla agenter som talar MCP eller HTTP. En server, minnen delade mellan dem alla.
---
### Datalagring
Minnen lagras som standard utanför ditt repo:
| Plattform | Datamapp |
|---|---|
| macOS | `~/Library/Application Support/agentmemory` |
| Linux | `$XDG_DATA_HOME/agentmemory` / `~/.local/share/agentmemory` |
| Windows | `%APPDATA%\agentmemory` |
Instans 0 återanvänder en befintlig `./data/state_store.db`. Välj en annan sökväg med `--data-dir ` eller `AGENTMEMORY_DATA_DIR` och behåll den vid omstarter och uppgraderingar. `--instance 1` använder undermappen `instance-1`, API-port `3211` och viewer-port `3213`. Se [lagring och säkerhetskopiering](../docs/reliability/state-storage.md) för Redis och migrering.
```bash
agentmemory --data-dir ~/.agentmemory-projects/main
agentmemory --instance 1
```
Senaste versionsanteckningarna: [CHANGELOG.md](../CHANGELOG.md).
---
Aktuella sökresultat, definitioner av mått och steg för reproduktion:
[0.9.31 · 2026-10-28 · strict recall-all@5](../docs/benchmarks/2026-10-28-retrieval-evaluation.md) · [eval/README.md](../eval/README.md).
---
Uppdaterad jämförelse av produkter och driftsalternativ med källor:
[AgentMemory / Mem0 / Supermemory / Zep / Letta / Cognee / claude-mem](../benchmark/COMPARISON.md) · 2026-10-28.
---
### Prova det på 30 sekunder
```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
```
`demo` sår 3 realistiska sessioner (JWT-autentisering, fix av N+1-fråga, rate limiting) och kör sökningar mot dem. Nyckelfria installationer inaktiverar vektorer, så nyckelordsfrågorna via `mem::search` bör träffa via BM25 medan `database performance optimization` kan ge noll resultat. `smart-search` kan dessutom returnera strukturella grafmatchningar när grafdata finns. För att få den semantiska frågan att hitta N+1-fixen via vektorer, sätt `EMBEDDING_PROVIDER=local`, starta om, och låt den första modellnedladdningen slutföras.
Öppna `http://localhost:3113` för att se minnet byggas upp i realtid.
### Validera en ny installation och omstarts-persistens
Kontrollera hälsa, viewer och status medan servern körs:
```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
```
`status` visar serverns tillstånd samt aktiva leverantörer och embeddings. Spara ett testminne och kontrollera sökningen:
```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}'
```
Kör sedan `npx -y @agentmemory/agentmemory@latest stop`, starta det kanoniska kommandot igen i Terminal 1, vänta på `/agentmemory/livez`, och upprepa sökningen. Testpunkten måste fortfarande returneras. Om du valde en anpassad `--data-dir`, ange samma katalog vid omstarten.
### Vardagskommandon
Installation och konfiguration finns under [Installation](#install) ovan (den första körningen guidar dig genom det). Till vardags:
```bash
agentmemory # start the server
agentmemory stop # stop it cleanly
agentmemory connect # wire another agent
agentmemory doctor # interactive diagnostics + fix prompts
agentmemory remove # uninstall everything we created
```
### Sessionsuppspelning
Varje session som agentmemory registrerar kan spelas upp igen. Öppna viewern, välj fliken **Replay**, och skrubba genom tidslinjen: prompter, verktygsanrop, verktygsresultat och svar renderas som diskreta händelser med play/pause, hastighetskontroll (0.5x till 4x) och kortkommandon (mellanslag för att växla, piltangenterna för att stega).
För att importera äldre Claude Code JSONL-transkript:
```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
```
Importerade sessioner dyker upp i Replay-väljaren tillsammans med de ursprungliga. Varje importerat transkript indexeras för sökning, märks med ursprungskanalen `import`, och analyseras för en sessionskristall och lärdomar.
> **Observera om du förlitar dig på `import-jsonl` som din primära infångningsväg:** Claude Codes `cleanupPeriodDays` (i `~/.claude/settings.json`, standard **30**) tar automatiskt bort JSONL-transkript äldre än det fönstret från `~/.claude/projects/`. Om du installerar agentmemory på en månader-gammal Claude Code-historik är allt äldre än 30 dagar redan borta innan den första importen. Antingen kör du `import-jsonl` på en cron, höjer `cleanupPeriodDays` till något högre, eller kopplar in auto-infångnings-hookarna (standardvägen vid plugin-installation) så att varje tur hamnar i agentmemory medan sessionen är live och JSONL-rensningen slutar spela någon roll.
### Uppgradering / underhåll
Använd underhållskommandot när du avsiktligt vill uppdatera din lokala körtid:
```bash
npx -y @agentmemory/agentmemory@latest upgrade
```
Kommandot uppdaterar den lokala körtiden och kan uppdatera JavaScript-beroenden i den aktuella arbetsytan. Säkerhetskopiera dina data och läs [uppgraderingsguiden](../docs/upgrades/iii-0.25.md) innan du fortsätter.
### Claude Code (ett block, klistra in det)
```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 utan plugin-installationen (fristående MCP-väg)
Om du kopplar in agentmemorys MCP-server via `~/.claude.json` (standardsökväg) direkt istället för att använda `/plugin install`, löser Claude Code aldrig upp `${CLAUDE_PLUGIN_ROOT}`, och du måste peka hook-skripten mot absoluta sökvägar i `~/.claude/settings.json` (standardsökväg). Dessa sökvägar innehåller vanligtvis agentmemory-versionen (t.ex. `~/.codex/plugins/cache/agentmemory/agentmemory/0.9.22/scripts/…`), så nästa uppgradering bryter varje hook i det tysta.
Lösning:
```bash
agentmemory connect claude-code --with-hooks
```
Det här kommandot konfigurerar MCP-servern och slår samman de medföljande hookarna med Claude Codes användarkonfiguration. Om `CLAUDE_CONFIG_DIR` inte är satt, är tom eller bara innehåller blanktecken används `~/.claude.json` för MCP och `~/.claude/settings.json` för hooks. Övriga katalogvärden används exakt som de anges, inklusive inledande och avslutande blanktecken. För en egen katalog ställer du in `CLAUDE_CONFIG_DIR` till samma icke-tomma värde för både det här kommandot och Claude Code; filerna blir då `$CLAUDE_CONFIG_DIR/.claude.json` respektive `$CLAUDE_CONFIG_DIR/settings.json`. Claude Code måste få värdet i sin startmiljö, även om anslutningsmodulen läser det från AgentMemorys `.env`. Skapa den egna katalogen innan du kör kommandot; annars hoppar anslutningsmodulen över Claude Code eftersom det inte upptäcks. Om värdet i skalet bara innehåller blanktecken tar du bort `CLAUDE_CONFIG_DIR` från miljön innan du startar Claude Code, så att det också använder standardprofilen. Använd en absolut sökväg. Relativa sökvägar utgår från arbetskatalogen, så båda kommandona måste köras från samma katalog.
Hook-kommandona använder absoluta sökvägar till det installerade paketets medföljande katalog `plugin/`. Kör kommandot igen efter en uppgradering av agentmemory för att uppdatera sökvägarna. Användarens egna poster i konfigurationsfilerna bevaras; bara tidigare agentmemory-poster ersätts. Att använda `/plugin install` är fortfarande det rekommenderade sättet.
För fjärr- eller skyddade driftsättningar, starta Claude Code med `AGENTMEMORY_URL` och `AGENTMEMORY_SECRET` satta. Plugin-programmet skickar båda värdena vidare till sin medföljande MCP-server; när `AGENTMEMORY_URL` är tomt använder MCP-shimmen `http://localhost:3111`.
### Codex CLI (Codex-plugin-plattformen)
```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
```
Codex-pluginet levereras från samma `plugin/`-katalog som Claude Code-pluginet. Det registrerar:
- En medföljande stdio MCP-brygga till den körande daemonen, utan npm-nedladdning eller fallback-lager. Se [lokala Codex-guiden](../docs/plugins/codex-local.md) för att testa en build som ännu inte är publicerad.
- 6 livscykel-hooks: `SessionStart`, `UserPromptSubmit`, `PreToolUse`, `PostToolUse`, `PreCompact`, `Stop`
- 9 anropsbara skills: `/recall`, `/remember`, `/session-history`, `/forget`, `/recap`, `/handoff`, `/lesson`, `/commit-context`, `/commit-history`, plus 8 referens-skills som agenten laddar vid behov (minnesdisciplin, MCP-verktyg, REST API, konfiguration, agenter, hooks, arkitektur och guiden för att skriva skills)
Codex hook-motor injicerar `CLAUDE_PLUGIN_ROOT` i hook-underprocesser (enligt [`codex-rs/hooks/src/engine/discovery.rs`](https://github.com/openai/codex/blob/main/codex-rs/hooks/src/engine/discovery.rs)), så samma hook-skript fungerar på båda värdarna utan duplicering. Händelserna Subagent / SessionEnd / Notification / TaskCompleted / PostToolUseFailure är specifika för Claude Code och registreras inte för Codex.
#### Codex hooks: tillit och kompatibilitet
Native plugin-hook-utlösning är verifierad med Codex CLI 0.150.1. Lita på plugin-hooksen innan du förväntar dig infångning. Desktop-beteendet beror på dess medföljande körtid; kontrollera `/hooks` och bekräfta en infångad händelse innan du aktiverar en lösning.
Om din värd kräver globala hooks, spegla kommandona till `~/.codex/hooks.json`. När MCP redan är inkopplat behöver den nuvarande adaptern `--force` för att nå hook-installationen:
```bash
agentmemory connect codex --with-hooks --force
```
Detta slår samman globala hooks och skriver om agentmemory-MCP-posten, och bevarar orelaterade poster. Granska eventuella anpassade agentmemory-endpoint-inställningar innan du använder `--force`. Kör om efter uppgradering för att uppdatera skriptsökvägarna. Aktivera antingen native plugin-hooks eller globala kopior för att undvika dubblerad infångning.
### GitHub Copilot CLI
För VS Code agent-läge, använd [Copilot MCP- och automatisk-infångningsguiden](../docs/plugins/copilot.md#vs-code-copilot-local-agent-sessions). CLI-adaptern konfigurerar inte VS Code.
```bash
# MCP-only wiring
agentmemory connect copilot-cli
# Alternatively, full hooks/skills plugin from the GitHub subdir
copilot plugin install rohitg00/agentmemory:plugin
```
`agentmemory connect copilot-cli` slår samman `mcpServers.agentmemory` i `~/.copilot/mcp-config.json` (eller `$COPILOT_HOME/mcp-config.json` när `COPILOT_HOME` är satt) och bevarar befintliga servrar. På native Windows är detta den enda automatiserade `connect`-adaptern; konfigurera varje annan native Windows-agent manuellt. WSL-`connect` stöds bara när målagenten är installerad i samma WSL-miljö. Copilot plockar upp MCP-servern vid nästa start eller efter `/mcp`. Installera även pluginet när du vill ha den fullständiga hook-/skill-upplevelsen.
### Cursor
```bash
agentmemory connect cursor
```
Lägg sedan till det inbyggda tillägget från en AgentMemory-utcheckning via **Settings → Plugins → Add marketplace** och ladda om fönstret. Tillägget ger livscykelregistrering, projekttilldelning, skills och MCP. Aktivera antingen tilläggets hooks eller manuella hooks i `~/.cursor/hooks.json` för att undvika dubbel registrering. [Cursor-guide](../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älj kommandot för din värd. Pi och OMP installerar sökning, registrering, offline-återsändning och 17 skills; `--with-mcp` lägger till alla verktyg. Kör `/reload` i Pi eller starta om OMP och kontrollera `/agentmemory-status`. DSH installerar MCP och det medföljande registreringstillägget; starta om DSH efteråt.
Pi stöder även det installerbara paketet `@agentmemory/pi`. [Pi-guiden](../integrations/pi/) beskriver lokal installation och tillgänglighet på npm. Använd en installationsmetod per värd.
[Pi](../integrations/pi/) · [Oh My Pi](../integrations/omp/) · [DSH](../docs/dsh.md)
OpenClaw (klistra in denna prompt)
```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`.
```
Fullständig guide: [`integrations/openclaw/`](../integrations/openclaw/)
Hermes Agent (klistra in denna prompt)
```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.
```
Fullständig guide: [`integrations/hermes/`](../integrations/hermes/)
### Andra agenter
Starta minnesservern: `npx -y @agentmemory/agentmemory@latest`
#### Inbyggda skills via `npx skills add`
agentmemory levereras med 17 skills i Claude-Code-stilens `/SKILL.md`-format: 9 anropsbara handlings-skills (`remember`, `recall`, `recap`, `handoff`, `forget`, `lesson`, `commit-context`, `commit-history`, `session-history`) och 8 referens-skills som agenten laddar vid behov (`memory-discipline`, `agentmemory-mcp-tools`, `agentmemory-rest-api`, `agentmemory-config`, `agentmemory-agents`, `agentmemory-hooks`, `agentmemory-architecture`, `write-agentmemory-skill`). Referens-skillsen innehåller datatabeller genererade från källkoden, så de avviker aldrig. CLI-verktyget [`skills`](https://npmjs.com/package/skills) från vercel-labs installerar dem automatiskt i den anropande agentens inbyggda skill-katalog över 50+ agenter (Claude Code, Cursor, Cline, Continue, Droid, Warp, Codex, Antigravity, Kiro, OpenCode, Goose, Roo, Trae, Windsurf och fler):
```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
```
Detta är ett **komplement** till `agentmemory connect `:
- `agentmemory connect ` skriver normalt MCP-konfigurationen. Hermes, OpenClaw, Pi och Oh My Pi installerar som standard sin inbyggda integration och medföljande skills; MCP läggs till med `--with-mcp`.
- `npx skills add rohitg00/agentmemory` installerar skills för agenter utan medföljande inbyggda skills. Hoppa över detta steg för Hermes, OpenClaw, Pi och Oh My Pi: deras anslutningar installerar redan dessa skills.
För de få agenter som skills-CLI:n ännu inte täcker (Zed v1.3.x och lägre), lägg själv de 17 SKILL.md-filerna i agentens inbyggda skill-katalog; samma format fungerar överallt.
#### Standard-MCP-block
agentmemory-posten är **samma MCP-serverblock** på alla värdar som använder `mcpServers`-formen (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}"
}
}
```
**Slå samman denna post med det befintliga `mcpServers`-objektet** i värdens konfigurationsfil; ersätt inte filen. Om filen redan har andra servrar, lägg till `agentmemory` bredvid dem som en ytterligare nyckel inuti `mcpServers`. Om `mcpServers` helt saknas, klistra in blocket inuti `{ "mcpServers": { ... } }`. `${VAR}`-platshållarna ärver `AGENTMEMORY_URL` / `AGENTMEMORY_SECRET` från skalet vid MCP-serverns start; ej satta variabler skickar tomma strängar och shimmen faller tillbaka till `http://localhost:3111`. En inkopplad post täcker både lokala och fjärran (k8s / reverse-proxyade) driftsättningar.
| Agent | Konfigurationsfil | Anteckningar |
|---|---|---|
| **Cursor (endast MCP)** | `~/.cursor/mcp.json` | Slå samman i `mcpServers`, eller `agentmemory connect cursor`. En deeplink med ett klick finns också på webbplatsen. |
| **Cursor (fullständigt plugin)** | `.cursor-plugin/` | Lägg sedan till det inbyggda tillägget från en AgentMemory-utcheckning via **Settings → Plugins → Add marketplace** och ladda om fönstret. Tillägget ger livscykelregistrering, projekttilldelning, skills och MCP. Aktivera antingen tilläggets hooks eller manuella hooks i `~/.cursor/hooks.json` för att undvika dubbel registrering. [Cursor-guide](../integrations/cursor/). |
| **Claude Desktop** | `claude_desktop_config.json` (Application Support) | Slå samman i `mcpServers`. Starta om Claude Desktop efter redigering. |
| **Cline / Roo Code / Kilo Code** | Clines MCP-inställningar (Settings UI → MCP Servers → Edit) | Samma `mcpServers`-block. |
| **Devin CLI (MCP + hooks)** | `~/.config/devin/config.json` | `agentmemory connect devin` slår samman MCP-posten; `--with-hooks` lägger till sex inbyggda auto-infångnings-hooks (SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Stop, SessionEnd) med Devins gemener i verktygsmatcharna. Verifiera med `devin mcp list` och `/hooks` inuti devin. |
| **Devin CLI (fullständigt plugin)** | `plugin/.devin-plugin/` | `devin plugins install ./plugin` från en checkout registrerar alla 17 skills som `/agentmemory:`-snabbkommandon plus MCP-servern. Devins plugin-hooks kan inte utlösa `SessionStart`/`SessionEnd`, så kombinera med `connect devin --with-hooks` för fullständig sessionsinfångning. |
| **Devin (moln)** | Settings → Connections → MCP servers | Lägg till en anpassad MCP (STDIO): kommando `npx`, argument `-y @agentmemory/mcp@latest`, miljövariabeln `AGENTMEMORY_URL` som pekar på en nätverksåtkomlig agentmemory-driftsättning plus `AGENTMEMORY_SECRET` (molnsessioner kan inte nå localhost — se [`deploy/`](../deploy/)). Spara hemligheten i Devin Secrets, och använd sedan "Test listing tools" för att bekräfta att alla 54 verktyg visas. |
| **Gemini CLI** | `~/.gemini/settings.json` | `gemini mcp add agentmemory npx -y @agentmemory/mcp --scope user` (slås samman automatiskt). |
| **GitHub Copilot CLI (endast MCP)** | `~/.copilot/mcp-config.json` | `agentmemory connect copilot-cli` slår samman `mcpServers.agentmemory`; Copilot plockar upp det vid nästa start eller via `/mcp`. |
| **GitHub Copilot CLI (fullständigt plugin)** | Copilot plugin-installation | `copilot plugin install rohitg00/agentmemory:plugin` för pluginet från GitHub-underkatalogen. |
| **OpenClaw** | OpenClaw MCP-konfiguration | Samma `mcpServers`-block. Djupare integration: `openclaw plugins install ./integrations/openclaw` tar över OpenClaws minnesplats (byter automatiskt från `memory-core`); sätt `plugins.entries.agentmemory.hooks.allowConversationAccess=true`, annars blockeras tur-infångningen i det tysta. Se [`integrations/openclaw`](../integrations/openclaw/). |
| **Codex CLI (endast MCP)** | `.codex/config.toml` | TOML-form: `codex mcp add agentmemory -- npx -y @agentmemory/mcp`, eller lägg till `[mcp_servers.agentmemory]` manuellt. |
| **Codex CLI (fullständigt plugin)** | Codex plugin-marketplace | `codex plugin marketplace add rohitg00/agentmemory` och sedan `codex plugin add agentmemory@agentmemory`. Registrerar MCP + 6 livscykel-hooks + 17 skills. Lita på hooksen och verifiera infångningen i din värd; se [Codex-konfiguration och validering](../docs/plugins/codex-local.md). |
| **OpenCode (endast MCP)** | `opencode.json` | Annan form: en toppnivånyckel `mcp`, kommando som array: `{"mcp": {"agentmemory": {"type": "local", "command": ["npx", "-y", "@agentmemory/mcp"], "enabled": true}}}`. |
| **OpenCode (fullständigt plugin)** | `plugin/opencode/` | 22 auto-infångnings-hooks som täcker sessionslivscykel, meddelanden, verktyg, fel. Projekttillhörighet är per session, så en OpenCode-process som spänner över flera repon registrerar varje session under sitt eget projekt. Två snabbkommandon (`/recall`, `/remember`). Kopiera `plugin/opencode/` till din OpenCode-arbetsyta och lägg till plugin-posten i `opencode.json`. Se [`plugin/opencode/README.md`](../plugin/opencode/README.md) för den fullständiga hook-tabellen + luckanalysen. |
| **Pi / Oh My Pi** | `~/.pi/agent/` / `~/.omp/agent/` | inbyggd sökning + registrering + skills. [Pi](../integrations/pi/) · [Oh My Pi](../integrations/omp/). |
| **Hermes Agent** | `~/.hermes/config.yaml` | `cp -r integrations/hermes ~/.hermes/plugins/agentmemory` + `memory.provider: agentmemory` ger minnesleverantören med 6 hooks (förhämtning, turinfångning, sessionsslut, förkomprimering, MEMORY.md-spegling, systemprompt-block). Validera med `hermes plugins doctor` och `hermes memory status`. Se [`integrations/hermes`](../integrations/hermes/). |
| **Qwen Code** | `~/.qwen/settings.json` | `agentmemory connect qwen` skriver det vanliga `mcpServers`-blocket. Hook-nyttolasten är fältkompatibel med Claude Code, så de befintliga 12-hooks-skripten fungerar utan ändring; koppla in dem via `hooks`-avsnittet i samma `settings.json`. |
| **Antigravity IDE / 2.0** | `~/.gemini/config/mcp_config.json` | `agentmemory connect antigravity --with-hooks` installerar MCP och infångnings-hooks i den delade anpassningskatalogen. Se [Antigravity-konfiguration och begränsningar](../docs/plugins/antigravity.md). |
| **Antigravity CLI** (`agy`) | `~/.gemini/config/mcp_config.json` | `agentmemory connect antigravity-cli --with-hooks` använder samma MCP- och hook-konfiguration som nuvarande IDE-versioner. Befintliga installationer bör uppdateras med `--force`; se [uppgraderingsanteckningarna](../docs/plugins/antigravity.md). |
| **Kiro** | `~/.kiro/settings/mcp.json` | `agentmemory connect kiro` skriver konfigurationen på användarnivå. Arbetsyteöverskrivningar läggs i `.kiro/settings/mcp.json` bredvid din kod. |
| **Warp** | `~/.warp/.mcp.json` | `agentmemory connect warp` skriver det vanliga `mcpServers`-blocket. Warp upptäcker också automatiskt skills från `.claude/skills/`; när Claude Code-pluginet är installerat visas agentmemorys 9 skills (`remember`, `recall`, `recap`, `handoff`, `forget`, `lesson`, `commit-context`, `commit-history`, `session-history`) naturligt i Warps snabbkommando-palett. |
| **Cline (CLI)** | `~/.cline/data/settings/cline_mcp_settings.json` | `agentmemory connect cline` skriver det vanliga `mcpServers`-blocket. VS Code-tilläggsanvändare: klistra in samma block via Cline Settings → MCP Servers → Edit JSON. |
| **Continue.dev** | `~/.continue/config.yaml` (att föredra) eller `config.json` (äldre) | `agentmemory connect continue` skapar en saknad `config.yaml` eller ändrar befintlig `config.json`. Om YAML-filen finns visas blocket för `mcpServers:` så att kommentarer och ankare bevaras. Continue använder en array, inte ett objekt. |
| **Zed** | `~/.config/zed/settings.json` | `agentmemory connect zed` skriver under `context_servers` (Zeds nyckel, INTE `mcpServers`). Fjärranslutna MCP-servrar kan istället kopplas in via `{"url": "..."}`. |
| **Droid (Factory.ai)** | `~/.factory/mcp.json` | `agentmemory connect droid` skriver det vanliga `mcpServers`-blocket. Projektbegränsade överskrivningar läggs i `/.factory/mcp.json`. Ange `--with-hooks` för inbyggd auto-infångning. |
| **DeepSeek Harness** | `$DSH_HOME/cordis.patch.yml` | `agentmemory connect dsh` aktiverar MCP-verktyg. Lägg till `--with-hooks` för att läsa in det inbyggda registreringstillägget som följer med AgentMemory. Inget separat tilläggspaket behövs. [DSH](../docs/dsh.md). |
| **Goose** | Goose MCP-inställningsgränssnitt | Samma `mcpServers`-block; använd `goose configure` → Add Extension → MCP. Direkt YAML-redigering i `~/.config/goose/config.yaml` stöds, men schemat använder `extensions:` + `cmd` (inte `mcpServers:` + `command`). |
| **Aider** | n/a | Använd de [autentiserade REST-exemplen](#validate-a-fresh-install-and-restart-persistence) för att spara och söka efter minnen från skript. |
| **Agenter som stöds** | Endast skills | `npx skills add rohitg00/agentmemory`; välj vilka skills som ska installeras och för vilka agenter. |
**Sandboxade MCP-klienter** (Flatpak / Snap / restriktiva containrar) som inte kan nå värdens `localhost`: sätt även `"AGENTMEMORY_FORCE_PROXY": "1"` i `env`-blocket, och peka `AGENTMEMORY_URL` mot en väg som sandboxen faktiskt kan nå (t.ex. din LAN-IP).
### Programmatisk åtkomst (Python / Rust / Node)
Använd [REST API:t](#api) från valfritt språk eller [MCP-verktygen](#mcp-server) från en agent. REST använder JSON och bearer-autentisering; se [exemplet för lagring och sökning](#validate-a-fresh-install-and-restart-persistence). [Python-exemplen](../examples/python/) visar direkt integration med körtiden.
### Från källkod
```bash
git clone https://github.com/rohitg00/agentmemory.git && cd agentmemory
npm install && npm run build && npm start
```
`npm start` startar samma lokala server som den installerade CLI:n. Kraven finns under [Install](#install); API och viewer lyssnar på `127.0.0.1`.
### Windows
agentmemory körs på Windows 10/11. WSL2 följer Linux-vägen och kan installera den fastlåsta enginen automatiskt. Native Windows kräver att den fastlåsta iii-engine v0.25.1-binären installeras manuellt: ladda ner rätt arkiv från [iii v0.25.1-utgåvan](https://github.com/iii-hq/iii/releases/tag/iii%2Fv0.25.1), verifiera kontrollsumman och placera `iii.exe` på `PATH` (till exempel `%USERPROFILE%\.local\bin\iii.exe`). CLI:n packar inte upp Windows-ZIP-filen automatiskt.
Automatiserad MCP-inkoppling på native Windows stöder bara `agentmemory connect copilot-cli`. För andra native Windows-agenter använder du det manuella MCP-blocket från [Andra agenter](#other-agents). Kör `connect` i WSL endast om målagenten är installerad i samma WSL-miljö.
**Endast fristående MCP (ingen engine).** Om du bara behöver MCP-verktyg och inte REST API, viewern eller runtime-tjänster:
```powershell
npx -y @agentmemory/agentmemory@latest mcp
# or
npx -y @agentmemory/mcp
```
Kör `agentmemory doctor` eller starta om med `--verbose`. Använd `--port ` eller `--instance ` om portarna är upptagna. Se [uppgraderingsguiden](../docs/upgrades/iii-0.25.md) för kompatibilitet och återställning.
---
Driftsättning
Driv tjänsten med Docker Compose eller mallarna nedan. Minnen och autentiseringsuppgifter finns på `/data`-volymen. Säkerhetskopiera och återanvänd volymen vid uppgradering. [Driftsättningsguiden](../deploy/README.md) beskriver autentisering, nätverk, säkerhetskopiering och migrering.
Renders driftsättningsknapp med ett klick kräver `render.yaml` i repots rot, vilket vi avsiktligt håller rent. Använd Render Blueprint-flödet som dokumenteras i [`deploy/render/`](.././deploy/render/README.md) för att manuellt peka på den repo-interna blueprinten.
Fullständiga installationsdetaljer (HMAC-infångning, SSH-tunnel för viewern, rotation, backup, kostnadsgolv) finns i [`deploy/`](.././deploy/README.md):
- [`deploy/fly`](.././deploy/fly/README.md): en enda maskin med
`auto_stop_machines = "stop"`; billigast vid inaktivitet.
- [`deploy/railway`](.././deploy/railway/README.md): fast avgift på
Hobby-planen, volym i dashboarden.
- [`deploy/render`](.././deploy/render/README.md): Blueprint-flöde,
automatiska disk-snapshots på betalplaner.
- [`deploy/coolify`](.././deploy/coolify/README.md): självhostat på din
egen VPS via [Coolify](https://coolify.io/self-hosted); samma Docker
Compose-stack, du äger värden och datan.
REST använder port `3111`; viewern använder `3113`. Håll dem privata eller skydda dem med autentisering och TLS. Driftsättningsguiden beskriver nätverksåtkomst och [migrering av äldre Docker-installationer](../deploy/README.md#migrating-from-the-legacy-cli-docker-mode).
---
Projektkunskap sprids mellan chattar och instruktionsfiler. AgentMemory gör tidigare beslut, lösningar och lärdomar sökbara från den agent du använder nu.
```text
Session 1: "Add auth to the API"
Agent writes code, runs tests, fixes bugs
Connected hooks capture supported tool events
Observations become searchable project history
Session 2: "Now add rate limiting"
Agent recalls:
- Auth uses JWT middleware in src/middleware/auth.ts
- Tests in test/auth.test.ts cover token validation
- You chose jose over jsonwebtoken for Edge compatibility
Continues with the earlier decisions in context.
```
### Jämfört med inbyggt agentminne
Varje AI-kodningsagent levereras med inbyggt minne: Claude Code har `MEMORY.md`, Cursor har notepads, Cline har memory bank. Dessa fungerar som post-it-lappar. agentmemory är den sökbara databasen bakom post-it-lapparna.
| | Inbyggt (CLAUDE.md) | agentmemory |
|---|---|---|
| Underhåll | Manuellt underhållna instruktioner | Indexerad sessionshistorik och minnen |
| Sökning | Laddar allt in i kontexten | BM25 + vektor + graf (endast topp-K) |
| Mellan agenter | Filer per agent | MCP + REST (vilken agent som helst) |
| Koordinering | Ingen | Leaser, signaler, åtgärder, rutiner |
| Observerbarhet | Läs filer manuellt | Viewer i realtid på :3113 |
---
### Minnespipeline
```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-nivås minneskonsolidering
Modellerat efter hur mänskliga hjärnor bearbetar minne, inklusive sömnkonsolidering.
| Nivå | Vad | Analogi |
|------|------|---------|
| **Arbetsminne** | Råa observationer från verktygsanvändning | Korttidsminne |
| **Episodiskt** | Komprimerade sessionssammanfattningar | "Vad som hände" |
| **Semantiskt** | Extraherade fakta och mönster | "Vad jag vet" |
| **Procedurellt** | Arbetsflöden och beslutsmönster | "Hur man gör det" |
Minnen klingar av över tid (Ebbinghaus-kurvan). Ofta använda minnen förstärks. Inaktuella minnen rensas ut automatiskt. Motsägelser upptäcks och löses.
### Vad som fångas in
Tabellen beskriver Claude Codes hooks. Andra integrationer registrerar de händelser som deras värd erbjuder; se respektive guide. Automatisk kontextinjektion via delade hooks aktiveras med `AGENTMEMORY_INJECT_CONTEXT=true`.
| Hook | Fångar in |
|------|----------|
| `SessionStart` | Projektsökväg, sessions-ID |
| `UserPromptSubmit` | Användarprompter (integritetsfiltrerade) |
| `PreToolUse` | Filåtkomstmönster + berikad kontext |
| `PostToolUse` | Verktygsnamn, indata, utdata |
| `PostToolUseFailure` | Felkontext |
| `PreCompact` | Återinjicerar minne före komprimering |
| `SubagentStart/Stop` | Underagentens livscykel |
| `Stop` | Sammanfattning vid sessionens slut |
| `SessionEnd` | Markering för avslutad session |
### Nyckelfunktioner
| Funktion | Beskrivning |
|---|---|
| **Automatisk infångning** | Inbyggda integrationer registrerar sessions- och verktygshändelser som stöds |
| **Semantisk sökning** | BM25 + vektor + kunskapsgraf med RRF-fusion |
| **Minnesutveckling** | Versionering, ersättning, relationsgrafer |
| **Återkallningshygien** | Ersatta minnesversioner lämnar sökindexen; versionskedjan i KV behåller fullständig historik |
| **Nästan-dubblett-tips** | Sparningar rapporterar en rådgivande `similarTo`-matchning när nytt innehåll nära liknar ett befintligt minne |
| **Scoping per agent** | `agentId` löper genom spara och återkalla över REST, MCP och sökindexet, i delat eller isolerat läge |
| **Ursprung vid skrivtillfället** | Varje observation och minne bär en oföränderlig ursprungskanal (user, agent, tool, import eller shared) stämplad vid infångning, sparning och import |
| **Automatisk glömning** | TTL-utgång, upptäckt av motsägelser, viktbaserad utrensning |
| **Integritet först** | API-nycklar, hemligheter, ``-taggar tas bort före lagring |
| **Självläkande** | Circuit breaker, reservkedja för leverantörer, hälsoövervakning |
| **Claude-brygga** | Dubbelriktad synkning med MEMORY.md |
| **Kunskapsgraf** | Entitetsextraktion + BFS-genomsökning |
| **Teamminne** | Namnrymdsindelat delat + privat mellan teammedlemmar |
| **Citeringsursprung** | Spåra vilket minne som helst tillbaka till källobservationerna |
| **Git-snapshots** | Versionera, återställa och diffa minnestillståndet |
---
Trippelströms-hämtning som kombinerar tre signaler:
| Ström | Vad den gör | När |
|---|---|---|
| **BM25** | Stam-baserad nyckelordsmatchning med synonymexpansion | Alltid aktiv |
| **Vektor** | Cosinuslikhet över täta embeddings | Embedding-leverantör konfigurerad |
| **Graf** | Genomsökning av kunskapsgrafen via entitetsmatchning | Entiteter upptäckta i frågan |
Sammanfogad med Reciprocal Rank Fusion (RRF, k=60) och sessionsdiversifierad (max 3 resultat per session).
När ett vektorindex är ifyllt använder `mem::search` (bakom `memory_recall`) den hybrida BM25 + vektor-rankaren. Utan embeddings används BM25. `smart-search` kan dessutom sammanfoga strukturella grafmatchningar när grafdata finns, även i nyckelfritt läge. Återkallning av lärdomar körs på ett dedikerat BM25-index i minnet istället för att skanna hela korpuset per fråga. Ersatta minnesversioner exkluderas från varje återkallningsväg; versionskedjan behåller deras historik.
[0.9.31: `AGENTMEMORY_VECTOR_BACKFILL=all` / `AGENTMEMORY_VECTOR_BACKFILL_MAX`](../docs/reliability/source-and-vector-recovery.md).
BM25 tokeniserar grekiska, kyrilliska, hebreiska, arabiska och accentuerad latin direkt ur lådan. För kinesiska/japanska/koreanska minnen, installera de valfria segmenterarna (`npm install @node-rs/jieba tiny-segmenter`) för att dela upp CJK-sekvenser i ordnivå-tokens; utan dem faller agentmemory mjukt tillbaka till tokenisering av hela sekvenser och skriver ut en engångstips på stderr.
### Embedding-leverantörer
Nyckelfria installationer inaktiverar vektor-embeddings: `mem::search` använder BM25, medan `smart-search` också kan använda befintlig strukturell grafdata. För att aktivera kostnadsfria semantiska embeddings på enheten, lägg till detta i `~/.agentmemory/.env` och starta om agentmemory:
```env
EMBEDDING_PROVIDER=local
```
Den vanliga npm-installationen inkluderar den valfria körtiden `@huggingface/transformers`. Den första embedding-förfrågan laddar ner `Xenova/all-MiniLM-L6-v2`, så den behöver nätverksåtkomst och kan ta längre tid; efterföljande inferens körs på enheten. Fjärrleverantörer upptäcks automatiskt utifrån sina nycklar om inte `EMBEDDING_PROVIDER` åsidosätter dem.
| Leverantör | Modell | Kostnad | Anteckningar |
|---|---|---|---|
| **Lokal (rekommenderat att aktivera)** | `all-MiniLM-L6-v2` | Kostnadsfri | [`EMBEDDING_PROVIDER=local`](../README.md#embedding-providers) |
| Gemini | `gemini-embedding-001` | Kostnadsfri nivå | 100+ språk, 768/1536/3072 dimensioner (MRL), 2048-token indata. Ersätter `text-embedding-004` ([utfasad, stängs ner 14 jan 2026](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` | Betald | Optimerad för kod |
| Cohere | `embed-english-v3.0` | Kostnadsfri provperiod | Generell användning |
| OpenRouter | Vilken modell som helst | Varierar | Multimodell-proxy |
---
54 verktyg, 6 resurser, 3 prompter och 17 skills.
> **MCP-shim kontra fullständig server:** det publicerade paketet `@agentmemory/mcp` är en tunn shim. Det exponerar hela ytan med 54 verktyg **bara när det kan nå en körande agentmemory-server** via `AGENTMEMORY_URL` (proxy-läge). Utan någon nåbar server faller shimmen tillbaka till en lokal uppsättning på 7 verktyg (`memory_save`, `memory_recall`, `memory_smart_search`, `memory_sessions`, `memory_export`, `memory_audit`, `memory_governance_delete`). Miljövariabeln `AGENTMEMORY_TOOLS=core|all` är en flagga på *serversidan*; att sätta den i shimmens `env`-block har ingen effekt. Om du bara ser 7 verktyg i Cursor / OpenCode / Gemini CLI, starta `npx -y @agentmemory/agentmemory@latest` (eller Docker-stacken) och sätt `AGENTMEMORY_URL=http://localhost:3111`.
### 54 verktyg
Tre verktygsytor, från minst till störst: `AGENTMEMORY_TOOLS=core` begränsar synligheten till 8 väsentliga verktyg (`memory_save`, `memory_recall`, `memory_consolidate`, `memory_smart_search`, `memory_sessions`, `memory_diagnose`, `memory_lesson_save`, `memory_reflect`); grundmängden nedan är registrets 14 grundläggande verktyg; standarden (`AGENTMEMORY_TOOLS=all`) exponerar alla 54.
Grundverktyg (14)
| Verktyg | Beskrivning |
|------|-------------|
| `memory_recall` | Sök i tidigare observationer |
| `memory_compress_file` | Komprimera markdown-filer samtidigt som strukturen bevaras |
| `memory_save` | Spara en insikt, ett beslut eller ett mönster |
| `memory_file_history` | Tidigare observationer om specifika filer |
| `memory_patterns` | Upptäck återkommande mönster |
| `memory_sessions` | Lista senaste sessionerna |
| `memory_smart_search` | Hybrid semantisk + nyckelordssökning |
| `memory_vision_search` | Sök bland bildobservationer |
| `memory_timeline` | Kronologiska observationer |
| `memory_profile` | Projektprofil (koncept, filer, mönster) |
| `memory_export` | Exportera all minnesdata |
| `memory_relations` | Fråga relationsgrafen |
| `memory_commit_lookup` | Sessioner bakom en git-commit |
| `memory_commits` | Commits registrerade för en session |
Utökade verktyg (54 totalt, standardytan)
| Verktyg | Beskrivning |
|------|-------------|
| `memory_patterns` | Upptäck återkommande mönster |
| `memory_timeline` | Kronologiska observationer |
| `memory_relations` | Fråga relationsgrafen |
| `memory_graph_query` | Genomsökning av kunskapsgrafen |
| `memory_consolidate` | Kör 4-nivås konsolidering |
| `memory_claude_bridge_sync` | Synka med MEMORY.md |
| `memory_team_share` | Dela med teammedlemmar |
| `memory_team_feed` | Senaste delade objekt |
| `memory_audit` | Granskningsspår för operationer |
| `memory_governance_delete` | Radera med granskningsspår |
| `memory_snapshot_create` | Git-versionerad snapshot |
| `memory_action_create` | Skapa arbetsobjekt med beroenden |
| `memory_action_update` | Uppdatera åtgärdsstatus |
| `memory_frontier` | Oblockerade åtgärder rankade efter prioritet |
| `memory_next` | Den enskilt viktigaste nästa åtgärden |
| `memory_lease` | Exklusiva åtgärdsleaser (multiagent) |
| `memory_routine_run` | Instansiera arbetsflödesrutiner |
| `memory_signal_send` | Meddelanden mellan agenter |
| `memory_signal_read` | Läs meddelanden med kvitton |
| `memory_checkpoint` | Externa villkorsgrindar |
| `memory_mesh_sync` | P2P-synk mellan instanser |
| `memory_sentinel_create` | Händelsedrivna bevakare |
| `memory_sentinel_trigger` | Utlös bevakare externt |
| `memory_sketch_create` | Kortlivade åtgärdsgrafer |
| `memory_sketch_promote` | Befordra till permanent |
| `memory_crystallize` | Komprimera åtgärdskedjor |
| `memory_diagnose` | Hälsokontroller |
| `memory_heal` | Fixa fastnat tillstånd automatiskt |
| `memory_facet_tag` | Dimension:värde-taggar |
| `memory_facet_query` | Fråga via facett-taggar |
| `memory_verify` | Spåra ursprung |
### 6 resurser · 3 prompter · 17 skills
| Typ | Namn | Beskrivning |
|------|------|-------------|
| Resurs | `agentmemory://status` | Hälsa, sessionsantal, minnesantal |
| Resurs | `agentmemory://project/{name}/profile` | Intelligens per projekt |
| Resurs | `agentmemory://project/{name}/recent` | Senaste observationer för ett projekt |
| Resurs | `agentmemory://memories/latest` | De 10 senaste aktiva minnena |
| Resurs | `agentmemory://graph/stats` | Statistik för kunskapsgrafen |
| Resurs | `agentmemory://team/{id}/profile` | Delad teamprofil |
| Prompt | `recall_context` | Sök + returnera kontextmeddelanden |
| Prompt | `session_handoff` | Överlämningsdata mellan agenter |
| Prompt | `detect_patterns` | Analysera återkommande mönster |
| Skill | `/recall` | Sök i minnet |
| Skill | `/remember` | Spara till långtidsminnet |
| Skill | `/session-history` | Senaste sessionssammanfattningarna |
| Skill | `/forget` | Radera observationer/sessioner |
Tabellen visar de fyra kärnskillsen. Den fullständiga mängden är 9 anropsbara skills plus 8 referens-skills; se avsnittet om inbyggda skills ovan.
### Fristående MCP
Körs utan den fullständiga servern, för vilken MCP-klient som helst. Något av dessa fungerar:
```bash
npx -y @agentmemory/agentmemory@latest mcp # canonical (always available)
npx -y @agentmemory/mcp # shim package alias
```
Eller lägg till i din agents MCP-konfiguration:
De flesta agenter (Cursor, Claude Desktop, Cline, Roo Code, Gemini CLI):
```json
{
"mcpServers": {
"agentmemory": {
"command": "npx",
"args": ["-y", "@agentmemory/mcp"],
"env": {
"AGENTMEMORY_URL": "http://localhost:3111"
}
}
}
}
```
Slå samman `agentmemory`-posten med värdens befintliga `mcpServers`-objekt istället för att ersätta filen. För sandboxade klienter som inte kan nå värdens `localhost`, lägg till `"AGENTMEMORY_FORCE_PROXY": "1"` i env-blocket och sätt `AGENTMEMORY_URL` till en väg som sandboxen kan nå.
OpenCode (`opencode.json`):
```json
{
"mcp": {
"agentmemory": {
"type": "local",
"command": ["npx", "-y", "@agentmemory/mcp"],
"enabled": true
}
},
"plugin": ["./plugins/agentmemory-capture.ts"]
}
```
Kopiera plugin-filen från repot:
```bash
mkdir -p ~/.config/opencode/plugins
cp plugin/opencode/agentmemory-capture.ts ~/.config/opencode/plugins/
cp plugin/opencode/commands/*.md ~/.config/opencode/commands/
```
---
Startar automatiskt på port `3113`. Viewern laddar en snapshot när den ansluter (`GET /agentmemory/viewer/snapshot`) och tillämpar därefter live-strömhändelser: nya minnen, lärdomar, observationer, granskningsposter, grafändringar och hälsouppdateringar visas utan polling eller sidomladdningar. De enda andra förfrågningarna är de åtgärder du klickar på, sidor för "ladda mer" och sökningar. När strömmen bryts visar viewern hur gamla dess siffror är, återansluter med backoff och synkar om från en snapshot.
- **12 flikar i fyra grupper** med livevärden, djuplänkar (`#memories/`, `#sessions/?obs=`, `#graph/`, `#health/consolidation`), kortkommandon och en mobilmeny.
- **Memories:** serversidig sökning, filter efter projekt, agent och typ, en detaljpanel med versionskedjan och en orddiff, ursprungslänkar, kopieringsknappar för id:t, MCP-anropet och ett curl-kommando, redigering (en ny version), glöm med bekräftelse, massglöm och JSON-export.
- **Sessions:** en inbäddad observationstidslinje med läsbar verktygsindata och -utdata, filter och sidbläddring, samt de minnen och lärdomar varje session gav upphov till.
- **Graph:** sökning, noddetaljer med relationer och källor, en legend som inte enbart förlitar sig på färg, samt zoomkontroller.
- **Health:** liveversionen av `GET /agentmemory/status`. Varje problem kommer med sin åtgärd, plus state-backend, indexsparningsstatus, förloppet för kompaktering av grafursprung och en konsolideringsförklaring med de verkliga tröskelvärdena.
- **Audit, Activity, Profile, Replay, Lessons, Actions och Crystals**-sidorna, var och en med ett tomt tillstånd som säger vad avsnittet är, varför det är tomt och vilket kommando som fyller det, samt en `?`-ordlisteverktygstips på varje term och siffra.
```bash
open http://localhost:3113
```
Viewer-servern binder till `127.0.0.1` som standard och bifogar serverhemligheten när den vidarebefordrar förfrågningar till REST API:et, så den behöver ingen konfiguration. Endpointen `/agentmemory/viewer`, som serveras via REST, följer de vanliga bearer-token-reglerna och omdirigerar webbläsare utan token till viewer-porten. CSP-headrarna använder en script-nonce per svar och inaktiverar inline-hanterarattribut (`script-src-attr 'none'`).
---
### LLM-leverantörer
agentmemory upptäcker leverantörer automatiskt från din miljö. En leverantör gör LLM-baserade operationer tillgängliga, men leverantörskonfiguration ensam aktiverar inte LLM-skriven observationskomprimering. Den vägen kräver både en leverantör och `AGENTMEMORY_AUTO_COMPRESS=true`.
| Leverantör | Konfiguration | Anteckningar |
|----------|--------|-------|
| **No-op (standard)** | Ingen konfiguration behövs | LLM-baserad komprimering/sammanfattning är inaktiverad. Syntetisk komprimering och BM25-återkallning fungerar fortfarande. Se `AGENTMEMORY_ALLOW_AGENT_SDK` nedan om du tidigare förlitade dig på Claude-prenumerationsreserven. |
| Anthropic API | `ANTHROPIC_API_KEY` | Fakturering per token |
| MiniMax | `MINIMAX_API_KEY` | Anthropic-kompatibel |
| Gemini | `GEMINI_API_KEY` | Aktiverar även embeddings |
| OpenRouter | `OPENROUTER_API_KEY` | Vilken modell som helst |
| OpenAI API | `OPENAI_API_KEY` | Standard `gpt-5.6-luna`, åsidosätt med `OPENAI_MODEL` |
| **Lokal (Ollama / LM Studio / vLLM / llama.cpp)** | `OPENAI_API_KEY=local` + `OPENAI_BASE_URL=http://localhost:11434/v1` (Ollama) eller `http://localhost:1234/v1` (LM Studio) + `OPENAI_MODEL=` | Allt som är OpenAI-API-kompatibelt. Noll kostnad, körs på din hårdvara. Se [Lokala modeller](#local-models-ollama--lm-studio--vllm) nedan. |
| Claude-prenumerationsreserv | `AGENTMEMORY_ALLOW_AGENT_SDK=true` | Endast opt-in. Startar `@anthropic-ai/claude-agent-sdk`-sessioner; den orsakade tidigare obegränsad Stop-hook-rekursion, så den är inte längre standard. |
### Lokala modeller (Ollama / LM Studio / vLLM)
agentmemory talar med vilken OpenAI-API-kompatibel server som helst, så allt som exponerar `/v1/chat/completions` fungerar utan kodändringar. Inga betalda nycklar, inget moln, inga rate limits; körs helt på din hårdvara.
**Ollama** (standardport `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** (standardport `1234`):
Öppna LM Studio → fliken Local Server → Start Server. Välj vilken chattmodell som helst från väljaren (Qwen 3, gpt-oss, DeepSeek R1, osv.).
```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**: samma form. Peka `OPENAI_BASE_URL` mot vilken URL din server än exponerar och sätt `OPENAI_MODEL` till ett namn din server accepterar.
**Modellval för minnesarbete**: komprimering och sammanfattning är korta uppgifter (<2K tokens in, <500 tokens ut) där en 7B instruct-modell räcker gott och väl. Rekommendationer:
| Modell | Storlek | Varför |
|-------|------|-----|
| `qwen3:8b` | ~5.2 GB | Balanserad standard på en 16 GB-maskin; stark på extraktion och verktygsformad text |
| `qwen3:4b` | ~2.6 GB | Minsta rimliga alternativet; funkar för komprimering, svagare för grafextraktion |
| `qwen3-coder:30b` | ~19 GB | Bästa lokala valet för kodformade sessioner (30B MoE, 3.3B aktiva) på 24-32 GB hårdvara |
| `gpt-oss:20b` | ~14 GB | Stark generell modell som ryms i 16 GB RAM |
| `deepseek-r1:8b` | ~5.2 GB | Reasoning-destillat; långsammare men renare extraktioner |
Qwen 3-modeller tänker som standard och kan bränna hela tokenbudgeten på reasoning innan någon utdata alls. Sätt `AGENTMEMORY_LLM_NOTHINK=1` för att lägga till `/no_think` i prompter för grafextraktion, och höj `MAX_TOKENS` (16384 funkar) om extraktioner kommer tillbaka tomma.
Reasoning-modeller (`o1`-stil med ``-block) kan returnera tomt `content` med ett `reasoning`-fält som din lokala server kanske inte exponerar. Om extraktioner kommer tillbaka tomma, byt först till en modell utan reasoning. Miljövariabeln `OPENAI_REASONING_EFFORT=none` kan också inaktivera tänkande på Ollama Cloud-tänkande-modeller som speglar OpenAIs reasoning-schema.
Lokala embeddings levereras som ett valfritt beroende men är inte aktiverade som standard. Sätt `EMBEDDING_PROVIDER=local` för att aktivera `Xenova/all-MiniLM-L6-v2` (384 dimensioner). Den första embedding-förfrågan laddar ner modellen; inferensen sker därefter på enheten. Utan den inställningen eller en fjärr-embedding-nyckel förblir vektorer inaktiverade, `mem::search` använder BM25, och `smart-search` kan fortfarande lägga till befintliga grafmatchningar.
### Kostnadsmedvetet modellval
Börja utan nyckel för registrering och nyckelordssökning. `EMBEDDING_PROVIDER=local` aktiverar lokal semantisk sökning efter den första modellnedladdningen. LLM-komprimering kräver en leverantör och `AGENTMEMORY_AUTO_COMPRESS=true`; den kan skicka en begäran per observation. Kontrollera aktuella priser först. Viewern och `agentmemory status` visar aktiva leverantörer.
### Multiagent-minne (`AGENT_ID` + `AGENTMEMORY_AGENT_SCOPE`)
I multiagent-uppsättningar där flera roller delar en agentmemory-server (architect / developer / reviewer / researcher / support-agent), taggar `AGENT_ID` varje skrivning med rollen som gjorde den. `AGENTMEMORY_AGENT_SCOPE` styr om återkallning filtrerar på den taggen.
```env
TEAM_ID=company
USER_ID=engineering-team
AGENT_ID=architect
AGENTMEMORY_AGENT_SCOPE=isolated # optional; default "shared"
```
Två lägen:
| Läge | Taggar skrivningar | Filtrerar återkallning | När man använder det |
|------|------------|---------------|-------------|
| `shared` (standard) | ja | nej | Kontext mellan agenter med granskningsspår. Architect kan se vad developer noterade, men varje rad registrerar vem som sa det. |
| `isolated` | ja | ja | Strikt separation. Architect ser aldrig developers observationer / minnen / sessioner. |
Vad som taggas när `AGENT_ID` är satt: `Session.agentId`, `RawObservation.agentId`, `CompressedObservation.agentId`, `Memory.agentId`. Rollen flödar från `api::session::start` → `mem::observe` → `mem::compress` → KV.
Vad som filtreras i isolerat läge: `mem::smart-search`, `/agentmemory/memories`, `/agentmemory/observations`, `/agentmemory/sessions`. Varje endpoint accepterar `?agentId=` för att åsidosätta per förfrågan, och `?agentId=*` för att helt välja bort miljö-scopet. `/memories` accepterar också `?includeOrphans=true` för att visa minnen från före AGENT_ID vars `agentId` är odefinierad.
Åsidosättning per anrop på SDK-/REST-lagret: varje muterande endpoint (`/session/start`, `/remember`) accepterar ett `agentId`-fält i förfrågans body som vinner över miljövariabeln. Användbart för körtider som dirigerar många roller genom en serverprocess. MCP-verktyget `memory_save` exponerar samma `agentId`-fält, den fristående stdio-servern vidarebefordrar både `agentId` och `project`, och sparade minnen bär `agentId` in i sökindexet, så agent-scopead sökning täcker minnen lika väl som observationer.
När `AGENT_ID` inte är satt förblir minnet oscopat (äldre beteende, inga taggar, inga filter).
### Portar
| Port | Syfte | Konfiguration |
|---|---|---|
| `3111` | REST API, MCP HTTP, SSE | `III_REST_PORT` |
| `3113` | Viewer UI | `III_VIEWER_PORT` |
`--port ` anger API-porten och som standard viewern på `N+2`. Använd `--instance N` för en separat instans. Håll interna portar privata; läs [driftsättningsguiden](../deploy/README.md) innan du tillåter fjärråtkomst.
### Lagringsbackend: fil (standard) kontra redis
Standardlagringen använder filer och kräver ingen separat databastjänst. Redis är valfritt med `AGENTMEMORY_STATE_BACKEND=redis` och `AGENTMEMORY_REDIS_URL`. Ett byte av backend kopierar inga minnen. Se [lagring och säkerhetskopiering](../docs/reliability/state-storage.md) för beständighet, Redis-begränsningar och autentiserad export/import.
### Konfigurationsfil
Lägg agentmemorys körtidskonfiguration i `~/.agentmemory/.env` istället för att exportera variabler i varje skal. Om viewern visar ett konfigurationstips som `export ANTHROPIC_API_KEY=...`, kopiera det in i den här filen som `ANTHROPIC_API_KEY=...` utan `export`-prefixet, och starta sedan om agentmemory. Sätt `AGENTMEMORY_ENV_FILE` för att använda en annan env-fil.
Processens miljövariabler har företräde framför filens värden. Starta om servern efter konfigurationsändringar.
På Windows finns samma fil på `%USERPROFILE%\.agentmemory\.env`:
```powershell
New-Item -ItemType Directory -Force $HOME\.agentmemory
notepad $HOME\.agentmemory\.env
```
För att testa med en Claude Code Pro/Max-prenumeration istället för en API-nyckel, aktivera det explicit:
```env
AGENTMEMORY_ALLOW_AGENT_SDK=true
AGENTMEMORY_AUTO_COMPRESS=true
```
LLM-skriven observationskomprimering kräver båda raderna: åtkomst till en LLM-leverantör (inklusive denna explicita prenumerationsreserv) och `AGENTMEMORY_AUTO_COMPRESS=true`. En leverantör ensam lämnar standardvägen för syntetisk komprimering intakt.
Konsolidering (grafnoder, lärdomar, crystals) är aktiverad som standard närhelst en LLM-leverantör är konfigurerad. Välj bort den explicit med `CONSOLIDATION_ENABLED=false` om du vill ha LLM-fri drift. Grafextraktion är en separat flagga:
```env
GRAPH_EXTRACTION_ENABLED=true
# CONSOLIDATION_ENABLED=false # opt out of auto-consolidation
```
### Miljövariabler
Vanliga alternativ för `~/.agentmemory/.env`:
```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
```
Den fullständiga referensen finns i [`.env.example`](../.env.example): autentiseringsuppgifter, registreringsfilter, lagringstid, lagring, teamavgränsning och tillval. `AGENTMEMORY_ENV_FILE` väljer en annan fil. Lägg aldrig till en ifylld `.env` eller bearer-hemlighet i git.
---
147 endpoints på port `3111`. REST API:et binder till `127.0.0.1` som standard. Skyddade endpoints kräver `Authorization: Bearer `, och mesh-synk-endpoints kräver en explicit satt `AGENTMEMORY_SECRET` på båda parterna.
**Autentisering är aktiverad som standard.** Om `AGENTMEMORY_SECRET` inte är angiven i skalet eller i `~/.agentmemory/.env` skapar CLI:n en slumpmässig hemlighet vid första starten i `~/.agentmemory/secret` och en kopia med namnet `secret` i den valda datamappen, med filbehörigheten `0600`. Alla medföljande klienter läser den därifrån när de ansluter till en lokal server: CLI:n, viewern, hookarna under `plugin/scripts`, MCP-servern och `@agentmemory/mcp`-shimmen, konfigurationerna skrivna av `agentmemory connect` samt de medföljande integrationerna för OpenCode, Pi, OpenClaw, Hermes och filsystemsbevakaren. Den lagrade hemligheten skickas bara till loopback-URL:er (`localhost`, `127.0.0.0/8`, `::1`). En explicit `AGENTMEMORY_SECRET` har alltid företräde; fjärrklienter behöver hemligheten i sin miljö. Docker-baserad self-hosting från repot och startpunkterna i `deploy/` genererar och exporterar en egen hemlighet. För att anropa API:et för hand:
```bash
curl -H "Authorization: Bearer " http://localhost:3111/agentmemory/health
```
**Regler för skrivförfrågningar.** `POST`-, `PUT`-, `PATCH`- och `DELETE`-förfrågningar till REST API:et och viewern måste skicka `Content-Type: application/json` (en `charset`-parameter är okej) närhelst de bär en body, och en `Origin`-header, när den finns, måste vara en loopback-origin för den konfigurerade REST- eller viewer-porten eller finnas listad i `VIEWER_ALLOWED_ORIGINS` (kommaseparerat, t.ex. `https://memory.example.com`). Klienter som inte skickar någon `Origin`-header (CLI, hooks, MCP, curl, server-till-server) påverkas inte. Viewern accepterar också sitt eget origin.
**Filsökvägar.** Endpoints som läser eller skriver filer (`/compress-file`, `/replay/import-jsonl`, `/graph/import-graphify`) accepterar bara sökvägar under `~/.agentmemory`, instansens datakatalog, eller en katalog listad i `AGENTMEMORY_IMPORT_ROOT` (separera flera med `:`, eller `;` på Windows). `/replay/import-jsonl` accepterar också sin standard `~/.claude/projects`. `/obsidian/export` håller sig inom `AGENTMEMORY_EXPORT_ROOT` och `/migrate` inom `~/.agentmemory`. Symlinkar löses upp innan varje kontroll.
**Rensning av hemligheter.** API-nycklar, bearer-tokens, PEM-privatnyckelblock och autentiseringsuppgifter inbäddade i URL:er (`scheme://user:password@host`) redigeras bort innan text lagras, på varje skrivväg: observations, remember, evolve, slots, lessons, actions, sketches, signals, checkpoints, imports, jsonl replay, mesh sync, team shares, komprimerings- och sammanfattningsutdata, crystals och grafnoder.
Viktiga endpoints
| Metod | Sökväg | Beskrivning |
|--------|------|-------------|
| `GET` | `/agentmemory/health` | Hälsokontroll (alltid publik) |
| `GET` | `/agentmemory/status` | Vad som är fel och hur man fixar det (HTML för webbläsare, annars JSON) |
| `GET` | `/agentmemory/viewer/snapshot` | Allt viewern visar, i ett svar |
| `POST` | `/agentmemory/session/start` | Starta session + hämta kontext |
| `POST` | `/agentmemory/session/end` | Avsluta session |
| `POST` | `/agentmemory/observe` | Fånga in observation (se infångningsleverans nedan) |
| `GET` | `/agentmemory/capture` | Infångningsinkorg, dödbrev och offline-spool |
| `POST` | `/agentmemory/capture/retry` | Försök igen med dödbrevsinfångningar |
| `POST` | `/agentmemory/capture/drain` | Skicka den lokala offline-spoolen nu |
| `POST` | `/agentmemory/smart-search` | Hybridsökning |
| `POST` | `/agentmemory/context` | Generera kontext |
| `POST` | `/agentmemory/remember` | Spara till långtidsminnet |
| `POST` | `/agentmemory/forget` | Radera observationer |
| `POST` | `/agentmemory/enrich` | Filkontext + minnen + buggar |
| `GET` | `/agentmemory/profile` | Projektprofil |
| `GET` | `/agentmemory/export` | Exportera all data |
| `POST` | `/agentmemory/import` | Importera från JSON |
| `POST` | `/agentmemory/graph/query` | Fråga kunskapsgrafen |
| `POST` | `/agentmemory/graph/compact` | Trimma överdimensionerat grafursprung |
| `POST` | `/agentmemory/team/share` | Dela med team |
| `GET` | `/agentmemory/audit` | Granskningsspår |
Fullständig endpoint-lista: [REST API](../plugin/skills/agentmemory-rest-api/REFERENCE.md)
**Infångningsleverans.** Hooks skickar varje observation en gång till `POST /agentmemory/observe` med ett `eventId`. Det är värdens eget id för anropet när nyttolasten har ett (till exempel Claude Codes `tool_use_id`), annars en hash av sessionen, hook-typen, verktygsnamnet, indata, utdata och värdens tidsstämpel. Servern skriver händelsen till en infångningsinkorg i state-lagret, lagrar observationen, och tar sedan bort inkorgsposten. Statuskoden säger vad som hände:
| Status | `status`-fält | Betydelse |
|---|---|---|
| `201` | `accepted` | Lagrad. `observationId` är den nya observationen. |
| `202` | `accepted` (`state: "retrying"`) | Accepterad, men lagringen misslyckades. Servern försöker igen, även efter en omstart. |
| `200` | `duplicate` | Det här `eventId` hade redan accepterats. `observationId` är den befintliga observationen; ingenting nytt lagras. |
| `400` / `422` | `rejected` | Ogiltig nyttolast, eller lagringen misslyckades permanent (händelsen behålls som ett dödbrev). |
| `503` | `rejected` (`retryable: true`) | Inkorgen är full (`AGENTMEMORY_CAPTURE_INBOX_MAX`). Hooks lägger händelsen i kö och skickar den senare. |
Misslyckade händelser får nya försök var `AGENTMEMORY_CAPTURE_RETRY_INTERVAL_MS` (10 s) med dubblerande backoff, upp till `AGENTMEMORY_CAPTURE_MAX_ATTEMPTS` (5). Händelser som fortfarande misslyckas stannar i inkorgen som dödbrev, listas på `/agentmemory/status` och viewerns Health-sida, och kan försökas igen med `POST /agentmemory/capture/retry` (`{"eventId": "..."}` eller `{"all": true}`). Accepterade händelse-id:n minns i `AGENTMEMORY_CAPTURE_DEDUP_HOURS` (168 timmar, högst `AGENTMEMORY_CAPTURE_EVENTS_MAX` id:n), så en hook som spelas upp igen efter en timeout eller en omstart lagras en gång, medan två separata verktygsanrop med sina egna värd-id:n lagras två gånger även om deras innehåll är identiskt. När en observation raderas (forget, sessionsradering, utrensning, auto-glömning eller en import som ersätter lagret), markeras dess händelse som raderad innan observationen tas bort, så en uppspelning av den händelsen inom samma fönster besvaras som en dubblett och lagrar ingenting. State-lagret skriver till disk var 2 sekunder, så en besvarad händelse kan fortfarande bara finnas i minnet för ett ögonblick. För att täcka det bär varje `2xx`-svar också serverns `bootId` (ny vid varje start), `acceptedAt` och `durableAfterMs` (sparintervallet plus 1.5 s på fil-lagret, 1.5 s på redis, där varaktighet är operatörens inställning). Hooks behåller händelsen i den lokala spoolen tills det fönstret har passerat och raderar den vid ett senare anrop utan ytterligare en förfrågan. Om `bootId` har ändrats vid det laget startade servern om, så hooken skickar händelsen igen med samma `eventId`; en händelse som faktiskt nådde disken lagras inte två gånger. Servern skickar också sådana händelser själv vid start och vid varje återförsöksintervall, så en omstart förlorar ingenting även om ingen hook körs efteråt. Äldre hooks ignorerar de extra fälten, och nya hooks mot en äldre server kastar händelsen vid `2xx` som tidigare.
När servern är nere, inte svarar i tid eller returnerar en 5xx, lägger hooken till observationen i en lokal spool-fil, `/capture-spool/-.jsonl` (åsidosätt mappen med `AGENTMEMORY_CAPTURE_SPOOL_DIR`). Filen är privat för din användare (rättigheterna 600), hemligheter redigeras bort på samma sätt som servern gör det, den rymmer högst `AGENTMEMORY_CAPTURE_SPOOL_MAX_BYTES` (5 MiB) och tappar poster äldre än `AGENTMEMORY_CAPTURE_SPOOL_MAX_AGE_HOURS` (168). När den är full tappas nya poster och räknas, och `/agentmemory/status` rapporterar det. Hooken avslutas fortfarande med 0 inom sin tidsgräns och lägger inte till någon förfrågan när servern är frisk. Spoolen skickas vid nästa start och av den första hooken som når servern igen, i en bakgrundsprocess så att agenten inte väntar. Händelse-id:n gör detta säkert: en observation som faktiskt anlände innan en timeout lagras inte två gånger. `npx @agentmemory/agentmemory capture` visar spoolen och serverns inkorg, `--drain` skickar spoolen nu, och `GET /agentmemory/capture` returnerar samma sak som JSON. Sätt `AGENTMEMORY_CAPTURE_SPOOL=false` för att stänga av spoolen.
**Kompaktering av grafursprung.** Kompaktering av äldre ursprungsdata skjuts upp vid start eftersom den läser hela äldre scopes. `/agentmemory/status` visar `deferred`, eller `off` med `AGENTMEMORY_GRAPH_COMPACT_ON_BOOT=false`. Kör den manuella kompakteringen nedan under underhåll. Migrering av sökindexet är separat: använd `agentmemory graph-index migrate --allow-legacy-scan` enligt [underhållsguiden](../docs/reliability/graph-index-migration.md).
För att köra den för hand, anropa `POST /agentmemory/graph/compact`. Den går igenom namn- och kant-nyckel-indexen istället för att lista varje nod och kant, och är säker att köra igen. När den trimmar id:n skriver den en `graph_compact`-granskningspost.
```bash
curl -X POST http://localhost:3111/agentmemory/graph/compact -H "Authorization: Bearer " -H "Content-Type: application/json" -d '{}'
```
På ett stort lager, eller när anropet returnerar 504, kör den i skivor. Skicka `scope` (`nodes`, `edges` eller `history`), `offset` och `limit`, och anropa sedan igen med det returnerade `nextOffset` tills det är `null`. Gör detta för `nodes`, `edges` och `history`, och avsluta med ett `{"scope":"snapshot"}`-anrop, eftersom en skivad körning inte rör den cachade snapshoten.
```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)
```
[Install](#install) · [CONTRIBUTING.md](../CONTRIBUTING.md)