Varig hukommelse på tvers av kodeøkter og agenter.
Persistent hukommelse for Claude Code, GitHub Copilot CLI, Cursor, Gemini CLI, Codex CLI, Hermes, OpenClaw, pi, Oh My Pi, DeepSeek Harness, OpenCode, og enhver MCP-klient.
---
AgentMemory registrerer kodeøkter og gjør beslutninger, rettelser og erfaringer søkbare. Del ett lager mellom agenter, se gjennom lagret innhold og velg hvor mye kontekst modellen mottar.
## Install
Krav:
- Node.js 20 eller nyere med npm og npx (`node -v`, `npm -v`, og `npx -v`).
- På macOS/Linux krever automatisk oppsett også `curl`, en POSIX-`sh` og `tar`.
- Bruk WSL2 på Windows, eller følg [oppsettet for native Windows](#windows).
Den kanoniske kommandoen for en fersk installasjon:
```bash
npx -y @agentmemory/agentmemory@latest
```
Velg agenter og en leverandør, eller bruk modus uten nøkkel. Oppsettet skriver konfigurasjonen, starter minneserveren og tilbyr en global installasjon av kommandoen `agentmemory`. `-y` godtar npm-spørsmålet; `@latest` velger gjeldende versjon. LLM-komprimering er valgfritt og krever en leverandør samt `AGENTMEMORY_AUTO_COMPRESS=true`.
Nøkkelfri modus deaktiverer vektor-embeddings. `memory_recall` (stien `mem::search`) bruker BM25, mens `memory_smart_search` også kan slå sammen strukturelle grafmatcher når grafdata allerede finnes. For gratis semantisk gjenkalling på enheten, sett `EMBEDDING_PROVIDER=local` i `~/.agentmemory/.env` og start på nytt. Den første embedding-forespørselen laster ned `Xenova/all-MiniLM-L6-v2`; etter den innledende modellnedlastingen kjører inferensen lokalt.
API-et er på `http://localhost:3111`, og viewer på `http://localhost:3113`. Begge lytter på loopback som standard. Konfigurasjonen ligger i `~/.agentmemory/.env`; se [datalagring](#data-storage) for plasseringer og separate instanser.
Deretter kan du bevise at gjenkalling fungerer og gi agenten din dens skills:
```bash
npx -y @agentmemory/agentmemory@latest demo # seed eksempelsesjoner + utløs gjenkalling
npx skills add rohitg00/agentmemory -y # 17 native skills slik at agenten din vet når den skal bruke hukommelsen
```
Nøkkelordsøkene bør gi treff i standard nøkkelfri modus via BM25. Demoens `database performance optimization`-søk er med vilje semantisk og kan returnere null treff før en embedding-leverandør er konfigurert.
Foretrekker du å la en kodeagent gjøre hele jobben? Gi den én instruksjon:
> Hent og følg instruksjonene på: https://raw.githubusercontent.com/rohitg00/agentmemory/main/INSTALL_FOR_AGENTS.md
Koble til en annen agent med `agentmemory connect `. Se [integrasjoner](#works-with-every-agent) og [daglige kommandoer](#everyday-commands).
Global installasjon / EACCES
```bash
npm install -g @agentmemory/agentmemory@latest
```
npx-kommandoen over er fortsatt den kanoniske veien for en fersk installasjon og unngår tillatelsesproblemer med den globale prefiksen.
npx serverer en gammel versjon
npx cacher per versjon. Tvinge den nyeste med `npx -y @agentmemory/agentmemory@latest`, eller tøm cachen én gang med `rm -rf ~/.npm/_npx` (macOS/Linux; på Windows, slett `%LOCALAPPDATA%\npm-cache\_npx`).
---
agentmemory fungerer med enhver agent som støtter hooks, MCP eller REST API. Alle agenter deler samme minneserver.
Oh My Pi native søk + registrering + skills + Valgfri MCP
Fungerer med enhver agent som snakker MCP eller HTTP. Én server, minner delt mellom alle.
---
### Datalagring
Minnene lagres som standard utenfor repoet:
| Plattform | Datamappe |
|---|---|
| macOS | `~/Library/Application Support/agentmemory` |
| Linux | `$XDG_DATA_HOME/agentmemory` / `~/.local/share/agentmemory` |
| Windows | `%APPDATA%\agentmemory` |
Instans 0 gjenbruker en eksisterende `./data/state_store.db`. Velg en annen plassering med `--data-dir ` eller `AGENTMEMORY_DATA_DIR`, og behold den ved omstart og oppgradering. `--instance 1` bruker undermappen `instance-1`, API-port `3211` og viewer-port `3213`. Se [lagring og sikkerhetskopiering](../docs/reliability/state-storage.md) for Redis og migrering.
```bash
agentmemory --data-dir ~/.agentmemory-projects/main
agentmemory --instance 1
```
Nyeste versjonsnotater: [CHANGELOG.md](../CHANGELOG.md).
---
Oppdaterte søkeresultater, definisjoner av måltall og trinn for reproduksjon:
[0.9.31 · 2026-10-28 · strict recall-all@5](../docs/benchmarks/2026-10-28-retrieval-evaluation.md) · [eval/README.md](../eval/README.md).
---
Oppdatert sammenligning av produkter og driftsalternativer med kilder:
[AgentMemory / Mem0 / Supermemory / Zep / Letta / Cognee / claude-mem](../benchmark/COMPARISON.md) · 2026-10-28.
---
### Prøv det på 30 sekunder
```bash
# Terminal 1: start serveren
npx -y @agentmemory/agentmemory@latest
# Terminal 2: seed eksempeldata og se gjenkalling i praksis
npx -y @agentmemory/agentmemory@latest demo
```
`demo` seeder 3 realistiske sesjoner (JWT-autentisering, N+1-spørringsfiks, rate limiting) og kjører søk mot dem. Nøkkelfrie installasjoner deaktiverer vektorer, så nøkkelordsøkene i `mem::search` bør gi treff via BM25, mens `database performance optimization` kan returnere null treff. `smart-search` kan i tillegg returnere strukturelle grafmatcher når grafdata finnes. For å få det semantiske søket til å finne N+1-fiksen via vektorer, sett `EMBEDDING_PROVIDER=local`, start på nytt, og vent til den første modellnedlastingen er fullført.
Åpne `http://localhost:3113` for å se hukommelsen bygges opp live.
### Validere en fersk installasjon og persistens ved omstart
Kontroller helse, viewer og status mens serveren kjører:
```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` viser servertilstanden og aktive leverandører og embeddings. Lagre et testminne, og kontroller søket:
```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}'
```
Kjør deretter `npx -y @agentmemory/agentmemory@latest stop`, start den kanoniske kommandoen på nytt i Terminal 1, vent på `/agentmemory/livez`, og gjenta søket. Proben må fortsatt returneres. Hvis du valgte en egendefinert `--data-dir`, bruk samme katalog ved omstarten.
### Daglige kommandoer
Installasjon og oppsett er beskrevet i [Install](#install) over (den første kjøringen leder deg gjennom det). Til daglig bruk:
```bash
agentmemory # start serveren
agentmemory stop # stopp den rent
agentmemory connect # koble til en annen agent
agentmemory doctor # interaktiv diagnostikk + forslag til fiks
agentmemory remove # avinstaller alt vi opprettet
```
### Sesjonsavspilling
Hver sesjon agentmemory registrerer kan spilles av på nytt. Åpne viewer, velg fanen **Replay**, og spol gjennom tidslinjen: prompter, verktøykall, verktøyresultater og svar vises som separate hendelser med spill/pause, hastighetskontroll (0.5x til 4x), og tastatursnarveier (mellomrom for å veksle, piltaster for å gå trinn for trinn).
For å hente inn eldre Claude Code JSONL-transkripsjoner:
```bash
# Importer alt under standard ~/.claude/projects
npx -y @agentmemory/agentmemory@latest import-jsonl
# Eller importer én enkelt fil
npx -y @agentmemory/agentmemory@latest import-jsonl ~/.claude/projects/-my-project/abc123.jsonl
```
Importerte sesjoner vises i Replay-velgeren side om side med native sesjoner. Hver importerte transkripsjon indekseres for søk, stemples med opprinnelseskanalen `import`, og bearbeides til en sesjonskrystall og læringspunkter.
> **Viktig hvis du bruker `import-jsonl` som din primære fangstvei:** Claude Codes `cleanupPeriodDays` (i `~/.claude/settings.json`, standard **30**) sletter automatisk JSONL-transkripsjoner eldre enn dette vinduet fra `~/.claude/projects/`. Hvis du installerer agentmemory ferskt på en Claude Code-historikk som er flere måneder gammel, er alt eldre enn 30 dager allerede borte før den første importen. Kjør enten `import-jsonl` via cron, sett `cleanupPeriodDays` høyere, eller koble til auto-fangst-hookene (standard installasjonsvei for plugin) slik at hver tur lander i agentmemory mens sesjonen er aktiv, og JSONL-ryddingen ikke lenger har betydning.
### Oppgradering / vedlikehold
Bruk vedlikeholdskommandoen når du med vilje vil oppdatere den lokale kjøretiden:
```bash
npx -y @agentmemory/agentmemory@latest upgrade
```
Kommandoen oppdaterer den lokale kjøretiden og kan oppdatere JavaScript-avhengigheter i gjeldende arbeidsområde. Ta sikkerhetskopi og les [oppgraderingsveiledningen](../docs/upgrades/iii-0.25.md) før du fortsetter.
### Claude Code (én blokk, lim den inn)
```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 uten plugin-installasjon (MCP-frittstående vei)
Hvis du kobler agentmemorys MCP-server direkte gjennom `~/.claude.json` (standardsti) i stedet for å bruke `/plugin install`, løser Claude Code aldri opp `${CLAUDE_PLUGIN_ROOT}`, og du må peke hook-skriptene til absolutte stier i `~/.claude/settings.json` (standardsti). Disse stiene bygger typisk inn agentmemory-versjonen (f.eks. `~/.codex/plugins/cache/agentmemory/agentmemory/0.9.22/scripts/…`), så neste oppgradering knekker stille hver hook.
Løsning:
```bash
agentmemory connect claude-code --with-hooks
```
Denne kommandoen konfigurerer MCP-serveren og fletter de medfølgende hookene inn i Claude Codes brukerkonfigurasjon. Hvis `CLAUDE_CONFIG_DIR` ikke er satt, er tom eller bare inneholder blanktegn, brukes `~/.claude.json` for MCP og `~/.claude/settings.json` for hooks. Andre mappeverdier brukes nøyaktig som angitt, inkludert innledende og avsluttende blanktegn. For en egendefinert mappe setter du `CLAUDE_CONFIG_DIR` til den samme ikke-tomme verdien for både denne kommandoen og Claude Code; filene blir da henholdsvis `$CLAUDE_CONFIG_DIR/.claude.json` og `$CLAUDE_CONFIG_DIR/settings.json`. Claude Code må motta verdien i oppstartsmiljøet sitt, selv om koblingen leser den fra AgentMemorys `.env`. Opprett den egendefinerte mappen før du kjører kommandoen; ellers hopper koblingen over Claude Code fordi det ikke blir oppdaget. Hvis verdien i skallet bare inneholder blanktegn, fjern `CLAUDE_CONFIG_DIR` fra miljøet før du starter Claude Code, slik at det også bruker standardprofilen. Bruk en absolutt sti. Relative stier tolkes fra arbeidsmappen, så begge kommandoene må kjøres fra samme mappe.
Hook-kommandoene bruker absolutte stier til den installerte pakkens medfølgende `plugin/`-mappe. Kjør kommandoen på nytt etter en oppgradering av agentmemory for å oppdatere stiene. Brukerens egne oppføringer i konfigurasjonsfilene beholdes; bare tidligere agentmemory-oppføringer erstattes. Det anbefales fortsatt å bruke `/plugin install`.
For eksterne eller beskyttede distribusjoner, start Claude Code med `AGENTMEMORY_URL` og `AGENTMEMORY_SECRET` satt. Pluginen sender begge verdiene videre til sin medfølgende MCP-server; når `AGENTMEMORY_URL` er tom, bruker MCP-shimmen `http://localhost:3111`.
### Codex CLI (Codex-plugin-plattformen)
```bash
# 1. start minneserveren i en separat terminal
npx -y @agentmemory/agentmemory@latest
# 2. registrer agentmemory-markedsplassen og installer pluginen
codex plugin marketplace add rohitg00/agentmemory
codex plugin add agentmemory@agentmemory
```
Codex-pluginen leveres fra samme `plugin/`-katalog som Claude Code-pluginen. Den registrerer:
- En medfølgende stdio MCP-bro til den kjørende daemonen, uten npm-nedlasting eller fallback-lager. Se [den lokale Codex-veiledningen](../docs/plugins/codex-local.md) for å teste en build som ennå ikke er utgitt.
- 6 livssyklus-hooks: `SessionStart`, `UserPromptSubmit`, `PreToolUse`, `PostToolUse`, `PreCompact`, `Stop`
- 9 skills som kan kalles: `/recall`, `/remember`, `/session-history`, `/forget`, `/recap`, `/handoff`, `/lesson`, `/commit-context`, `/commit-history`, pluss 8 referanseskills agenten laster ved behov (minnedisiplin, MCP-verktøy, REST API, konfigurasjon, agenter, hooks, arkitektur, og skill-forfatterveiledningen)
Codex' hook-motor injiserer `CLAUDE_PLUGIN_ROOT` inn i hook-underprosesser (ifølge [`codex-rs/hooks/src/engine/discovery.rs`](https://github.com/openai/codex/blob/main/codex-rs/hooks/src/engine/discovery.rs)), så de samme hook-skriptene fungerer på begge verter uten duplisering. Subagent-/SessionEnd-/Notification-/TaskCompleted-/PostToolUseFailure-hendelser er kun for Claude Code og registreres ikke for Codex.
#### Codex-hooks: tillit og kompatibilitet
Native plugin-hook-utsendelse er verifisert med Codex CLI 0.150.1. Stol på plugin-hooksene før du forventer fangst. Desktop-oppførselen avhenger av dens medfølgende kjøretid; kontroller `/hooks` og bekreft en fanget hendelse før du aktiverer en løsning.
Hvis verten din krever globale hooks, speil kommandoene inn i `~/.codex/hooks.json`. Når MCP allerede er tilkoblet, trenger den nåværende adapteren `--force` for å nå hook-installasjonen:
```bash
agentmemory connect codex --with-hooks --force
```
Dette slår sammen globale hooks og skriver om agentmemory MCP-oppføringen, og bevarer urelaterte oppføringer. Gå gjennom eventuelle egendefinerte agentmemory-endepunktinnstillinger før du bruker `--force`. Kjør på nytt etter oppgradering for å oppdatere skriptstiene. Aktiver enten native plugin-hooks eller globale kopier for å unngå duplisert fangst.
### GitHub Copilot CLI
For VS Code agent-modus, bruk [Copilot MCP- og auto-fangst-veiledningen](../docs/plugins/copilot.md#vs-code-copilot-local-agent-sessions). CLI-adapteren konfigurerer ikke VS Code.
```bash
# Kun MCP-tilkobling
agentmemory connect copilot-cli
# Alternativt, full hooks/skills-plugin fra GitHub-undermappen
copilot plugin install rohitg00/agentmemory:plugin
```
`agentmemory connect copilot-cli` slår sammen `mcpServers.agentmemory` inn i `~/.copilot/mcp-config.json` (eller `$COPILOT_HOME/mcp-config.json` når `COPILOT_HOME` er satt) og bevarer eksisterende servere. På native Windows er dette den eneste automatiserte `connect`-adapteren; konfigurer alle andre native Windows-agenter manuelt. WSL-`connect` er kun støttet når målagenten også er installert i samme WSL-miljø. Installer også pluginen når du vil ha hele hook-/skill-opplevelsen.
### Cursor
```bash
agentmemory connect cursor
```
Legg deretter til det native programtillegget fra en AgentMemory-utsjekking via **Settings → Plugins → Add marketplace**, og last vinduet på nytt. Tillegget gir livssyklusregistrering, prosjekttilknytning, skills og MCP. Aktiver enten tilleggets hooks eller manuelle hooks i `~/.cursor/hooks.json` for å unngå duplikater. [Cursor-veiledning](../integrations/cursor/).
### Pi, Oh My Pi, DeepSeek Harness
```bash
agentmemory connect pi --with-mcp
agentmemory connect omp --with-mcp
agentmemory connect dsh --with-hooks
```
Velg kommandoen for verten din. Pi og OMP installerer søk, registrering, offline-gjensending og 17 skills; `--with-mcp` legger til alle verktøyene. Kjør `/reload` i Pi eller start OMP på nytt, og kontroller `/agentmemory-status`. DSH installerer MCP og det medfølgende registreringstillegget; start DSH på nytt etterpå.
Pi støtter også den installerbare pakken `@agentmemory/pi`. [Pi-veiledningen](../integrations/pi/) beskriver lokal installasjon og tilgjengelighet på npm. Bruk én installasjonsmetode per vert.
[Pi](../integrations/pi/) · [Oh My Pi](../integrations/omp/) · [DSH](../docs/dsh.md)
OpenClaw (lim inn denne prompten)
```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`.
```
Full veiledning: [`integrations/openclaw/`](../integrations/openclaw/)
Hermes Agent (lim inn denne prompten)
```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.
```
Full veiledning: [`integrations/hermes/`](../integrations/hermes/)
### Andre agenter
Start minneserveren: `npx -y @agentmemory/agentmemory@latest`
#### Native skills via `npx skills add`
agentmemory leveres med 17 skills i Claude-Code-stilens `/SKILL.md`-format: 9 skills som kan kalles (`remember`, `recall`, `recap`, `handoff`, `forget`, `lesson`, `commit-context`, `commit-history`, `session-history`) og 8 referanseskills agenten laster ved behov (`memory-discipline`, `agentmemory-mcp-tools`, `agentmemory-rest-api`, `agentmemory-config`, `agentmemory-agents`, `agentmemory-hooks`, `agentmemory-architecture`, `write-agentmemory-skill`). Referanseskillene har datatabeller generert fra kildekoden, så de aldri går ut av synk. CLI-en [`skills`](https://npmjs.com/package/skills) fra vercel-labs installerer dem automatisk inn i den kallende agentens native skill-katalog over 50+ agenter (Claude Code, Cursor, Cline, Continue, Droid, Warp, Codex, Antigravity, Kiro, OpenCode, Goose, Roo, Trae, Windsurf, med flere):
```bash
npx skills add rohitg00/agentmemory -y # oppdager den kallende agenten automatisk
npx skills add rohitg00/agentmemory -y -a warp # uttrykkelig agent
npx skills add rohitg00/agentmemory -y -a '*' # installer til hver installerte agent
```
Dette er **utfyllende** til `agentmemory connect `:
- `agentmemory connect ` skriver vanligvis MCP-konfigurasjonen. Hermes, OpenClaw, Pi og Oh My Pi installerer sin native integrasjon og medfølgende skills som standard; MCP legges til med `--with-mcp`.
- `npx skills add rohitg00/agentmemory` installerer skills for agenter uten medfølgende native skills. Hopp over dette trinnet for Hermes, OpenClaw, Pi og Oh My Pi: koblingene deres installerer allerede disse skillsene.
For de få agentene skills-CLI-en ikke dekker ennå (Zed v1.3.x og eldre), legg de 17 SKILL.md-filene manuelt under agentens native skill-katalog; samme format fungerer overalt.
#### Standard MCP-blokk
agentmemory-oppføringen er **samme MCP-server-blokk** på tvers av alle verter som bruker `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å denne oppføringen sammen med det eksisterende `mcpServers`-objektet** i vertens konfigurasjonsfil; ikke erstatt filen. Hvis filen allerede har andre servere, legg til `agentmemory` ved siden av dem som en ny nøkkel inne i `mcpServers`. Hvis `mcpServers` mangler helt, lim inn blokken inne i `{ "mcpServers": { ... } }`. `${VAR}`-plassholderne arver `AGENTMEMORY_URL` / `AGENTMEMORY_SECRET` fra skallet når MCP-serveren starter; usatte variabler gir tomme strenger og shimmen faller tilbake til `http://localhost:3111`. Én tilkoblet oppføring dekker både lokale og eksterne (k8s / reverse-proxy) distribusjoner.
| Agent | Konfigurasjonsfil | Merknader |
|---|---|---|
| **Cursor (kun MCP)** | `~/.cursor/mcp.json` | Slå sammen inn i `mcpServers`, eller `agentmemory connect cursor`. Et direktelink med ett klikk er også tilgjengelig på nettsiden. |
| **Cursor (full plugin)** | `.cursor-plugin/` | Legg deretter til det native programtillegget fra en AgentMemory-utsjekking via **Settings → Plugins → Add marketplace**, og last vinduet på nytt. Tillegget gir livssyklusregistrering, prosjekttilknytning, skills og MCP. Aktiver enten tilleggets hooks eller manuelle hooks i `~/.cursor/hooks.json` for å unngå duplikater. [Cursor-veiledning](../integrations/cursor/). |
| **Claude Desktop** | `claude_desktop_config.json` (Application Support) | Slå sammen inn i `mcpServers`. Start Claude Desktop på nytt etter redigering. |
| **Cline / Roo Code / Kilo Code** | Clines MCP-innstillinger (Settings-UI → MCP Servers → Edit) | Samme `mcpServers`-blokk. |
| **Devin CLI (MCP + hooks)** | `~/.config/devin/config.json` | `agentmemory connect devin` slår sammen MCP-oppføringen; `--with-hooks` legger til seks native auto-fangst-hooks (SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Stop, SessionEnd) med Devins små bokstaver i verktøymatcherne. Verifiser med `devin mcp list` og `/hooks` inne i devin. |
| **Devin CLI (full plugin)** | `plugin/.devin-plugin/` | `devin plugins install ./plugin` fra et checkout registrerer alle 17 skills som `/agentmemory:`-slash-kommandoer pluss MCP-serveren. Devins plugin-hooks kan ikke utløse `SessionStart`/`SessionEnd`, så kombiner den med `connect devin --with-hooks` for full sesjonsfangst. |
| **Devin (sky)** | Settings → Connections → MCP servers | Legg til en egendefinert MCP (STDIO): kommando `npx`, argumenter `-y @agentmemory/mcp@latest`, miljøvariabel `AGENTMEMORY_URL` pekende på en nettverksnåbar agentmemory-distribusjon pluss `AGENTMEMORY_SECRET` (sky-sesjoner kan ikke nå localhost — se [`deploy/`](../deploy/)). Lagre hemmeligheten i Devin Secrets, og bruk deretter "Test listing tools" for å verifisere at alle 54 verktøyene vises. |
| **Gemini CLI** | `~/.gemini/settings.json` | `gemini mcp add agentmemory npx -y @agentmemory/mcp --scope user` (slås sammen automatisk). |
| **GitHub Copilot CLI (kun MCP)** | `~/.copilot/mcp-config.json` | `agentmemory connect copilot-cli` slår sammen `mcpServers.agentmemory`; Copilot plukker det opp ved neste oppstart eller `/mcp`. |
| **GitHub Copilot CLI (full plugin)** | Copilot plugin-installasjon | `copilot plugin install rohitg00/agentmemory:plugin` for pluginen fra GitHub-undermappen. |
| **OpenClaw** | OpenClaw MCP-konfigurasjon | Samme `mcpServers`-blokk. Dypere: `openclaw plugins install ./integrations/openclaw` tar over OpenClaws minneplass (bytter automatisk fra `memory-core`); sett `plugins.entries.agentmemory.hooks.allowConversationAccess=true`, ellers blokkeres turfangsten stille. Se [`integrations/openclaw`](../integrations/openclaw/). |
| **Codex CLI (kun MCP)** | `.codex/config.toml` | TOML-form: `codex mcp add agentmemory -- npx -y @agentmemory/mcp`, eller legg til `[mcp_servers.agentmemory]` manuelt. |
| **Codex CLI (full plugin)** | Codex plugin-markedsplass | `codex plugin marketplace add rohitg00/agentmemory` deretter `codex plugin add agentmemory@agentmemory`. Registrerer MCP + 6 livssyklus-hooks + 17 skills. Stol på hooks og bekreft fangst på verten din; se [Codex-oppsett og validering](../docs/plugins/codex-local.md). |
| **OpenCode (kun MCP)** | `opencode.json` | Annen form: toppnivå-nøkkelen `mcp`, kommando som array: `{"mcp": {"agentmemory": {"type": "local", "command": ["npx", "-y", "@agentmemory/mcp"], "enabled": true}}}`. |
| **OpenCode (full plugin)** | `plugin/opencode/` | 22 auto-fangst-hooks som dekker sesjonslivssyklus, meldinger, verktøy, feil. Prosjekttilskrivning er per sesjon, så én OpenCode-prosess som spenner over flere repoer registrerer hver sesjon under sitt eget prosjekt. To slash-kommandoer (`/recall`, `/remember`). Kopier `plugin/opencode/` inn i OpenCode-arbeidsområdet ditt og legg plugin-oppføringen til `opencode.json`. Se [`plugin/opencode/README.md`](../plugin/opencode/README.md) for hele hook-tabellen + gap-analysen. |
| **Pi / Oh My Pi** | `~/.pi/agent/` / `~/.omp/agent/` | native søk + 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` gir 6-hook-minneleverandøren (prefetch, turfangst, sesjonsslutt, pre-compress, MEMORY.md-speiling, systemprompt-blokk). Valider med `hermes plugins doctor` og `hermes memory status`. Se [`integrations/hermes`](../integrations/hermes/). |
| **Qwen Code** | `~/.qwen/settings.json` | `agentmemory connect qwen` skriver standard `mcpServers`-blokk. Hook-nyttelasten er feltkompatibel med Claude Code, så de eksisterende 12-hook-skriptene fungerer uten endring; koble dem til via `hooks`-delen i samme `settings.json`. |
| **Antigravity IDE / 2.0** | `~/.gemini/config/mcp_config.json` | `agentmemory connect antigravity --with-hooks` installerer MCP og fangst-hooks i den delte tilpasningskatalogen. Se [Antigravity-oppsett og begrensninger](../docs/plugins/antigravity.md). |
| **Antigravity CLI** (`agy`) | `~/.gemini/config/mcp_config.json` | `agentmemory connect antigravity-cli --with-hooks` bruker samme MCP- og hook-konfigurasjon som nåværende IDE-versjoner. Eksisterende installasjoner bør oppdateres med `--force`; se [oppgraderingsnotatene](../docs/plugins/antigravity.md). |
| **Kiro** | `~/.kiro/settings/mcp.json` | `agentmemory connect kiro` skriver brukernivå-konfigurasjonen. Arbeidsområde-overstyringer går i `.kiro/settings/mcp.json` ved siden av koden din. |
| **Warp** | `~/.warp/.mcp.json` | `agentmemory connect warp` skriver standard `mcpServers`-blokk. Warp oppdager også automatisk skills fra `.claude/skills/`; når Claude Code-pluginen er installert vises de 9 agentmemory-skillene (`remember`, `recall`, `recap`, `handoff`, `forget`, `lesson`, `commit-context`, `commit-history`, `session-history`) naturlig i Warps slash-kommando-palett. |
| **Cline (CLI)** | `~/.cline/data/settings/cline_mcp_settings.json` | `agentmemory connect cline` skriver standard `mcpServers`-blokk. VS Code-utvidelsesbrukere: lim inn samme blokk via Cline Settings → MCP Servers → Edit JSON. |
| **Continue.dev** | `~/.continue/config.yaml` (foretrukket) eller `config.json` (eldre) | `agentmemory connect continue` oppretter en manglende `config.yaml` eller endrer eksisterende `config.json`. Hvis YAML-filen finnes, vises blokken for `mcpServers:` slik at kommentarer og ankere bevares. Continue bruker et array, ikke et objekt. |
| **Zed** | `~/.config/zed/settings.json` | `agentmemory connect zed` skriver under `context_servers` (Zeds nøkkel, IKKE `mcpServers`). Eksterne MCP-servere kan kobles til via `{"url": "..."}` i stedet. |
| **Droid (Factory.ai)** | `~/.factory/mcp.json` | `agentmemory connect droid` skriver standard `mcpServers`-blokk. Prosjektavgrensede overstyringer går i `/.factory/mcp.json`. Send `--with-hooks` for native auto-fangst. |
| **DeepSeek Harness** | `$DSH_HOME/cordis.patch.yml` | `agentmemory connect dsh` aktiverer MCP-verktøy. Legg til `--with-hooks` for å laste det native registreringstillegget som følger med AgentMemory. Ingen separat tilleggspakke er nødvendig. [DSH](../docs/dsh.md). |
| **Goose** | Gooses MCP-innstillings-UI | Samme `mcpServers`-blokk; bruk `goose configure` → Add Extension → MCP. Direkte YAML-redigering ved `~/.config/goose/config.yaml` er støttet, men skjemaet bruker `extensions:` + `cmd` (ikke `mcpServers:` + `command`). |
| **Aider** | n/a | Bruk de [autentiserte REST-eksemplene](#validate-a-fresh-install-and-restart-persistence) for å lagre og søke etter minner fra skript. |
| **Støttede agenter** | Kun skills | `npx skills add rohitg00/agentmemory`; velg hvilke skills du vil installere, og hvilke agenter de skal installeres for. |
**Sandkasse-MCP-klienter** (Flatpak / Snap / restriktive containere) som ikke kan nå vertens `localhost`: sett også `"AGENTMEMORY_FORCE_PROXY": "1"` i `env`-blokken, og pek `AGENTMEMORY_URL` mot en rute sandkassen faktisk kan nå (f.eks. din LAN-IP).
### Programmatisk tilgang (Python / Rust / Node)
Bruk [REST-API-et](#api) fra ethvert språk eller [MCP-verktøyene](#mcp-server) fra en agent. REST bruker JSON og bearer-autentisering; se [eksemplet på lagring og søk](#validate-a-fresh-install-and-restart-persistence). [Python-eksemplene](../examples/python/) viser direkte integrasjon med kjøretiden.
### Fra kildekode
```bash
git clone https://github.com/rohitg00/agentmemory.git && cd agentmemory
npm install && npm run build && npm start
```
`npm start` starter samme lokale server som den installerte CLI-en. Kravene står under [Install](#install); API og viewer lytter på `127.0.0.1`.
### Windows
agentmemory kjører på Windows 10/11. WSL2 følger Linux-stien og kan installere den fastlåste engine-en automatisk. Native Windows krever at den fastlåste iii-engine v0.25.1-binærfilen installeres manuelt; last ned det tilsvarende arkivet fra [iii v0.25.1-utgivelsessiden](https://github.com/iii-hq/iii/releases/tag/iii%2Fv0.25.1), kontroller kontrollsummen og legg `iii.exe` på `PATH` (for eksempel `%USERPROFILE%\.local\bin\iii.exe`). CLI-en pakker ikke ut Windows-ZIP-filen automatisk.
Automatisert native Windows-MCP-tilkobling støtter bare `agentmemory connect copilot-cli`. For andre native Windows-agenter bruker du den manuelle MCP-blokken fra [Andre agenter](#other-agents). Kjør `connect` i WSL bare når målagenten er installert i det samme WSL-miljøet.
**Kun frittstående MCP (uten engine).** Hvis du bare trenger MCP-verktøy og ikke REST-API-et, viewer eller kjøretidstjenester:
```powershell
npx -y @agentmemory/agentmemory@latest mcp
# or
npx -y @agentmemory/mcp
```
Kjør `agentmemory doctor` eller start på nytt med `--verbose`. Bruk `--port ` eller `--instance ` hvis portene er opptatt. Se [oppgraderingsveiledningen](../docs/upgrades/iii-0.25.md) for kompatibilitet og gjenoppretting.
---
Deploy
Host tjenesten med Docker Compose eller malene nedenfor. Minner og legitimasjon ligger på `/data`-volumet. Ta sikkerhetskopi og gjenbruk volumet ved oppgraderinger. [Distribusjonsveiledningen](../deploy/README.md) dekker autentisering, nettverk, sikkerhetskopiering og migrering.
Renders knapp for ett-klikks-distribusjon krever `render.yaml` i repoets rot, som vi med vilje holder ren. Bruk Render Blueprint-flyten dokumentert i [`deploy/render/`](.././deploy/render/README.md) for å peke på den interne blueprinten manuelt.
Fullstendige oppsettsdetaljer (HMAC-fangst, SSH-tunnel for viewer, rotasjon, sikkerhetskopiering,
kostnadsgulv) finnes i [`deploy/`](.././deploy/README.md):
- [`deploy/fly`](.././deploy/fly/README.md): én enkelt maskin med
`auto_stop_machines = "stop"`; billigst når inaktiv.
- [`deploy/railway`](.././deploy/railway/README.md): Hobby-planen, fast
pris, volum i dashbordet.
- [`deploy/render`](.././deploy/render/README.md): Blueprint-flyt,
automatiske disk-snapshot på betalte planer.
- [`deploy/coolify`](.././deploy/coolify/README.md): selvhostet på din
egen VPS via [Coolify](https://coolify.io/self-hosted); samme Docker
Compose-stack, du eier verten og dataene.
REST bruker port `3111`; viewer bruker `3113`. Hold dem private eller beskytt dem med autentisering og TLS. Distribusjonsveiledningen forklarer nettverkstilgang og [migrering av eldre Docker-installasjoner](../deploy/README.md#migrating-from-the-legacy-cli-docker-mode).
---
Prosjektkunnskap spres mellom samtaler og instruksjonsfiler. AgentMemory gjør tidligere beslutninger, rettelser og erfaringer søkbare fra agenten du bruker nå.
```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.
```
### vs innebygd agenthukommelse
Hver AI-kodeagent leveres med innebygd hukommelse: Claude Code har `MEMORY.md`, Cursor har notisblokker, Cline har en minnebank. Disse fungerer som gule lapper. agentmemory er den søkbare databasen bak de gule lappene.
| | Innebygd (CLAUDE.md) | agentmemory |
|---|---|---|
| Vedlikehold | Manuelt vedlikeholdte instruksjoner | Indeksert økthistorikk og minner |
| Søk | Laster alt inn i konteksten | BM25 + vektor + graf (kun topp-K) |
| Tvers av agenter | Filer per agent | MCP + REST (hvilken som helst agent) |
| Koordinering | Ingen | Leaser, signaler, handlinger, rutiner |
| Observerbarhet | Les filer manuelt | Viewer i realtid på :3113 |
---
### Hukommelsespipeline
```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 hukommelseskonsolidering
Modellert etter hvordan menneskehjernen behandler hukommelse, inkludert konsolidering under søvn.
| Nivå | Hva | Analogi |
|------|------|---------|
| **Working (arbeid)** | Rå observasjoner fra verktøybruk | Korttidshukommelse |
| **Episodic (episodisk)** | Komprimerte sesjonsoppsummeringer | "Hva som skjedde" |
| **Semantic (semantisk)** | Uttrukne fakta og mønstre | "Hva jeg vet" |
| **Procedural (prosedyral)** | Arbeidsflyter og beslutningsmønstre | "Hvordan gjøre det" |
Minner forfaller over tid (Ebbinghaus-kurven). Ofte brukte minner styrkes. Utdaterte minner kastes automatisk. Motsetninger oppdages og løses.
### Hva som fanges opp
Tabellen beskriver Claude Codes hooks. Andre integrasjoner registrerer hendelsene verten tilbyr; se de enkelte veiledningene. Automatisk kontekstinnsetting via delte hooks aktiveres med `AGENTMEMORY_INJECT_CONTEXT=true`.
| Hook | Fanger |
|------|----------|
| `SessionStart` | Prosjektsti, sesjons-ID |
| `UserPromptSubmit` | Brukerprompter (personvernfiltrert) |
| `PreToolUse` | Filtilgangsmønstre + utvidet kontekst |
| `PostToolUse` | Verktøynavn, inndata, utdata |
| `PostToolUseFailure` | Feilkontekst |
| `PreCompact` | Injiserer hukommelse på nytt før komprimering |
| `SubagentStart/Stop` | Livssyklus for underagenter |
| `Stop` | Oppsummering ved sesjonsslutt |
| `SessionEnd` | Markør for fullført sesjon |
### Viktige egenskaper
| Egenskap | Beskrivelse |
|---|---|
| **Automatisk fangst** | Native integrasjoner registrerer støttede økt- og verktøyhendelser |
| **Semantisk søk** | BM25 + vektor + kunnskapsgraf med RRF-fusjon |
| **Hukommelsesevolusjon** | Versjonering, erstatning, relasjonsgrafer |
| **Hygiene ved gjenkalling** | Erstattede minneversjoner forlater søkeindeksene; versjonskjeden i KV beholder full historikk |
| **Hint om nær-duplikater** | Lagringer rapporterer et rådgivende `similarTo`-treff når nytt innhold ligner mye på et eksisterende minne |
| **Avgrensning per agent** | `agentId` flyter gjennom lagring og gjenkalling over REST, MCP, og søkeindeksen, i delt eller isolert modus |
| **Opprinnelse ved skrivetidspunkt** | Hver observasjon og hvert minne har en uforanderlig opprinnelseskanal (user, agent, tool, import, eller shared) stemplet ved fangst, lagring, og import |
| **Automatisk glemming** | TTL-utløp, oppdagelse av motsetninger, beskjæring etter viktighet |
| **Personvern først** | API-nøkler, hemmeligheter, ``-tagger fjernes før lagring |
| **Selvhelende** | Strømbryterkrets (circuit breaker), fallback-kjede for leverandører, helseovervåking |
| **Claude-bro** | Toveis synkronisering med MEMORY.md |
| **Kunnskapsgraf** | Entitetsuttrekk + BFS-traversering |
| **Teamhukommelse** | Navneromdelt delt + privat mellom teammedlemmer |
| **Siteringsopprinnelse** | Spor ethvert minne tilbake til kildeobservasjonene |
| **Git-snapshots** | Versjoner, tilbakerulling, og diff av minnetilstand |
---
Trippel-strøm-gjenfinning som kombinerer tre signaler:
| Strøm | Hva den gjør | Når |
|---|---|---|
| **BM25** | Stemmet nøkkelordmatching med synonymutvidelse | Alltid på |
| **Vektor** | Kosinus-likhet over tette embeddings | Embedding-leverandør konfigurert |
| **Graf** | Kunnskapsgraf-traversering via entitetsmatching | Entiteter oppdaget i søket |
Fusjonert med Reciprocal Rank Fusion (RRF, k=60) og sesjonsdiversifisert (maks 3 resultater per sesjon).
Når en vektorindeks er fylt, bruker `mem::search` (bak `memory_recall`) den hybride BM25 + vektor-rangereren. Uten embeddings bruker den BM25. `smart-search` kan i tillegg slå sammen strukturelle grafmatcher når grafdata finnes, også i nøkkelfri modus. Gjenkalling av læringspunkter kjører på en dedikert BM25-indeks i minnet i stedet for å skanne hele korpuset per søk. Erstattede minneversjoner er utelatt fra hver gjenkallingsvei; versjonskjeden beholder historikken deres.
[0.9.31: `AGENTMEMORY_VECTOR_BACKFILL=all` / `AGENTMEMORY_VECTOR_BACKFILL_MAX`](../docs/reliability/source-and-vector-recovery.md).
BM25 tokeniserer gresk, kyrillisk, hebraisk, arabisk, og aksentuert latin ut av boksen. For kinesiske/japanske/koreanske minner, installer de valgfrie segmenterne (`npm install @node-rs/jieba tiny-segmenter`) for å dele opp CJK-sekvenser i ord-nivå-tokens; uten dem faller agentmemory mykt tilbake til hele-sekvens-tokenisering og skriver et engangs-hint til stderr.
### Embedding-leverandører
Nøkkelfrie installasjoner deaktiverer vektor-embeddings: `mem::search` bruker BM25, mens `smart-search` også kan bruke eksisterende strukturelle grafdata. For å velge gratis semantiske embeddings på enheten, legg dette til i `~/.agentmemory/.env` og start agentmemory på nytt:
```env
EMBEDDING_PROVIDER=local
```
Den vanlige npm-installasjonen inkluderer den valgfrie `@huggingface/transformers`-kjøretiden. Den første embedding-forespørselen laster ned `Xenova/all-MiniLM-L6-v2`, så den trenger nettverkstilgang og kan ta lengre tid; senere inferens kjører på enheten. Eksterne leverandører oppdages automatisk fra sine nøkler med mindre `EMBEDDING_PROVIDER` overstyrer dem.
| Leverandør | Modell | Kostnad | Merknader |
|---|---|---|---|
| **Lokal (anbefalt opt-in)** | `all-MiniLM-L6-v2` | Gratis | [`EMBEDDING_PROVIDER=local`](../README.md#embedding-providers) |
| Gemini | `gemini-embedding-001` | Gratis nivå | 100+ språk, 768/1536/3072 dimensjoner (MRL), 2048-tokens inndata. Erstatter `text-embedding-004` ([avviklet, stengt 14. januar 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` | Betalt | Optimalisert for kode |
| Cohere | `embed-english-v3.0` | Gratis prøveperiode | Generell bruk |
| OpenRouter | Hvilken som helst modell | Varierer | Flermodell-proxy |
---
54 MCP-verktøy, 6 ressurser, 3 prompter, og 17 skills.
> **MCP-shim vs full server:** den publiserte `@agentmemory/mcp`-pakken er en tynn shim. Den eksponerer hele 54-verktøys-overflaten **kun når den kan nå en kjørende agentmemory-server** via `AGENTMEMORY_URL` (proxy-modus). Uten en nåbar server faller shimmen tilbake til et lokalt sett på 7 verktøy (`memory_save`, `memory_recall`, `memory_smart_search`, `memory_sessions`, `memory_export`, `memory_audit`, `memory_governance_delete`). Miljøvariabelen `AGENTMEMORY_TOOLS=core|all` er et flagg på *serversiden*; å sette den i shimmens `env`-blokk har ingen effekt. Hvis du bare ser 7 verktøy i Cursor / OpenCode / Gemini CLI, start `npx -y @agentmemory/agentmemory@latest` (eller koble til en selvhostet server) og sett `AGENTMEMORY_URL=http://localhost:3111`.
### 54 verktøy
Tre verktøyoverflater, fra minst til størst: `AGENTMEMORY_TOOLS=core` begrenser synligheten til 8 essensielle (`memory_save`, `memory_recall`, `memory_consolidate`, `memory_smart_search`, `memory_sessions`, `memory_diagnose`, `memory_lesson_save`, `memory_reflect`); grunnsettet nedenfor er registerets 14 grunnleggende verktøy; standarden (`AGENTMEMORY_TOOLS=all`) eksponerer alle 54.
Grunnverktøy (14)
| Verktøy | Beskrivelse |
|------|-------------|
| `memory_recall` | Søk i tidligere observasjoner |
| `memory_compress_file` | Komprimer markdown-filer og bevar strukturen |
| `memory_save` | Lagre en innsikt, beslutning, eller et mønster |
| `memory_file_history` | Tidligere observasjoner om spesifikke filer |
| `memory_patterns` | Oppdag gjentakende mønstre |
| `memory_sessions` | List opp nylige sesjoner |
| `memory_smart_search` | Hybrid semantisk + nøkkelordsøk |
| `memory_vision_search` | Søk i bildeobservasjoner |
| `memory_timeline` | Kronologiske observasjoner |
| `memory_profile` | Prosjektprofil (konsepter, filer, mønstre) |
| `memory_export` | Eksporter all minnedata |
| `memory_relations` | Spør relasjonsgrafen |
| `memory_commit_lookup` | Sesjoner bak en git-commit |
| `memory_commits` | Commits registrert for en sesjon |
Utvidede verktøy (54 totalt, standardoverflaten)
| Verktøy | Beskrivelse |
|------|-------------|
| `memory_patterns` | Oppdag gjentakende mønstre |
| `memory_timeline` | Kronologiske observasjoner |
| `memory_relations` | Spør relasjonsgrafen |
| `memory_graph_query` | Kunnskapsgraf-traversering |
| `memory_consolidate` | Kjør 4-nivås konsolidering |
| `memory_claude_bridge_sync` | Synkroniser med MEMORY.md |
| `memory_team_share` | Del med teammedlemmer |
| `memory_team_feed` | Nylig delte elementer |
| `memory_audit` | Revisjonsspor for operasjoner |
| `memory_governance_delete` | Slett med revisjonsspor |
| `memory_snapshot_create` | Git-versjonert snapshot |
| `memory_action_create` | Opprett arbeidselementer med avhengigheter |
| `memory_action_update` | Oppdater handlingsstatus |
| `memory_frontier` | Ublokkerte handlinger rangert etter prioritet |
| `memory_next` | Den enkelt viktigste neste handlingen |
| `memory_lease` | Eksklusive handlingsleaser (flere agenter) |
| `memory_routine_run` | Instansier arbeidsflyt-rutiner |
| `memory_signal_send` | Meldinger mellom agenter |
| `memory_signal_read` | Les meldinger med kvitteringer |
| `memory_checkpoint` | Eksterne tilstandsporter |
| `memory_mesh_sync` | P2P-synkronisering mellom instanser |
| `memory_sentinel_create` | Hendelsesdrevne overvåkere |
| `memory_sentinel_trigger` | Utløs sentinels eksternt |
| `memory_sketch_create` | Forbigående handlingsgrafer |
| `memory_sketch_promote` | Forfrem til permanent |
| `memory_crystallize` | Komprimer handlingskjeder |
| `memory_diagnose` | Helsekontroller |
| `memory_heal` | Fiks fastlåst tilstand automatisk |
| `memory_facet_tag` | Dimensjon:verdi-tagger |
| `memory_facet_query` | Spør etter fasett-tagger |
| `memory_verify` | Spor opprinnelse |
### 6 ressurser · 3 prompter · 17 skills
| Type | Navn | Beskrivelse |
|------|------|-------------|
| Ressurs | `agentmemory://status` | Helse, sesjonsantall, minneantall |
| Ressurs | `agentmemory://project/{name}/profile` | Prosjektspesifikk intelligens |
| Ressurs | `agentmemory://project/{name}/recent` | Nylige observasjoner for et prosjekt |
| Ressurs | `agentmemory://memories/latest` | De siste 10 aktive minnene |
| Ressurs | `agentmemory://graph/stats` | Kunnskapsgraf-statistikk |
| Ressurs | `agentmemory://team/{id}/profile` | Delt teamprofil |
| Prompt | `recall_context` | Søk + returner kontekstmeldinger |
| Prompt | `session_handoff` | Overleveringsdata mellom agenter |
| Prompt | `detect_patterns` | Analyser gjentakende mønstre |
| Skill | `/recall` | Søk i hukommelsen |
| Skill | `/remember` | Lagre til langtidshukommelse |
| Skill | `/session-history` | Nylige sesjonsoppsummeringer |
| Skill | `/forget` | Slett observasjoner/sesjoner |
Tabellen viser de fire kjerne-skillene. Hele settet er 9 skills som kan kalles, pluss 8 referanseskills; se avsnittet om native skills over.
### Frittstående MCP
Kjør uten hele serveren, for en hvilken som helst MCP-klient. Begge disse fungerer:
```bash
npx -y @agentmemory/agentmemory@latest mcp # canonical (always available)
npx -y @agentmemory/mcp # shim package alias
```
Eller legg til i agentens MCP-konfigurasjon:
De fleste 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å sammen `agentmemory`-oppføringen inn i vertens eksisterende `mcpServers`-objekt i stedet for å erstatte filen. For sandkasse-klienter som ikke kan nå vertens `localhost`, legg til `"AGENTMEMORY_FORCE_PROXY": "1"` i `env`-blokken og sett `AGENTMEMORY_URL` til en rute sandkassen kan nå.
OpenCode (`opencode.json`):
```json
{
"mcp": {
"agentmemory": {
"type": "local",
"command": ["npx", "-y", "@agentmemory/mcp"],
"enabled": true
}
},
"plugin": ["./plugins/agentmemory-capture.ts"]
}
```
Kopier plugin-filen fra repoet:
```bash
mkdir -p ~/.config/opencode/plugins
cp plugin/opencode/agentmemory-capture.ts ~/.config/opencode/plugins/
cp plugin/opencode/commands/*.md ~/.config/opencode/commands/
```
---
Starter automatisk på port `3113`. Viewer laster ett snapshot når den kobler til (`GET /agentmemory/viewer/snapshot`) og bruker deretter SSE på `/agentmemory/viewer/events` via REST-workeren for live-hendelser: nye minner, læringspunkter, observasjoner, revisjonsoppføringer, grafendringer og helseoppdateringer vises uten polling eller sideoppdateringer. De eneste andre forespørslene er handlingene du klikker på, "load more"-sider og søk. Når strømmen faller ut, viser viewer hvor gamle tallene er, kobler til igjen med backoff og synkroniserer på nytt fra ett snapshot.
- **12 faner i fire grupper** med live antall, dype lenker (`#memories/`, `#sessions/?obs=`, `#graph/`, `#health/consolidation`), tastatursnarveier, og en mobilmeny.
- **Memories:** server-side søk, filtre etter prosjekt, agent, og type, et detaljpanel med versjonskjeden og en orddiff, opprinnelseslenker, kopieringsknapper for id-en, MCP-kallet, og en curl-kommando, rediger (en ny versjon), glem med bekreftelse, bulk-glemming, og JSON-eksport.
- **Sessions:** en innebygd observasjonstidslinje med lesbar verktøyinndata og -utdata, filtre og paginering, og minnene og læringspunktene hver sesjon produserte.
- **Graph:** søk, nodedetaljer med relasjoner og kilder, en legende som ikke er avhengig av farge alene, og zoomkontroller.
- **Health:** liveversjonen av `GET /agentmemory/status`. Hvert problem kommer med sin fiks, pluss state-backend, indekslagringsstatus, fremdrift for komprimering av grafopprinnelse, og en konsolideringsforklaring med de reelle tersklene.
- **Audit, Activity, Profile, Replay, Lessons, Actions og Crystals**-sider, hver med en tom tilstand som sier hva avsnittet er, hvorfor det er tomt, og kommandoen som fyller det, og et `?`-ordlistetips på hvert begrep og tall.
```bash
open http://localhost:3113
```
Viewer-serveren bindes til `127.0.0.1` som standard og legger på serverhemmeligheten når den videresender forespørsler til REST-API-en. Ved en binding som ikke er loopback, er HTML-skallet offentlig, men hver proxyforespørsel krever bearer-token; viewer ber om det og lagrer det i session storage. Konfigurer uttrykkelige verts-/opprinnelsestillatelser og TLS før du eksponerer viewer. REST-endepunktet `/agentmemory/viewer` følger de vanlige bearer-token-reglene og omdirigerer nettlesere uten token til viewer-porten. CSP-headere bruker en nonce per svar og deaktiverer inline-håndteringsattributter (`script-src-attr 'none'`).
---
### LLM-leverandører
agentmemory oppdager leverandører automatisk fra miljøet ditt. En leverandør gjør LLM-baserte operasjoner tilgjengelige, men leverandørkonfigurasjon alene aktiverer ikke LLM-skrevet observasjonskomprimering. Denne stien krever både en leverandør og `AGENTMEMORY_AUTO_COMPRESS=true`.
| Leverandør | Konfigurasjon | Merknader |
|----------|--------|-------|
| **No-op (standard)** | Ingen konfigurasjon nødvendig | LLM-basert komprimering/oppsummering er deaktivert. Syntetisk komprimering og BM25-gjenkalling fungerer fortsatt. Se `AGENTMEMORY_ALLOW_AGENT_SDK` under hvis du tidligere brukte Claude-abonnement-fallbacken. |
| Anthropic API | `ANTHROPIC_API_KEY` | Fakturering per token |
| MiniMax | `MINIMAX_API_KEY` | Anthropic-kompatibel |
| Gemini | `GEMINI_API_KEY` | Aktiverer også embeddings |
| OpenRouter | `OPENROUTER_API_KEY` | Hvilken som helst modell |
| OpenAI API | `OPENAI_API_KEY` | Standard `gpt-5.6-luna`, overstyr 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=` | Alt som er OpenAI-API-kompatibelt. Null kostnad, kjører på egen maskinvare. Se [Lokale modeller](#local-models-ollama--lm-studio--vllm) under. |
| Claude-abonnement-fallback | `AGENTMEMORY_ALLOW_AGENT_SDK=true` | Kun opt-in. Starter `@anthropic-ai/claude-agent-sdk`-sesjoner; dette brukte å forårsake ubegrenset Stop-hook-rekursjon, så det er ikke lenger standard. |
### Lokale modeller (Ollama / LM Studio / vLLM)
agentmemory snakker med enhver OpenAI-API-kompatibel server, så alt som eksponerer `/v1/chat/completions` fungerer uten kodeendringer. Ingen betalte nøkler, ingen sky, ingen rate-grenser; kjører helt på din egen maskinvare.
**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`):
Åpne LM Studio → Local Server-fanen → Start Server. Velg en hvilken som helst chat-modell fra velgeren (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**: samme form. Pek `OPENAI_BASE_URL` mot hvilken URL serveren din eksponerer og sett `OPENAI_MODEL` til et navn serveren din vil godta.
**Modellvalg for hukommelsesarbeid**: komprimering og oppsummering er korte oppgaver (<2K tokens inn, <500 tokens ut) der en 7B instruct-modell er mer enn nok. Anbefalinger:
| Modell | Størrelse | Hvorfor |
|-------|------|-----|
| `qwen3:8b` | ~5.2 GB | Balansert standard på en 16 GB-maskin; sterk på uttrekk og verktøy-formet tekst |
| `qwen3:4b` | ~2.6 GB | Minste fornuftige alternativ; fint for komprimering, svakere for grafuttrekk |
| `qwen3-coder:30b` | ~19 GB | Beste lokale valg for kode-formede sesjoner (30B MoE, 3.3B aktive) på 24-32 GB maskinvare |
| `gpt-oss:20b` | ~14 GB | Sterk generell modell som får plass i 16 GB RAM |
| `deepseek-r1:8b` | ~5.2 GB | Resonnerings-distill; tregere men renere uttrekk |
Qwen 3-modeller tenker som standard og kan brenne hele tokenbudsjettet på resonnering før noe utdata. Sett `AGENTMEMORY_LLM_NOTHINK=1` for å legge til `/no_think` i grafuttrekk-promptene, og øk `MAX_TOKENS` (16384 fungerer) hvis uttrekkene kommer tomme tilbake.
Resonneringsmodeller (`o1`-stil med ``-blokker) kan returnere tomt `content` med et `reasoning`-felt din lokale server ikke nødvendigvis eksponerer. Hvis uttrekkene kommer tomme tilbake, bytt til en ikke-resonnerende modell først. Miljøvariabelen `OPENAI_REASONING_EFFORT=none` kan også deaktivere tenking på Ollama Cloud-tenkemodeller som speiler OpenAIs resonnerings-skjema.
Lokale embeddings leveres som en valgfri avhengighet, men er ikke aktivert som standard. Sett `EMBEDDING_PROVIDER=local` for å velge `Xenova/all-MiniLM-L6-v2` (384 dimensjoner). Den første embedding-forespørselen laster ned modellen; inferens kjører på enheten etterpå. Uten denne innstillingen eller en ekstern embedding-nøkkel forblir vektorer deaktivert, `mem::search` bruker BM25, og `smart-search` kan fortsatt legge til eksisterende grafmatcher.
### Kostnadsbevisst modellvalg
Start uten nøkkel for registrering og nøkkelordsøk. `EMBEDDING_PROVIDER=local` aktiverer lokalt semantisk søk etter første modellnedlasting. LLM-komprimering krever en leverandør og `AGENTMEMORY_AUTO_COMPRESS=true`; den kan sende én forespørsel per observasjon. Kontroller gjeldende priser først. Viewer og `agentmemory status` viser aktive leverandører.
### Hukommelse for flere agenter (`AGENT_ID` + `AGENTMEMORY_AGENT_SCOPE`)
I oppsett med flere agenter der flere roller deler én agentmemory-server (arkitekt / utvikler / reviewer / forsker / support-agent), tagger `AGENT_ID` hver skriving med rollen som utførte den. `AGENTMEMORY_AGENT_SCOPE` styrer om gjenkalling filtrerer etter denne taggen.
```env
TEAM_ID=company
USER_ID=engineering-team
AGENT_ID=architect
AGENTMEMORY_AGENT_SCOPE=isolated # optional; default "shared"
```
To moduser:
| Modus | Tagger skriving | Filtrerer gjenkalling | Når brukes den |
|------|------------|---------------|-------------|
| `shared` (standard) | ja | nei | Kryss-agent-kontekst med revisjonsspor. Arkitekten kan se hva utvikleren noterte, men hver rad registrerer hvem som sa det. |
| `isolated` | ja | ja | Strikt separasjon. Arkitekten ser aldri utviklerens observasjoner/minner/sesjoner. |
Hva som tagges når `AGENT_ID` er satt: `Session.agentId`, `RawObservation.agentId`, `CompressedObservation.agentId`, `Memory.agentId`. Rollen flyter fra `api::session::start` → `mem::observe` → `mem::compress` → KV.
Hva som filtreres i isolert modus: `mem::smart-search`, `/agentmemory/memories`, `/agentmemory/observations`, `/agentmemory/sessions`. Hvert endepunkt godtar `?agentId=` for å overstyre per forespørsel, og `?agentId=*` for å gå ut av miljø-scopet helt. `/memories` godtar også `?includeOrphans=true` for å vise minner fra før AGENT_ID der `agentId` er udefinert.
Overstyring per kall på SDK-/REST-laget: hvert muterende endepunkt (`/session/start`, `/remember`) godtar et `agentId`-felt i forespørselskroppen som vinner over miljøvariabelen. Nyttig for kjøretider som ruter mange roller gjennom én serverprosess. MCP-verktøyet `memory_save` eksponerer samme `agentId`-felt, den frittstående stdio-serveren videresender både `agentId` og `project`, og lagrede minner bærer `agentId` inn i søkeindeksen, slik at agent-avgrenset søk dekker minner så vel som observasjoner.
Når `AGENT_ID` ikke er satt, forblir hukommelsen uten avgrensning (eldre oppførsel, ingen tagger, ingen filtre).
### Porter
| Port | Formål | Konfigurasjon |
|---|---|---|
| `3111` | REST API, MCP HTTP, SSE | `III_REST_PORT` |
| `3113` | Viewer UI | `III_VIEWER_PORT` |
`--port ` setter API-porten og som standard viewer til `N+2`. Bruk `--instance N` for en separat instans. Hold interne porter private; les [distribusjonsveiledningen](../deploy/README.md) før du tillater fjerntilgang.
### Lagringsbackend: filbasert (standard) vs Redis
Standardlageret bruker filer og krever ingen separat databasetjeneste. Redis er valgfritt med `AGENTMEMORY_STATE_BACKEND=redis` og `AGENTMEMORY_REDIS_URL`. Et backendbytte kopierer ikke minnene. Se [lagring og sikkerhetskopiering](../docs/reliability/state-storage.md) for persistens, Redis-begrensninger og autentisert eksport/import.
### Konfigurasjonsfil
Legg agentmemorys kjøretidskonfigurasjon i `~/.agentmemory/.env` i stedet for å eksportere variabler i hvert skall. Hvis viewer viser et oppsettshint som `export ANTHROPIC_API_KEY=...`, kopier det inn i denne filen som `ANTHROPIC_API_KEY=...` uten `export`-prefikset, og start deretter agentmemory på nytt. Sett `AGENTMEMORY_ENV_FILE` for å bruke en annen miljøfil.
Prosessens miljøvariabler har prioritet over filens verdier. Start serveren på nytt etter konfigurasjonsendringer.
På Windows ligger samme fil på `%USERPROFILE%\.agentmemory\.env`:
```powershell
New-Item -ItemType Directory -Force $HOME\.agentmemory
notepad $HOME\.agentmemory\.env
```
For å teste med et Claude Code Pro/Max-abonnement i stedet for en API-nøkkel, velg det inn uttrykkelig:
```env
AGENTMEMORY_ALLOW_AGENT_SDK=true
AGENTMEMORY_AUTO_COMPRESS=true
```
LLM-skrevet observasjonskomprimering krever begge linjene: tilgang til en LLM-leverandør (inkludert denne uttrykkelige abonnement-fallbacken) og `AGENTMEMORY_AUTO_COMPRESS=true`. En leverandør alene lar standard syntetisk komprimeringsvei stå på plass.
Konsolidering (grafnoder, læringspunkter, krystaller) er på som standard når en LLM-leverandør er konfigurert. Velg deg uttrykkelig ut med `CONSOLIDATION_ENABLED=false` hvis du vil ha LLM-fri drift. Grafuttrekk er et eget flagg:
```env
GRAPH_EXTRACTION_ENABLED=true
# CONSOLIDATION_ENABLED=false # opt out of auto-consolidation
```
### Miljøvariabler
Vanlige innstillinger for `~/.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 fullstendige referansen er [`.env.example`](../.env.example), med legitimasjon, registreringsfiltre, oppbevaring, lagring, teamavgrensning og tilvalg. `AGENTMEMORY_ENV_FILE` velger en annen fil. Ikke legg en utfylt `.env` eller en bearer-hemmelighet i git.
---
147 endepunkter på port `3111`. REST-API-en bindes til `127.0.0.1` som standard. Beskyttede endepunkter krever `Authorization: Bearer `, og mesh-synkroniseringsendepunkter krever en uttrykkelig satt `AGENTMEMORY_SECRET` på begge sider.
**Autentisering er på som standard.** Hvis `AGENTMEMORY_SECRET` verken er satt i skallet eller i `~/.agentmemory/.env`, oppretter CLI-en en tilfeldig hemmelighet ved første start i `~/.agentmemory/secret` og en kopi kalt `secret` i den valgte datamappen, med filmodus `0600`. Alle medfølgende klienter leser den derfra når de snakker med en lokal server: CLI-en, viewer, hookene under `plugin/scripts`, MCP-serveren og `@agentmemory/mcp`-shimmen, konfigurasjonene skrevet av `agentmemory connect` og de medfølgende OpenCode-, Pi-, OpenClaw-, Hermes- og filsystemovervåker-integrasjonene. Den lagrede hemmeligheten sendes bare til loopback-URL-er (`localhost`, `127.0.0.0/8`, `::1`). En uttrykkelig `AGENTMEMORY_SECRET` vinner alltid, og eksterne klienter trenger hemmeligheten i miljøet sitt. Docker-basert selvhosting fra repoet og `deploy/`-entrypointene genererer og eksporterer sin egen hemmelighet. Slik kaller du API-et manuelt:
```bash
curl -H "Authorization: Bearer " http://localhost:3111/agentmemory/health
```
**Forespørselsregler for skriving.** `POST`-, `PUT`-, `PATCH`-, og `DELETE`-forespørsler til REST-API-en og viewer må sende `Content-Type: application/json` (en `charset`-parameter er greit) når de har en kropp, og en `Origin`-header, når den er til stede, må være en loopback-opprinnelse for den konfigurerte REST- eller viewer-porten eller være listet i `VIEWER_ALLOWED_ORIGINS` (kommaseparert, f.eks. `https://memory.example.com`). Klienter som sender ingen `Origin`-header (CLI, hooks, MCP, curl, server-til-server) er ikke påvirket. Viewer godtar også sin egen opprinnelse.
**Filstier.** Endepunkter som leser eller skriver filer (`/compress-file`, `/replay/import-jsonl`, `/graph/import-graphify`) godtar bare stier under `~/.agentmemory`, instansens datakatalog, eller en katalog listet i `AGENTMEMORY_IMPORT_ROOT` (separer flere med `:`, eller `;` på Windows). `/replay/import-jsonl` godtar også sin standard `~/.claude/projects`. `/obsidian/export` holder seg innenfor `AGENTMEMORY_EXPORT_ROOT` og `/migrate` innenfor `~/.agentmemory`. Symlinker løses opp før hver kontroll.
**Fjerning av hemmeligheter.** API-nøkler, bearer-tokens, PEM-private-key-blokker, og credentials innebygd i URL-er (`scheme://user:password@host`) sladdes før tekst lagres, på hver skrivevei: observasjoner, remember, evolve, slots, læringspunkter, handlinger, sketches, signaler, checkpoints, imports, jsonl-avspilling, mesh-synkronisering, team-delinger, komprimerings- og oppsummeringsutdata, krystaller, og grafnoder.
Viktige endepunkter
| Metode | Sti | Beskrivelse |
|--------|------|-------------|
| `GET` | `/agentmemory/health` | Helsekontroll (alltid offentlig) |
| `GET` | `/agentmemory/status` | Hva er galt og hvordan fikse det (HTML for nettlesere, JSON ellers) |
| `GET` | `/agentmemory/viewer/snapshot` | Alt viewer viser, i én respons |
| `POST` | `/agentmemory/session/start` | Start sesjon + hent kontekst |
| `POST` | `/agentmemory/session/end` | Avslutt sesjon |
| `POST` | `/agentmemory/observe` | Fang observasjon (se fangstlevering under) |
| `GET` | `/agentmemory/capture` | Fangst-innboks, dead letters, og offline-kø |
| `POST` | `/agentmemory/capture/retry` | Prøv dead-letter-fangster på nytt |
| `POST` | `/agentmemory/capture/drain` | Send den lokale offline-køen nå |
| `POST` | `/agentmemory/smart-search` | Hybridsøk |
| `POST` | `/agentmemory/context` | Generer kontekst |
| `POST` | `/agentmemory/remember` | Lagre til langtidshukommelse |
| `POST` | `/agentmemory/forget` | Slett observasjoner |
| `POST` | `/agentmemory/enrich` | Filkontekst + minner + feil |
| `GET` | `/agentmemory/profile` | Prosjektprofil |
| `GET` | `/agentmemory/export` | Eksporter all data |
| `POST` | `/agentmemory/import` | Importer fra JSON |
| `POST` | `/agentmemory/graph/query` | Kunnskapsgraf-spørring |
| `POST` | `/agentmemory/graph/compact` | Beskjær overdimensjonert grafopprinnelse |
| `POST` | `/agentmemory/team/share` | Del med team |
| `GET` | `/agentmemory/audit` | Revisjonsspor |
Full endepunktliste: [REST API](../plugin/skills/agentmemory-rest-api/REFERENCE.md)
**Fangstlevering.** Hooks sender hver observasjon én gang til `POST /agentmemory/observe` med en `eventId`. Dette er vertens egen id for kallet når nyttelasten har en (for eksempel Claude Codes `tool_use_id`), ellers en hash av sesjonen, hook-typen, verktøynavnet, inndata, utdata, og vert-tidsstempelet. Serveren skriver hendelsen til en fangst-innboks i state-lageret, lagrer observasjonen, og fjerner deretter innboks-oppføringen. Statuskoden sier hva som skjedde:
| Status | `status`-felt | Betydning |
|---|---|---|
| `201` | `accepted` | Lagret. `observationId` er den nye observasjonen. |
| `202` | `accepted` (`state: "retrying"`) | Akseptert, men lagring mislyktes. Serveren prøver på nytt, også etter en omstart. |
| `200` | `duplicate` | Denne `eventId`-en var allerede akseptert. `observationId` er den eksisterende observasjonen; ingenting nytt lagres. |
| `400` / `422` | `rejected` | Ugyldig nyttelast, eller lagring mislyktes permanent (hendelsen beholdes som et dead letter). |
| `503` | `rejected` (`retryable: true`) | Innboksen er full (`AGENTMEMORY_CAPTURE_INBOX_MAX`). Hooks mellomlagrer hendelsen og sender den senere. |
Mislykkede hendelser prøves på nytt hvert `AGENTMEMORY_CAPTURE_RETRY_INTERVAL_MS` (10 sek) med doblende backoff, opp til `AGENTMEMORY_CAPTURE_MAX_ATTEMPTS` (5). Hendelser som fortsatt mislykkes forblir i innboksen som dead letters, listes på `/agentmemory/status` og viewerens Health-side, og kan prøves på nytt med `POST /agentmemory/capture/retry` (`{"eventId": "..."}` eller `{"all": true}`). Aksepterte hendelses-ID-er huskes i `AGENTMEMORY_CAPTURE_DEDUP_HOURS` (168 timer, høyst `AGENTMEMORY_CAPTURE_EVENTS_MAX` ID-er), slik at en hook som spilles av igjen etter en timeout eller en omstart lagres én gang, mens to separate verktøykall med sine egne vert-ID-er lagres to ganger selv når innholdet deres er identisk. Når en observasjon slettes (forget, sesjonssletting, eviction, auto-forget, eller en import som erstatter lageret), markeres hendelsen som slettet før observasjonen fjernes, slik at en avspilling av den hendelsen innenfor samme vindu besvares som et duplikat og lagrer ingenting. State-lageret skriver til disk hvert 2. sekund, så et besvart event kan fortsatt bare være i minnet et øyeblikk. For å dekke dette bærer også hvert `2xx`-svar serverens `bootId` (ny ved hver oppstart), `acceptedAt`, og `durableAfterMs` (lagringsintervallet pluss 1.5 sek på filbasertet, 1.5 sek på redis, der persistens er operatørens innstilling). Hooks holder på hendelsen i den lokale mellomlagringen til dette vinduet er passert og sletter den ved et senere kall uten en ny forespørsel. Hvis `bootId` har endret seg da, har serveren startet på nytt, så hooken sender hendelsen på nytt med samme `eventId`; en hendelse som nådde disken lagres ikke to ganger. Serveren sender også slike hendelser selv ved oppstart og ved hvert retry-intervall, slik at en omstart ikke taper noe selv når ingen hook kjører etterpå. Eldre hooks ignorerer de ekstra feltene, og nye hooks mot en eldre server forkaster hendelsen ved `2xx` som før.
Når serveren er nede, ikke svarer i tide, eller returnerer en 5xx, legger hooken observasjonen til en lokal mellomlagringsfil, `/capture-spool/-.jsonl` (overstyr mappen med `AGENTMEMORY_CAPTURE_SPOOL_DIR`). Filen er privat for brukeren din (modus 600), hemmeligheter sladdes på samme måte som serveren sladder dem, den har plass til høyst `AGENTMEMORY_CAPTURE_SPOOL_MAX_BYTES` (5 MiB) og dropper oppføringer eldre enn `AGENTMEMORY_CAPTURE_SPOOL_MAX_AGE_HOURS` (168). Når den er full, droppes nye oppføringer og telles, og `/agentmemory/status` rapporterer det. Hooken avsluttes fortsatt med 0 innen tidsgrensen og legger ikke til noen forespørsel når serveren er sunn. Mellomlagringen sendes ved neste oppstart og av den første hooken som når serveren igjen, i en bakgrunnsprosess slik at agenten ikke venter. Hendelses-ID-er gjør dette trygt: en observasjon som faktisk ankom før en timeout lagres ikke to ganger. `npx @agentmemory/agentmemory capture` viser mellomlagringen og serverinnboksen, `--drain` sender mellomlagringen nå, og `GET /agentmemory/capture` returnerer samme som JSON. Sett `AGENTMEMORY_CAPTURE_SPOOL=false` for å skru av mellomlagringen.
**Komprimering av grafopprinnelse.** Komprimering av eldre opprinnelsesdata utsettes ved oppstart fordi den leser hele eldre scopes. `/agentmemory/status` viser `deferred`, eller `off` med `AGENTMEMORY_GRAPH_COMPACT_ON_BOOT=false`. Kjør den manuelle komprimeringen nedenfor under vedlikehold. Migrering av søkeindeksen er separat: bruk `agentmemory graph-index migrate --allow-legacy-scan` som beskrevet i [vedlikeholdsveiledningen](../docs/reliability/graph-index-migration.md).
For å kjøre den manuelt, kall `POST /agentmemory/graph/compact`. Den går gjennom navne- og kant-nøkkel-indeksene i stedet for å liste hver node og kant, og er trygg å kjøre på nytt. Når den beskjærer ID-er skriver den en `graph_compact`-revisjonsoppføring.
```bash
curl -X POST http://localhost:3111/agentmemory/graph/compact -H "Authorization: Bearer " -H "Content-Type: application/json" -d '{}'
```
På et stort lager, eller når kallet returnerer 504, kjør det i skiver. Send `scope` (`nodes`, `edges`, eller `history`), `offset`, og `limit`, og kall deretter på nytt med den returnerte `nextOffset` til den er `null`. Gjør dette for `nodes`, `edges`, og `history`, og avslutt med ett `{"scope":"snapshot"}`-kall, fordi en skivet kjøring ikke berører den bufrede 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)