agentmemory: persistent hukommelse til AI-kodeagenter

Vedvarende hukommelse på tværs af kodningssessioner og agenter.
Persistent hukommelse til Claude Code, GitHub Copilot CLI, Cursor, Gemini CLI, Codex CLI, Hermes, OpenClaw, pi, Oh My Pi, DeepSeek Harness, OpenCode og enhver MCP-klient.

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

rohitg00/agentmemory | Trendshift

Designdokument: 1.7k stjerner / 240 forks på gist'en

Gisten udvider Karpathys LLM Wiki-mønster med konfidensscoring, livscyklus, videngrafer og hybrid søgning: agentmemory er implementeringen.

npm-version CI Licens Stjerner skills.sh installs

54 MCP-værktøjer 12 automatiske hooks 0 eksterne databaser 5,000+ beståede tests

agentmemory-demo

Installation • Hurtig start • Benchmarks • vs. konkurrenter • Agenter • Hvordan det virker • MCP • Viewer • Konfiguration • API

--- AgentMemory registrerer kodningssessioner og gør beslutninger, rettelser og erfaringer søgbare. Del ét lager mellem agenter, undersøg det gemte indhold, og vælg, hvor meget kontekst modellen modtager. ## Installation Krav: - Node.js 20 eller nyere med npm og npx (`node -v`, `npm -v` og `npx -v`). - På macOS/Linux kræver automatisk opsætning også `curl`, en POSIX-`sh` og `tar`. - Brug WSL2 på Windows, eller følg [opsætningen til native Windows](#windows). Den kanoniske kommando til en ny installation: ```bash npx -y @agentmemory/agentmemory@latest ``` Vælg dine agenter og en udbyder, eller brug tilstanden uden nøgle. Opsætningen skriver konfigurationen, starter hukommelsesserveren og tilbyder en global installation af kommandoen `agentmemory`. `-y` accepterer npm-prompten; `@latest` vælger den aktuelle version. LLM-komprimering er valgfri og kræver en udbyder samt `AGENTMEMORY_AUTO_COMPRESS=true`. Nøgleløs tilstand deaktiverer vektor-embeddings. `memory_recall` (stien `mem::search`) bruger BM25, mens `memory_smart_search` også kan kombinere strukturelle graf-match, når der allerede findes graf-data. For gratis semantisk recall på enheden, sæt `EMBEDDING_PROVIDER=local` i `~/.agentmemory/.env` og genstart. Den første embedding-forespørgsel downloader `Xenova/all-MiniLM-L6-v2`; herefter køres inferens lokalt. API'et findes på `http://localhost:3111`, og viewer på `http://localhost:3113`. Begge lytter som standard på loopback. Konfigurationen ligger i `~/.agentmemory/.env`; se [datalagring](#data-storage) for placeringer og separate instanser. Bevis derefter, at recall virker, og giv din agent dens 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 ``` Nøgleordssøgningerne bør give hit i standard nøgleløs tilstand via BM25. Demoens `database performance optimization`-forespørgsel er bevidst semantisk og kan give nul resultater, før en embedding-udbyder er konfigureret. Foretrækker du, at en kodeagent gør det hele selv? Giv den en enkelt instruktion: > Retrieve and follow the instructions at: https://raw.githubusercontent.com/rohitg00/agentmemory/main/INSTALL_FOR_AGENTS.md Tilslut en anden agent med `agentmemory connect `. Se [integrationer](#works-with-every-agent) og [daglige kommandoer](#everyday-commands).
Global installation / EACCES ```bash npm install -g @agentmemory/agentmemory@latest ``` npx-kommandoen ovenfor er stadig den kanoniske vej til en ny installation og undgår problemer med rettigheder til global-prefix.
npx leverer en gammel version npx cacher pr. version. Tving den nyeste med `npx -y @agentmemory/agentmemory@latest`, eller ryd cachen én gang med `rm -rf ~/.npm/_npx` (macOS/Linux; på Windows slettes `%LOCALAPPDATA%\npm-cache\_npx`).
---

Fungerer med alle agenter

agentmemory fungerer med enhver agent, der understøtter hooks, MCP eller REST API. Alle agenter deler den samme hukommelsesserver.
Claude Code
Claude Code
native plugin + 12 hooks + MCP
Codex CLI
Codex CLI
native plugin + 6 hooks + MCP
GitHub Copilot CLI
GitHub Copilot CLI
MCP + plugin hooks/skills
Cursor
Cursor
native plugin + lifecycle-hooks + MCP
OpenCode
OpenCode
capture plugin + MCP
Devin
Devin
6 hooks + skills + MCP
OpenClaw
OpenClaw
native plugin + MCP
Hermes
Hermes
native plugin + MCP
pi
pi
native søgning + registrering + skills
OpenHuman
OpenHuman
native Memory trait backend
Gemini CLI
Gemini CLI
MCP server
Antigravity
Antigravity
MCP + hooks
Claude Desktop
Claude Desktop
MCP server
Warp
Warp
connect + MCP + skills
Zed
Zed
MCP server
Cline
Cline
MCP server
Continue
Continue
MCP server
Droid
Droid
MCP server
Kiro
Kiro
MCP server
Qwen Code
Qwen Code
MCP server
DeepSeek Harness
DeepSeek Harness
native registrering + MCP
Roo Code
Roo Code
MCP server
Kilo Code
Kilo Code
MCP server
Goose
Goose
MCP server
Aider
Aider
REST API
Oh My Pi
native søgning + registrering + skills + Valgfri MCP

Fungerer med enhver agent, der taler MCP eller HTTP. Én server — hukommelse delt mellem dem alle.

--- ### Datalagring Hukommelsen gemmes som standard uden for dit repository: | Platform | Datamappe | |---|---| | macOS | `~/Library/Application Support/agentmemory` | | Linux | `$XDG_DATA_HOME/agentmemory` / `~/.local/share/agentmemory` | | Windows | `%APPDATA%\agentmemory` | Instans 0 genbruger en eksisterende `./data/state_store.db`. Vælg en anden placering med `--data-dir ` eller `AGENTMEMORY_DATA_DIR`, og behold den ved genstart og opgradering. `--instance 1` bruger undermappen `instance-1`, API-port `3211` og viewer-port `3213`. Se [lagring og backup](../docs/reliability/state-storage.md) for Redis og migrering. ```bash agentmemory --data-dir ~/.agentmemory-projects/main agentmemory --instance 1 ``` Seneste udgivelsesnoter: [CHANGELOG.md](../CHANGELOG.md). ---

Benchmarks

Aktuelle søgeresultater, definitioner af målinger og trin til gentagelse: [0.9.31 · 2026-10-28 · strict recall-all@5](../docs/benchmarks/2026-10-28-retrieval-evaluation.md) · [eval/README.md](../eval/README.md). ---

vs. konkurrenter

Opdateret sammenligning af produkter og driftsmuligheder med kilder: [AgentMemory / Mem0 / Supermemory / Zep / Letta / Cognee / claude-mem](../benchmark/COMPARISON.md) · 2026-10-28. ---

Hurtig start

### Prøv 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` seeder 3 realistiske sessioner (JWT-auth, N+1-forespørgselsfix, rate limiting) og kører søgninger mod dem. Nøgleløse installationer deaktiverer vektorer, så nøgleordsforespørgslerne via `mem::search` bør give hit via BM25, mens `database performance optimization` kan give nul resultater. `smart-search` kan desuden returnere strukturelle graf-match, når der findes graf-data. For at få den semantiske forespørgsel til at finde N+1-fixet via vektorer, sæt `EMBEDDING_PROVIDER=local`, genstart, og lad den første modeldownload færdiggøre. Åbn `http://localhost:3113` for at se hukommelsen bygges live. ### Validér en frisk installation og persistens ved genstart Kontrollér sundhed, viewer og status, mens serveren kø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 serverens tilstand og de aktive udbydere og embeddings. Gem en testhukommelse, og kontrollér søgningen: ```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 derefter `npx -y @agentmemory/agentmemory@latest stop`, start den kanoniske kommando igen i Terminal 1, vent på `/agentmemory/livez`, og gentag søgningen. Proben skal stadig returneres. Hvis du valgte en brugerdefineret `--data-dir`, så angiv samme mappe ved genstarten. ### Daglige kommandoer Installation og opsætning findes under [Install](#install) ovenfor (den første kørsel guider dig igennem det). Til dagligt brug: ```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 ``` ### Session-genafspilning Hver session, agentmemory optager, kan genafspilles. Åbn viewer, vælg fanen **Replay**, og spol gennem tidslinjen: prompts, tool calls, tool-resultater og svar vises som enkeltstående events med afspil/pause, hastighedskontrol (0.5x til 4x) og tastaturgenveje (space til at skifte afspil/pause, piletaster til at trinvist bevæge dig). For at importere ældre Claude Code JSONL-transskripter: ```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 ``` Importerede sessioner vises i Replay-vælgeren sammen med de native. Hvert importeret transskript indekseres til søgning, stemples med oprindelseskanalen `import`, og udvindes for en session-crystal og lessons. > **Vigtigt, hvis du afhænger af `import-jsonl` som din primære indsamlingsvej:** Claude Codes `cleanupPeriodDays` (i `~/.claude/settings.json`, standard **30**) sletter automatisk JSONL-transskripter, der er ældre end dette vindue, fra `~/.claude/projects/`. Hvis du installerer agentmemory helt nyt mod en måneder gammel Claude Code-historik, er alt ældre end 30 dage allerede væk, før den første import. Kør enten `import-jsonl` via en cron, hæv `cleanupPeriodDays` til noget højere, eller forbind auto-capture-hooks (standard-installationsvejen for pluginet), så hver tur lander i agentmemory, mens sessionen er aktiv, og JSONL-ryddet ikke længere betyder noget. ### Opgradering / vedligeholdelse Brug vedligeholdelseskommandoen, når du bevidst vil opdatere din lokale runtime: ```bash npx -y @agentmemory/agentmemory@latest upgrade ``` Kommandoen opdaterer den lokale runtime og kan opdatere JavaScript-afhængigheder i det aktuelle workspace. Tag en backup, og læs [opgraderingsvejledningen](../docs/upgrades/iii-0.25.md), før du fortsætter. ### Claude Code (én blok, indsæt den) ```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 uden plugin-installation (MCP-standalone-vej) Hvis du forbinder agentmemorys MCP-server via `~/.claude.json` (standardsti) direkte i stedet for at bruge `/plugin install`, opløser Claude Code aldrig `${CLAUDE_PLUGIN_ROOT}`, og du skal pege hook-scripts på absolutte paths i `~/.claude/settings.json` (standardsti). Disse paths indeholder typisk agentmemory-versionen (f.eks. `~/.codex/plugins/cache/agentmemory/agentmemory/0.9.22/scripts/…`), så den næste opgradering stille og roligt bryder hver hook. Løsning: ```bash agentmemory connect claude-code --with-hooks ``` Denne kommando konfigurerer MCP-serveren og fletter de medfølgende hooks ind i Claude Codes brugerkonfiguration. Hvis `CLAUDE_CONFIG_DIR` ikke er sat, er tom eller kun indeholder blanktegn, bruges `~/.claude.json` til MCP og `~/.claude/settings.json` til hooks. Andre mappeværdier bruges præcis som angivet, inklusive indledende og afsluttende blanktegn. Hvis du vil bruge en brugerdefineret mappe, skal `CLAUDE_CONFIG_DIR` have den samme ikke-tomme værdi for både denne kommando og Claude Code; filerne bliver da henholdsvis `$CLAUDE_CONFIG_DIR/.claude.json` og `$CLAUDE_CONFIG_DIR/settings.json`. Claude Code skal modtage værdien i sit startmiljø, selv hvis connectoren læser den fra AgentMemorys `.env`. Opret den brugerdefinerede mappe, før du kører kommandoen; ellers springer connectoren Claude Code over, fordi det ikke bliver fundet. Hvis værdien i shellen kun indeholder blanktegn, skal du fjerne `CLAUDE_CONFIG_DIR` fra miljøet, før du starter Claude Code, så det også bruger standardprofilen. Brug en absolut sti. Relative stier fortolkes ud fra arbejdsmappen, så begge kommandoer skal køres fra samme mappe. Hook-kommandoerne bruger absolutte stier til den installerede pakkes medfølgende `plugin/`-mappe. Kør kommandoen igen efter en opgradering af agentmemory for at opdatere stierne. Brugerens egne indgange i konfigurationsfilerne bevares; kun tidligere agentmemory-indgange erstattes. Det anbefales fortsat at bruge `/plugin install`. Til eksterne eller beskyttede deployments, start Claude Code med `AGENTMEMORY_URL` og `AGENTMEMORY_SECRET` sat. Pluginet sender begge værdier videre til sin medfølgende MCP-server; når `AGENTMEMORY_URL` er tom, bruger MCP-shimmen `http://localhost:3111`. ### Codex CLI (Codex-plugin-platform) ```bash # 1. start the memory server in a separate terminal npx -y @agentmemory/agentmemory@latest # 2. register the agentmemory marketplace and install the plugin codex plugin marketplace add rohitg00/agentmemory codex plugin add agentmemory@agentmemory ``` Codex-pluginet leveres fra samme `plugin/`-mappe som Claude Code-pluginet. Det registrerer: - En medfølgende stdio MCP-bridge til den kørende daemon, uden npm-download eller fallback-lager. Se [den lokale Codex-guide](../docs/plugins/codex-local.md) for at teste en build, der endnu ikke er udgivet. - 6 livscyklus-hooks: `SessionStart`, `UserPromptSubmit`, `PreToolUse`, `PostToolUse`, `PreCompact`, `Stop` - 9 kaldbare skills: `/recall`, `/remember`, `/session-history`, `/forget`, `/recap`, `/handoff`, `/lesson`, `/commit-context`, `/commit-history`, samt 8 referenceskills, som agenten indlæser efter behov (hukommelsesdisciplin, MCP-værktøjer, REST API, konfiguration, agenter, hooks, arkitektur og guiden til at skrive skills) Codex' hook-motor injicerer `CLAUDE_PLUGIN_ROOT` i hook-underprocesser (jf. [`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-scripts virker på begge hosts uden duplikering. Subagent-/SessionEnd-/Notification-/TaskCompleted-/PostToolUseFailure-events er kun til Claude Code og registreres ikke for Codex. #### Codex-hooks: tillid og kompatibilitet Native plugin-hook-afsendelse er verificeret med Codex CLI 0.150.1. Stol på plugin-hooks, før du forventer capture. Desktop-opførslen afhænger af dens medfølgende runtime; kontrollér `/hooks`, og bekræft en fanget hændelse, før du aktiverer en løsning. Hvis din host kræver globale hooks, så spejl kommandoerne ind i `~/.codex/hooks.json`. Når MCP allerede er forbundet, skal den nuværende adapter bruge `--force` for at nå hook-installationen: ```bash agentmemory connect codex --with-hooks --force ``` Dette sammenføjer globale hooks og omskriver agentmemory MCP-indgangen, og bevarer ikke-relaterede indgange. Gennemgå eventuelle tilpassede agentmemory endpoint-indstillinger, før du bruger `--force`. Kør igen efter opgradering for at opdatere scriptpaths. Aktivér enten native plugin-hooks eller globale kopier for at undgå duplikeret capture. ### GitHub Copilot CLI Til VS Code agent-tilstand, brug [Copilot MCP- og auto-capture-guiden](../docs/plugins/copilot.md#vs-code-copilot-local-agent-sessions). CLI-adapteren konfigurerer ikke 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` sammenføjer `mcpServers.agentmemory` ind i `~/.copilot/mcp-config.json` (eller `$COPILOT_HOME/mcp-config.json`, når `COPILOT_HOME` er sat) og bevarer eksisterende servere. På native Windows er dette den eneste automatiserede `connect`-adapter; konfigurér alle andre native Windows-agenter manuelt. WSL `connect` understøttes kun, når målagenten er installeret i samme WSL-miljø. Copilot opdager MCP-serveren ved næste opstart eller efter `/mcp`. Installér også pluginet, når du vil have den fulde hook-/skill-oplevelse. ### Cursor ```bash agentmemory connect cursor ``` Tilføj derefter det native plugin fra en AgentMemory-checkout via **Settings → Plugins → Add marketplace**, og genindlæs vinduet. Pluginet giver lifecycle-registrering, projekttilknytning, skills og MCP. Aktivér enten pluginets hooks eller manuelle hooks i `~/.cursor/hooks.json` for at undgå dobbelt registrering. [Cursor-vejledning](../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ælg kommandoen til din host. Pi og OMP installerer søgning, registrering, offline-gensendelse og 17 skills; `--with-mcp` tilføjer alle værktøjer. Kør `/reload` i Pi, eller genstart OMP, og kontrollér `/agentmemory-status`. DSH installerer MCP og det medfølgende registreringsplugin; genstart DSH bagefter. Pi understøtter også pakken `@agentmemory/pi`. [Pi-vejledningen](../integrations/pi/) beskriver lokal installation og tilgængelighed på npm. Brug én installationsmetode pr. host. [Pi](../integrations/pi/) · [Oh My Pi](../integrations/omp/) · [DSH](../docs/dsh.md)
OpenClaw (indsæt denne 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`. ``` Fuld guide: [`integrations/openclaw/`](../integrations/openclaw/)
Hermes Agent (indsæt denne 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. ``` Fuld guide: [`integrations/hermes/`](../integrations/hermes/)
### Andre agenter Start hukommelsesserveren: `npx -y @agentmemory/agentmemory@latest` #### Native skills via `npx skills add` agentmemory leveres med 17 skills i Claude-Code-stilens `/SKILL.md`-format: 9 kaldbare action-skills (`remember`, `recall`, `recap`, `handoff`, `forget`, `lesson`, `commit-context`, `commit-history`, `session-history`) og 8 referenceskills, som agenten indlæser efter behov (`memory-discipline`, `agentmemory-mcp-tools`, `agentmemory-rest-api`, `agentmemory-config`, `agentmemory-agents`, `agentmemory-hooks`, `agentmemory-architecture`, `write-agentmemory-skill`). Referenceskillene indeholder datatabeller genereret fra kildekoden, så de aldrig driver ud af kurs. [`skills`](https://npmjs.com/package/skills)-CLI'en fra vercel-labs installerer dem automatisk i den kaldende agents native skill-mappe på tværs af 50+ agenter (Claude Code, Cursor, Cline, Continue, Droid, Warp, Codex, Antigravity, Kiro, OpenCode, Goose, Roo, Trae, Windsurf og flere): ```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 ``` Dette er et **supplement** til `agentmemory connect `: - `agentmemory connect ` skriver normalt MCP-konfigurationen. Hermes, OpenClaw, Pi og Oh My Pi installerer som standard deres native integration og medfølgende skills; MCP tilvælges med `--with-mcp`. - `npx skills add rohitg00/agentmemory` installerer skills til agenter uden medfølgende native skills. Spring dette trin over for Hermes, OpenClaw, Pi og Oh My Pi: deres connectorer installerer allerede disse skills. For de få agenter, som skills-CLI'en endnu ikke dækker (Zed v1.3.x og tidligere), skal du selv placere de 17 SKILL.md-filer i agentens native skill-mappe; det samme format fungerer alle steder. #### Standard MCP-blok agentmemory-indgangen er den **samme MCP-serverblok** på alle hosts, der bruger `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}" } } ``` **Sammenføj denne indgang i det eksisterende `mcpServers`-objekt** i hostens konfigurationsfil; udskift ikke filen. Hvis filen allerede har andre servere, så tilføj `agentmemory` ved siden af dem som endnu en nøgle inde i `mcpServers`. Hvis `mcpServers` helt mangler, så indsæt blokken inden i `{ "mcpServers": { ... } }`. `${VAR}`-pladsholderne overtager `AGENTMEMORY_URL` / `AGENTMEMORY_SECRET` fra shellen, når MCP-serveren starter; ikke-satte variabler giver tomme strenge, og shimmen falder tilbage til `http://localhost:3111`. Én forbundet indgang dækker både lokale og eksterne (k8s/reverse-proxy'ede) deployments. | Agent | Konfigurationsfil | Noter | |---|---|---| | **Cursor (kun MCP)** | `~/.cursor/mcp.json` | Sammenføj i `mcpServers`, eller brug `agentmemory connect cursor`. Et one-click deeplink er også tilgængeligt på hjemmesiden. | | **Cursor (fuldt plugin)** | `.cursor-plugin/` | Tilføj derefter det native plugin fra en AgentMemory-checkout via **Settings → Plugins → Add marketplace**, og genindlæs vinduet. Pluginet giver lifecycle-registrering, projekttilknytning, skills og MCP. Aktivér enten pluginets hooks eller manuelle hooks i `~/.cursor/hooks.json` for at undgå dobbelt registrering. [Cursor-vejledning](../integrations/cursor/). | | **Claude Desktop** | `claude_desktop_config.json` (Application Support) | Sammenføj i `mcpServers`. Genstart Claude Desktop efter redigering. | | **Cline / Roo Code / Kilo Code** | Cline MCP-indstillinger (Settings UI → MCP Servers → Edit) | Samme `mcpServers`-blok. | | **Devin CLI (MCP + hooks)** | `~/.config/devin/config.json` | `agentmemory connect devin` sammenføjer MCP-indgangen; `--with-hooks` tilføjer seks native auto-capture-hooks (SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Stop, SessionEnd) med Devins små bogstaver-tool-matchers. Bekræft med `devin mcp list` og `/hooks` inde i devin. | | **Devin CLI (fuldt plugin)** | `plugin/.devin-plugin/` | `devin plugins install ./plugin` fra en checkout registrerer alle 17 skills som `/agentmemory:`-slash-kommandoer plus MCP-serveren. Devins plugin-hooks kan ikke udløse `SessionStart`/`SessionEnd`, så kombinér det med `connect devin --with-hooks` for fuld sessionsindsamling. | | **Devin (cloud)** | Settings → Connections → MCP servers | Tilføj en custom MCP (STDIO): kommando `npx`, args `-y @agentmemory/mcp@latest`, env `AGENTMEMORY_URL`, der peger på en netværkstilgængelig agentmemory-deployment, plus `AGENTMEMORY_SECRET` (cloud-sessioner kan ikke nå localhost — se [`deploy/`](../deploy/)). Gem secreten i Devin Secrets, og brug derefter "Test listing tools" til at bekræfte, at alle 54 værktøjer vises. | | **Gemini CLI** | `~/.gemini/settings.json` | `gemini mcp add agentmemory npx -y @agentmemory/mcp --scope user` (sammenføjer automatisk). | | **GitHub Copilot CLI (kun MCP)** | `~/.copilot/mcp-config.json` | `agentmemory connect copilot-cli` sammenføjer `mcpServers.agentmemory`; Copilot opdager den ved næste opstart eller `/mcp`. | | **GitHub Copilot CLI (fuldt plugin)** | Copilot plugin-installation | `copilot plugin install rohitg00/agentmemory:plugin` for pluginet fra GitHub-undermappen. | | **OpenClaw** | OpenClaw MCP-konfiguration | Samme `mcpServers`-blok. Dybere integration: `openclaw plugins install ./integrations/openclaw` tager OpenClaws memory-slot (skifter automatisk fra `memory-core`); sæt `plugins.entries.agentmemory.hooks.allowConversationAccess=true`, ellers blokeres tur-indsamlingen stille og roligt. Se [`integrations/openclaw`](../integrations/openclaw/). | | **Codex CLI (kun MCP)** | `.codex/config.toml` | TOML-form: `codex mcp add agentmemory -- npx -y @agentmemory/mcp`, eller tilføj `[mcp_servers.agentmemory]` manuelt. | | **Codex CLI (fuldt plugin)** | Codex plugin marketplace | `codex plugin marketplace add rohitg00/agentmemory`, derefter `codex plugin add agentmemory@agentmemory`. Registrerer MCP + 6 livscyklus-hooks + 17 skills. Stol på hooks, og bekræft capture på din host; se [Codex-opsætning og validering](../docs/plugins/codex-local.md). | | **OpenCode (kun MCP)** | `opencode.json` | Anden form: en `mcp`-nøgle på topniveau, kommando som array: `{"mcp": {"agentmemory": {"type": "local", "command": ["npx", "-y", "@agentmemory/mcp"], "enabled": true}}}`. | | **OpenCode (fuldt plugin)** | `plugin/opencode/` | 22 auto-capture-hooks, der dækker sessionslivscyklus, beskeder, tools og fejl. Projekttilskrivning er pr. session, så én OpenCode-proces, der spænder over flere repositories, journalfører hver session under sit eget projekt. To slash-kommandoer (`/recall`, `/remember`). Kopiér `plugin/opencode/` ind i dit OpenCode-workspace, og tilføj plugin-indgangen til `opencode.json`. Se [`plugin/opencode/README.md`](../plugin/opencode/README.md) for den fulde hook-tabel + gap-analyse. | | **Pi / Oh My Pi** | `~/.pi/agent/` / `~/.omp/agent/` | native søgning + 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` giver den 6-hook hukommelsesprovider (prefetch, turindsamling, sessionsafslutning, pre-compress, MEMORY.md-spejling, system-prompt-blok). Validér med `hermes plugins doctor` og `hermes memory status`. Se [`integrations/hermes`](../integrations/hermes/). | | **Qwen Code** | `~/.qwen/settings.json` | `agentmemory connect qwen` skriver standard-`mcpServers`-blokken. Hook-payloaden er felt-kompatibel med Claude Code, så de eksisterende 12-hook-scripts fungerer uden ændringer; forbind dem via `hooks`-sektionen i samme `settings.json`. | | **Antigravity IDE / 2.0** | `~/.gemini/config/mcp_config.json` | `agentmemory connect antigravity --with-hooks` installerer MCP og capture-hooks i den delte tilpasningsmappe. Se [Antigravity-opsætning og begrænsninger](../docs/plugins/antigravity.md). | | **Antigravity CLI** (`agy`) | `~/.gemini/config/mcp_config.json` | `agentmemory connect antigravity-cli --with-hooks` bruger samme MCP- og hook-konfiguration som de nuværende IDE-versioner. Eksisterende installationer bør opdateres med `--force`; se [opgraderingsnoterne](../docs/plugins/antigravity.md). | | **Kiro** | `~/.kiro/settings/mcp.json` | `agentmemory connect kiro` skriver konfigurationen på brugerniveau. Workspace-overrides placeres i `.kiro/settings/mcp.json` ved siden af din kode. | | **Warp** | `~/.warp/.mcp.json` | `agentmemory connect warp` skriver standard-`mcpServers`-blokken. Warp opdager også automatisk skills fra `.claude/skills/`; når Claude Code-pluginet er installeret, vises de 9 agentmemory-skills (`remember`, `recall`, `recap`, `handoff`, `forget`, `lesson`, `commit-context`, `commit-history`, `session-history`) nativt i Warps slash-kommando-palette. | | **Cline (CLI)** | `~/.cline/data/settings/cline_mcp_settings.json` | `agentmemory connect cline` skriver standard-`mcpServers`-blokken. Brugere af VS Code-extensionen: indsæt samme blok via Cline Settings → MCP Servers → Edit JSON. | | **Continue.dev** | `~/.continue/config.yaml` (foretrukket) eller `config.json` (legacy) | `agentmemory connect continue` opretter en manglende `config.yaml` eller ændrer eksisterende `config.json`. Hvis YAML-filen findes, vises blokken til `mcpServers:`, så kommentarer og ankre bevares. Continue bruger et array, ikke et objekt. | | **Zed** | `~/.config/zed/settings.json` | `agentmemory connect zed` skriver under `context_servers` (Zeds nøgle, IKKE `mcpServers`). Eksterne MCP-servere kan i stedet forbindes via `{"url": "..."}`. | | **Droid (Factory.ai)** | `~/.factory/mcp.json` | `agentmemory connect droid` skriver standard-`mcpServers`-blokken. Projekt-scopede overrides placeres i `/.factory/mcp.json`. Angiv `--with-hooks` for native auto-capture. | | **DeepSeek Harness** | `$DSH_HOME/cordis.patch.yml` | `agentmemory connect dsh` aktiverer MCP-værktøjer. Tilføj `--with-hooks` for at indlæse det native registreringsplugin, der følger med AgentMemory. Ingen separat pluginpakke er nødvendig. [DSH](../docs/dsh.md). | | **Goose** | Goose MCP-indstillings-UI | Samme `mcpServers`-blok; brug `goose configure` → Add Extension → MCP. Direkte YAML-redigering i `~/.config/goose/config.yaml` understøttes, men skemaet bruger `extensions:` + `cmd` (ikke `mcpServers:` + `command`). | | **Aider** | n/a | Brug de [autentificerede REST-eksempler](#validate-a-fresh-install-and-restart-persistence) til at gemme og søge i hukommelsen fra scripts. | | **Understøttede agenter** | Kun skills | `npx skills add rohitg00/agentmemory`; vælg de skills og agenter, du vil installere dem til. | **Sandboxede MCP-klienter** (Flatpak/Snap/restriktive containere), der ikke kan nå hostens `localhost`: sæt også `"AGENTMEMORY_FORCE_PROXY": "1"` i `env`-blokken, og peg `AGENTMEMORY_URL` på en rute, sandboxen faktisk kan nå (f.eks. din LAN-IP). ### Programmatisk adgang (Python / Rust / Node) Brug [REST API'et](#api) fra ethvert sprog eller [MCP-værktøjerne](#mcp-server) fra en agent. REST bruger JSON og bearer-autentificering; se [eksemplet på lagring og søgning](#validate-a-fresh-install-and-restart-persistence). [Python-eksemplerne](../examples/python/) viser direkte runtime-integration. ### 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 installerede CLI. Kravene står under [Install](#install); API og viewer lytter på `127.0.0.1`. ### Windows agentmemory kører på Windows 10/11. WSL2 følger Linux-vejen og kan installere den fastlåste engine automatisk. Native Windows kræver, at den fastlåste iii-engine v0.25.1-binary installeres manuelt; download det tilsvarende arkiv fra [iii v0.25.1-udgivelsessiden](https://github.com/iii-hq/iii/releases/tag/iii%2Fv0.25.1), verificér checksum, og placér `iii.exe` på `PATH` (for eksempel `%USERPROFILE%\.local\bin\iii.exe`). CLI’en pakker ikke Windows-ZIP’en ud automatisk. Automatisk MCP-opsætning på native Windows understøtter kun `agentmemory connect copilot-cli`. Brug den manuelle MCP-blok fra [Andre agenter](#other-agents) til andre native Windows-agenter. Kør kun `connect` i WSL, hvis målagenten er installeret i samme WSL-miljø. **Kun standalone MCP (uden engine).** Hvis du kun har brug for MCP-værktøjerne og ikke REST API, viewer eller runtime-tjenester: ```powershell npx -y @agentmemory/agentmemory@latest mcp # or npx -y @agentmemory/mcp ``` Kør `agentmemory doctor`, eller genstart med `--verbose`. Brug `--port ` eller `--instance `, hvis portene er optaget. Se [opgraderingsvejledningen](../docs/upgrades/iii-0.25.md) for kompatibilitet og gendannelse. ---

Deployment

Host tjenesten med Docker Compose eller skabelonerne nedenfor. Hukommelse og legitimationsoplysninger ligger på `/data`-volumenet. Tag backup af det, og genbrug det ved opgradering. [Deployment-vejledningen](../deploy/README.md) beskriver autentificering, netværk, backup og migrering.

Deploy til fly.io Deploy til Railway

Renders one-click-deploy-knap kræver `render.yaml` i repositoryets rod, som vi med vilje holder ren. Brug Render Blueprint-flowet, dokumenteret i [`deploy/render/`](.././deploy/render/README.md), til manuelt at pege på blueprintet i repositoryet. Fulde opsætningsdetaljer (HMAC-capture, SSH-tunnel til viewer, rotation, backup, minimumsomkostninger) findes i [`deploy/`](.././deploy/README.md): - [`deploy/fly`](.././deploy/fly/README.md): én maskine med `auto_stop_machines = "stop"`; billigst i tomgang. - [`deploy/railway`](.././deploy/railway/README.md): fast pris på Hobby-planen, volume i dashboardet. - [`deploy/render`](.././deploy/render/README.md): Blueprint-flow, automatiske disk-snapshots 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 ejer hosten og dataene. REST bruger port `3111`; viewer bruger `3113`. Hold dem private, eller beskyt dem med autentificering og TLS. Deployment-vejledningen dækker netværksadgang og [migrering af ældre Docker-installationer](../deploy/README.md#migrating-from-the-legacy-cli-docker-mode). ---

Hvorfor agentmemory

Projektviden spredes mellem chats og instruktionsfiler. AgentMemory gør tidligere beslutninger, rettelser og erfaringer søgbare fra den agent, du bruger 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. ``` ### vs. indbygget agenthukommelse Hver AI-kodeagent leveres med indbygget hukommelse: Claude Code har `MEMORY.md`, Cursor har notepads, Cline har memory bank. Disse fungerer som gule post-it-sedler. agentmemory er den søgbare database bag post-it-sedlerne. | | Indbygget (CLAUDE.md) | agentmemory | |---|---|---| | Vedligeholdelse | Manuelt vedligeholdte instruktioner | Indekseret sessionshistorik og hukommelse | | Søgning | Indlæser alt i konteksten | BM25 + vektor + graf (kun top-K) | | Tværs af agenter | Filer pr. agent | MCP + REST (enhver agent) | | Koordinering | Ingen | Leases, signaler, actions, routines | | Observerbarhed | Læs filer manuelt | Realtids-viewer på :3113 | ---

Hvordan det virker

### 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-lags hukommelseskonsolidering Modelleret efter, hvordan menneskehjerner bearbejder hukommelse, inklusive søvnkonsolidering. | Lag | Hvad | Analogi | |------|------|---------| | **Arbejdshukommelse** | Rå observationer fra tool-brug | Korttidshukommelse | | **Episodisk** | Komprimerede sessionsopsummeringer | "Hvad der skete" | | **Semantisk** | Udtrukne fakta og mønstre | "Hvad jeg ved" | | **Procedurel** | Workflows og beslutningsmønstre | "Hvordan man gør det" | Hukommelser forfalder over tid (Ebbinghaus-kurven). Ofte tilgåede hukommelser styrkes. Forældede hukommelser smides automatisk ud. Modsætninger opdages og løses. ### Hvad der indsamles Tabellen beskriver Claude Codes hooks. Andre integrationer registrerer de hændelser, deres host tilbyder; se de enkelte vejledninger. Automatisk kontekstindsættelse via delte hooks aktiveres med `AGENTMEMORY_INJECT_CONTEXT=true`. | Hook | Indsamler | |------|----------| | `SessionStart` | Projektsti, session-ID | | `UserPromptSubmit` | Brugerprompts (privacy-filtreret) | | `PreToolUse` | Filtilgangsmønstre + beriget kontekst | | `PostToolUse` | Tool-navn, input, output | | `PostToolUseFailure` | Fejlkontekst | | `PreCompact` | Genindsætter hukommelse før compaction | | `SubagentStart/Stop` | Subagent-livscyklus | | `Stop` | Opsummering ved sessionsafslutning | | `SessionEnd` | Markør for afsluttet session | ### Vigtigste funktioner | Funktion | Beskrivelse | |---|---| | **Automatisk indsamling** | Native integrationer registrerer understøttede sessions- og værktøjshændelser | | **Semantisk søgning** | BM25 + vektor + videngraf med RRF-fusion | | **Hukommelsesudvikling** | Versionering, overskrivning (supersession), relationsgrafer | | **Recall-hygiejne** | Overskrevne hukommelsesversioner forsvinder fra søgeindeksene; versionskæden i KV bevarer den fulde historik | | **Hints om næsten-duplikater** | Gemninger rapporterer et vejledende `similarTo`-match, når nyt indhold ligner en eksisterende hukommelse | | **Scoping pr. agent** | `agentId` følger med gennem save og recall tværs af REST, MCP og søgeindekset, i delt eller isoleret tilstand | | **Herkomst ved skrivetidspunkt** | Hver observation og hukommelse bærer en uforanderlig oprindelseskanal (user, agent, tool, import eller shared), stemplet ved capture, save og import | | **Auto-forglemmelse** | TTL-udløb, modstridsdetektion, vigtighedsbaseret udsmidning | | **Privacy first** | API-nøgler, secrets, ``-tags fjernes før lagring | | **Selvhelende** | Circuit breaker, fallback-kæde for providere, health-overvågning | | **Claude-bridge** | Bidirektionel synkronisering med MEMORY.md | | **Videngraf** | Entitetsudtrækning + BFS-traversering | | **Team-hukommelse** | Namespaced delt + privat hukommelse mellem teammedlemmer | | **Citationsherkomst** | Spor enhver hukommelse tilbage til kildeobservationerne | | **Git-snapshots** | Versionér, rul tilbage og diff hukommelsestilstanden | --- Trestrøms-retrieval, der kombinerer tre signaler: | Strøm | Hvad den gør | Hvornår | |---|---|---| | **BM25** | Stemmet nøgleordsmatching med synonymudvidelse | Altid aktiv | | **Vektor** | Cosine-similaritet over dense embeddings | Embedding-udbyder konfigureret | | **Graf** | Videngraf-traversering via entitetsmatching | Entiteter opdaget i forespørgslen | Fusioneret med Reciprocal Rank Fusion (RRF, k=60) og session-diversificeret (maks. 3 resultater pr. session). Når et vektorindeks er udfyldt, bruger `mem::search` (bag `memory_recall`) den hybride BM25 + vektor-ranker. Uden embeddings bruger den BM25. `smart-search` kan desuden fusionere strukturelle graf-match, når der findes graf-data, også i nøgleløs tilstand. Lesson-recall køres på et dedikeret in-memory BM25-indeks i stedet for at scanne hele korpuset pr. forespørgsel. Overskrevne hukommelsesversioner udelukkes fra alle recall-veje; versionskæden bevarer deres historik. [0.9.31: `AGENTMEMORY_VECTOR_BACKFILL=all` / `AGENTMEMORY_VECTOR_BACKFILL_MAX`](../docs/reliability/source-and-vector-recovery.md). BM25 tokeniserer græsk, kyrillisk, hebraisk, arabisk og accentueret latin ud af boksen. For kinesiske/japanske/koreanske hukommelser skal du installere de valgfrie segmenterere (`npm install @node-rs/jieba tiny-segmenter`) for at splitte CJK-forløb i ord-niveau-tokens; uden dem falder agentmemory blidt tilbage til hel-forløb-tokenisering og printer et engangshint på stderr. ### Embedding-udbydere Nøgleløse installationer deaktiverer vektor-embeddings: `mem::search` bruger BM25, mens `smart-search` også kan bruge eksisterende strukturel graf-data. For at tilvælge gratis semantiske embeddings på enheden, tilføj dette til `~/.agentmemory/.env`, og genstart agentmemory: ```env EMBEDDING_PROVIDER=local ``` Den normale npm-installation inkluderer den valgfrie `@huggingface/transformers`-runtime. Den første embedding-forespørgsel downloader `Xenova/all-MiniLM-L6-v2`, så den kræver netværksadgang og kan tage længere tid; efterfølgende inferens køres på enheden. Eksterne udbydere opdages automatisk fra deres nøgler, med mindre `EMBEDDING_PROVIDER` overskriver dem. | Udbyder | Model | Pris | Noter | |---|---|---|---| | **Lokal (anbefalet tilvalg)** | `all-MiniLM-L6-v2` | Gratis | [`EMBEDDING_PROVIDER=local`](../README.md#embedding-providers) | | Gemini | `gemini-embedding-001` | Gratis niveau | 100+ sprog, 768/1536/3072 dimensioner (MRL), 2048-token input. Afløser `text-embedding-004` ([udfaset, lukket 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 | Optimeret til kode | | Cohere | `embed-english-v3.0` | Gratis prøveperiode | Generelt anvendelig | | OpenRouter | Enhver model | Varierer | Multi-model-proxy | ---

MCP-server

54 værktøjer, 6 ressourcer, 3 prompts og 17 skills. > **MCP-shim vs. fuld server:** den publicerede `@agentmemory/mcp`-pakke er en tynd shim. Den eksponerer den fulde overflade med 54 værktøjer **kun når den kan nå en kørende agentmemory-server** via `AGENTMEMORY_URL` (proxy-tilstand). Når ingen server kan nås, falder shimmen tilbage til et lokalt sæt på 7 værktøjer (`memory_save`, `memory_recall`, `memory_smart_search`, `memory_sessions`, `memory_export`, `memory_audit`, `memory_governance_delete`). Miljøvariablen `AGENTMEMORY_TOOLS=core|all` er et flag på *serversiden*; at sætte den i shimmens `env`-blok har ingen effekt. Hvis du kun ser 7 værktøjer i Cursor / OpenCode / Gemini CLI, så start `npx -y @agentmemory/agentmemory@latest` (eller Docker-stacken), og sæt `AGENTMEMORY_URL=http://localhost:3111`. ### 54 værktøjer Tre værktøjsoverflader, fra mindst til størst: `AGENTMEMORY_TOOLS=core` beskærer synligheden til 8 essentielle værktøjer (`memory_save`, `memory_recall`, `memory_consolidate`, `memory_smart_search`, `memory_sessions`, `memory_diagnose`, `memory_lesson_save`, `memory_reflect`); grundsættet nedenfor er registerets 14 fundamentale værktøjer; standarden (`AGENTMEMORY_TOOLS=all`) eksponerer alle 54.
Grundlæggende værktøjer (14) | Værktøj | Beskrivelse | |------|-------------| | `memory_recall` | Søg i tidligere observationer | | `memory_compress_file` | Komprimer markdown-filer, mens strukturen bevares | | `memory_save` | Gem en indsigt, beslutning eller et mønster | | `memory_file_history` | Tidligere observationer om specifikke filer | | `memory_patterns` | Opdag tilbagevendende mønstre | | `memory_sessions` | List de seneste sessioner | | `memory_smart_search` | Hybrid semantisk + nøgleordssøgning | | `memory_vision_search` | Søg i billedobservationer | | `memory_timeline` | Kronologiske observationer | | `memory_profile` | Projektprofil (koncepter, filer, mønstre) | | `memory_export` | Eksportér alle hukommelsesdata | | `memory_relations` | Forespørg relationsgrafen | | `memory_commit_lookup` | Sessioner bag et git-commit | | `memory_commits` | Commits registreret for en session |
Udvidede værktøjer (54 i alt, standardoverfladen) | Værktøj | Beskrivelse | |------|-------------| | `memory_patterns` | Opdag tilbagevendende mønstre | | `memory_timeline` | Kronologiske observationer | | `memory_relations` | Forespørg relationsgrafen | | `memory_graph_query` | Videngraf-traversering | | `memory_consolidate` | Kør 4-lags konsolidering | | `memory_claude_bridge_sync` | Synkronisér med MEMORY.md | | `memory_team_share` | Del med teammedlemmer | | `memory_team_feed` | Seneste delte elementer | | `memory_audit` | Audit trail for operationer | | `memory_governance_delete` | Slet med audit trail | | `memory_snapshot_create` | Git-versioneret snapshot | | `memory_action_create` | Opret arbejdselementer med afhængigheder | | `memory_action_update` | Opdatér action-status | | `memory_frontier` | Ublokerede actions rangeret efter prioritet | | `memory_next` | Den enkelte vigtigste næste action | | `memory_lease` | Eksklusive action-leases (multi-agent) | | `memory_routine_run` | Instantiér workflow-routines | | `memory_signal_send` | Besked mellem agenter | | `memory_signal_read` | Læs beskeder med kvitteringer | | `memory_checkpoint` | Eksterne betingelses-gates | | `memory_mesh_sync` | P2P-synkronisering mellem instanser | | `memory_sentinel_create` | Event-drevne watchers | | `memory_sentinel_trigger` | Udløs sentinels eksternt | | `memory_sketch_create` | Kortvarige action-grafer | | `memory_sketch_promote` | Forfrem til permanent | | `memory_crystallize` | Komprimér action-kæder | | `memory_diagnose` | Health-checks | | `memory_heal` | Auto-reparér fastlåst tilstand | | `memory_facet_tag` | Dimension:værdi-tags | | `memory_facet_query` | Forespørg via facet-tags | | `memory_verify` | Spor herkomst |
### 6 ressourcer · 3 prompts · 17 skills | Type | Navn | Beskrivelse | |------|------|-------------| | Ressource | `agentmemory://status` | Health, antal sessioner, antal hukommelser | | Ressource | `agentmemory://project/{name}/profile` | Intelligens pr. projekt | | Ressource | `agentmemory://project/{name}/recent` | Seneste observationer for et projekt | | Ressource | `agentmemory://memories/latest` | De seneste 10 aktive hukommelser | | Ressource | `agentmemory://graph/stats` | Videngraf-statistik | | Ressource | `agentmemory://team/{id}/profile` | Delt teamprofil | | Prompt | `recall_context` | Søg + returnér kontekst-beskeder | | Prompt | `session_handoff` | Handoff-data mellem agenter | | Prompt | `detect_patterns` | Analysér tilbagevendende mønstre | | Skill | `/recall` | Søg i hukommelse | | Skill | `/remember` | Gem til langtidshukommelse | | Skill | `/session-history` | Seneste sessionsopsummeringer | | Skill | `/forget` | Slet observationer/sessioner | Tabellen viser de fire centrale skills. Det fulde sæt er 9 kaldbare skills plus 8 referenceskills; se afsnittet Native skills ovenfor. ### Standalone MCP Køres uden den fulde server, til enhver MCP-klient. Begge disse fungerer: ```bash npx -y @agentmemory/agentmemory@latest mcp # canonical (always available) npx -y @agentmemory/mcp # shim package alias ``` Eller tilføj til din agents MCP-konfiguration: 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" } } } } ``` Sammenføj `agentmemory`-indgangen i hostens eksisterende `mcpServers`-objekt, i stedet for at udskifte filen. For sandboxede klienter, der ikke kan nå hostens `localhost`, tilføj `"AGENTMEMORY_FORCE_PROXY": "1"` til env-blokken, og sæt `AGENTMEMORY_URL` til en rute, sandboxen kan nå. OpenCode (`opencode.json`): ```json { "mcp": { "agentmemory": { "type": "local", "command": ["npx", "-y", "@agentmemory/mcp"], "enabled": true } }, "plugin": ["./plugins/agentmemory-capture.ts"] } ``` Kopiér plugin-filen fra repositoryet: ```bash mkdir -p ~/.config/opencode/plugins cp plugin/opencode/agentmemory-capture.ts ~/.config/opencode/plugins/ cp plugin/opencode/commands/*.md ~/.config/opencode/commands/ ``` ---

Realtids-viewer

Starter automatisk på port `3113`. Viewer indlæser ét snapshot, når den forbinder (`GET /agentmemory/viewer/snapshot`), og anvender derefter livehændelser via SSE på `/agentmemory/viewer/events` i REST-workeren: nye hukommelser, lessons, observationer, audit-poster, grafændringer og health-opdateringer vises uden polling eller genindlæsning af siden. De eneste andre forespørgsler er de handlinger, du klikker på, "load more"-sider og søgninger. Når feedet afbrydes, viser viewer, hvor gamle dens tal er, genopretter forbindelsen med backoff og synkroniserer fra ét snapshot. - **12 faner i fire grupper** med live-tal, deep links (`#memories/`, `#sessions/?obs=`, `#graph/`, `#health/consolidation`), tastaturgenveje og en mobilmenu. - **Memories:** søgning på serversiden, filtre efter projekt, agent og type, et detaljepanel med versionskæden og en orddiff, herkomstlinks, kopiér-knapper til id'et, MCP-kaldet og en curl-kommando, rediger (en ny version), glem med bekræftelse, bulk-glem og JSON-eksport. - **Sessions:** en indlejret observationstidslinje med læsbart tool-input og -output, filtre og paginering, samt de hukommelser og lessons, hver session gav. - **Graph:** søgning, node-detaljer med relationer og kilder, en legende, der ikke udelukkende afhænger af farve, samt zoom-kontroller. - **Health:** den levende version af `GET /agentmemory/status`. Hvert problem kommer med sin løsning, plus state-backenden, indeksets save-tilstand, fremdrift for graf-herkomst-kompaktering og en forklaring på konsolidering med de reelle tærskler. - Siderne **Audit, Activity, Profile, Replay, Lessons, Actions og Crystals**, hver med en tom-tilstand, der siger, hvad sektionen er, hvorfor den er tom, og den kommando, der udfylder den, samt et `?`-ordliste-tooltip på hvert begreb og tal. ```bash open http://localhost:3113 ``` Viewer-serveren binder til `127.0.0.1` som standard og tilføjer server-secreten, når den videresender forespørgsler til REST API'et. Ved bind uden for loopback forbliver HTML-skallen offentlig, men hver proxy-forespørgsel kræver bearer-token; viewer beder om det og gemmer det i session storage. Konfigurér eksplicitte host-/origin-allowlists og TLS, før viewer eksponeres. REST-endpointet `/agentmemory/viewer` følger de normale bearer-token-regler og omdirigerer browsere uden token til viewer-porten. CSP-headers bruger en per-response script-nonce og forbyder inline handler-attributter (`script-src-attr 'none'`). ---

Konfiguration

### LLM-udbydere agentmemory opdager automatisk udbydere fra dit miljø. En udbyder gør LLM-baserede operationer tilgængelige, men udbyderkonfiguration alene aktiverer ikke LLM-skrevet observationskomprimering. Den vej kræver både en udbyder og `AGENTMEMORY_AUTO_COMPRESS=true`. | Provider | Config | Notes | |----------|--------|-------| | **No-op (standard)** | Ingen konfiguration nødvendig | LLM-baseret compress/summarize er deaktiveret. Syntetisk komprimering og BM25-recall fungerer stadig. Se `AGENTMEMORY_ALLOW_AGENT_SDK` nedenfor, hvis du tidligere afhang af Claude-abonnements-fallbacken. | | Anthropic API | `ANTHROPIC_API_KEY` | Per-token-fakturering | | MiniMax | `MINIMAX_API_KEY` | Anthropic-kompatibel | | Gemini | `GEMINI_API_KEY` | Aktiverer også embeddings | | OpenRouter | `OPENROUTER_API_KEY` | Enhver model | | OpenAI API | `OPENAI_API_KEY` | Standard `gpt-5.6-luna`, overskriv 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, der er OpenAI-API-kompatibelt. Ingen omkostning, kører på din egen hardware. Se [Lokale modeller](#local-models-ollama--lm-studio--vllm) nedenfor. | | Claude-abonnements-fallback | `AGENTMEMORY_ALLOW_AGENT_SDK=true` | Kun tilvalg. Starter `@anthropic-ai/claude-agent-sdk`-sessioner; det forårsagede tidligere ubegrænset Stop-hook-rekursion, så det er ikke længere standard. | ### Lokale modeller (Ollama / LM Studio / vLLM) agentmemory taler med enhver OpenAI-API-kompatibel server, så alt, der eksponerer `/v1/chat/completions`, fungerer uden kodeændringer. Ingen betalte nøgler, ingen cloud, ingen rate limits; kører helt på din egen hardware. **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`): Åbn LM Studio → fanen Local Server → Start Server. Vælg en vilkårlig chat-model fra vælgeren (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. Peg `OPENAI_BASE_URL` på den URL, din server eksponerer, og sæt `OPENAI_MODEL` til et navn, din server vil acceptere. **Modelvalg til hukommelsesarbejde**: komprimering og opsummering er korte opgaver (<2K tokens ind, <500 tokens ud), hvor en 7B instruct-model er mere end rigeligt. Anbefalinger: | Model | Størrelse | Hvorfor | |-------|------|-----| | `qwen3:8b` | ~5.2 GB | Balanceret standard på en 16 GB-maskine; stærk til udtrækning og tool-formet tekst | | `qwen3:4b` | ~2.6 GB | Mindste fornuftige mulighed; fin til komprimering, svagere til graf-udtrækning | | `qwen3-coder:30b` | ~19 GB | Bedste lokale valg til kode-formede sessioner (30B MoE, 3.3B aktive) på 24-32 GB hardware | | `gpt-oss:20b` | ~14 GB | Stærk generel model, der passer til 16 GB RAM | | `deepseek-r1:8b` | ~5.2 GB | Reasoning-distillat; langsommere, men renere udtrækninger | Qwen 3-modeller tænker som standard og kan brænde hele token-budgettet på reasoning, før der kommer nogen output. Sæt `AGENTMEMORY_LLM_NOTHINK=1` for at tilføje `/no_think` til graf-udtræknings-prompts, og hæv `MAX_TOKENS` (16384 virker), hvis udtrækninger kommer tomme tilbage. Reasoning-klasse-modeller (`o1`-stil med ``-blokke) kan returnere tomt `content` med et `reasoning`-felt, din lokale server muligvis ikke eksponerer. Hvis udtrækninger kommer tomme tilbage, skal du først skifte til en ikke-reasoning-model. Miljøvariablen `OPENAI_REASONING_EFFORT=none` kan også deaktivere thinking på Ollama Cloud thinking-modeller, der spejler OpenAI's reasoning-skema. Lokale embeddings leveres som en valgfri afhængighed, men er ikke aktiveret som standard. Sæt `EMBEDDING_PROVIDER=local` for at tilvælge `Xenova/all-MiniLM-L6-v2` (384-dim). Den første embedding-forespørgsel downloader modellen; inferens er derefter på enheden. Uden denne indstilling eller en ekstern embedding-nøgle forbliver vektorer deaktiveret, `mem::search` bruger BM25, og `smart-search` kan stadig tilføje eksisterende graf-match. ### Kostbevidst modelvalg Start uden nøgle til registrering og nøgleordssøgning. `EMBEDDING_PROVIDER=local` aktiverer lokal semantisk søgning efter den første modeldownload. LLM-komprimering kræver en udbyder og `AGENTMEMORY_AUTO_COMPRESS=true`; den kan sende én anmodning pr. observation. Kontrollér de aktuelle priser først. Viewer og `agentmemory status` viser de aktive udbydere. ### Multi-agent-hukommelse (`AGENT_ID` + `AGENTMEMORY_AGENT_SCOPE`) I multi-agent-opsætninger, hvor flere roller deler én agentmemory-server (architect / developer / reviewer / researcher / support-agent), tagger `AGENT_ID` hver skrivning med den rolle, der udførte den. `AGENTMEMORY_AGENT_SCOPE` styrer, om recall filtrerer efter dette tag. ```env TEAM_ID=company USER_ID=engineering-team AGENT_ID=architect AGENTMEMORY_AGENT_SCOPE=isolated # optional; default "shared" ``` To tilstande: | Tilstand | Tagger skrivninger | Filtrerer recall | Hvornår bruges den | |------|------------|---------------|-------------| | `shared` (standard) | ja | nej | Kontekst tværs af agenter med audit trail. Architect kan se, hvad developer noterede, men hver række registrerer, hvem der sagde det. | | `isolated` | ja | ja | Striks adskillelse. Architect ser aldrig developers observationer/hukommelser/sessioner. | Hvad der tagges, når `AGENT_ID` er sat: `Session.agentId`, `RawObservation.agentId`, `CompressedObservation.agentId`, `Memory.agentId`. Rollen flyder fra `api::session::start` → `mem::observe` → `mem::compress` → KV. Hvad der filtreres i isoleret tilstand: `mem::smart-search`, `/agentmemory/memories`, `/agentmemory/observations`, `/agentmemory/sessions`. Hver endpoint accepterer `?agentId=` til at overskrive pr. forespørgsel, og `?agentId=*` til helt at framelde env-scopet. `/memories` accepterer også `?includeOrphans=true` for at vise pre-AGENT_ID-hukommelser, hvis `agentId` er undefined. Override pr. kald på SDK-/REST-laget: hver muterende endpoint (`/session/start`, `/remember`) accepterer et `agentId`-felt i request-body'en, som vinder over env'et. Nyttigt for runtimes, der ruter mange roller gennem én serverproces. MCP-værktøjet `memory_save` eksponerer det samme `agentId`-felt, den selvstændige stdio-server videresender både `agentId` og `project`, og gemte hukommelser bærer `agentId` ind i søgeindekset, så agent-scopet søgning dækker både hukommelser og observationer. Når `AGENT_ID` ikke er sat, forbliver hukommelsen uscopet (legacy-opførsel, ingen tags, ingen filtre). ### Porte | Port | Formål | Konfiguration | |---|---|---| | `3111` | REST API, MCP HTTP, SSE | `III_REST_PORT` | | `3113` | Viewer UI | `III_VIEWER_PORT` | `--port ` sætter API-porten og som standard viewer til `N+2`. Brug `--instance N` til en separat instans. Hold interne porte private; læs [deployment-vejledningen](../deploy/README.md), før du tillader fjernadgang. ### Storage-backend: file (standard) vs. redis Standardlageret bruger filer og kræver ingen separat databasetjeneste. Redis er valgfrit med `AGENTMEMORY_STATE_BACKEND=redis` og `AGENTMEMORY_REDIS_URL`. Et backendskift kopierer ikke hukommelsen. Se [lagring og backup](../docs/reliability/state-storage.md) for persistens, Redis-begrænsninger og autentificeret eksport/import. ### Konfigurationsfil Placér agentmemorys runtime-konfiguration i `~/.agentmemory/.env` i stedet for at eksportere variabler i hver shell. Hvis viewer viser et opsætningshint som `export ANTHROPIC_API_KEY=...`, kopiér det ind i denne fil som `ANTHROPIC_API_KEY=...` uden `export`-præfikset, og genstart derefter agentmemory. Sæt `AGENTMEMORY_ENV_FILE` for at vælge en anden env-fil. Procesmiljøvariabler har forrang over filens værdier. Genstart serveren efter konfigurationsændringer. På Windows ligger samme fil på `%USERPROFILE%\.agentmemory\.env`: ```powershell New-Item -ItemType Directory -Force $HOME\.agentmemory notepad $HOME\.agentmemory\.env ``` For at teste med et Claude Code Pro/Max-abonnement i stedet for en API-nøgle, skal du tilvælge det eksplicit: ```env AGENTMEMORY_ALLOW_AGENT_SDK=true AGENTMEMORY_AUTO_COMPRESS=true ``` LLM-skrevet observationskomprimering kræver begge linjer: adgang til en LLM-udbyder (inklusive denne eksplicitte abonnements-fallback) og `AGENTMEMORY_AUTO_COMPRESS=true`. En udbyder alene lader standard-stien med syntetisk komprimering forblive uændret. Konsolidering (graf-noder, lessons, crystals) er aktiveret som standard, når en LLM-udbyder er konfigureret. Fravælg eksplicit med `CONSOLIDATION_ENABLED=false`, hvis du vil have LLM-fri drift. Graf-udtrækning er et separat flag: ```env GRAPH_EXTRACTION_ENABLED=true # CONSOLIDATION_ENABLED=false # opt out of auto-consolidation ``` ### Miljøvariabler Almindelige indstillinger 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 fulde reference er [`.env.example`](../.env.example) med legitimationsoplysninger, registreringsfiltre, opbevaring, lagring, teamafgrænsning og tilvalg. `AGENTMEMORY_ENV_FILE` vælger en anden fil. Commit aldrig en udfyldt `.env` eller en bearer-hemmelighed. ---

API

147 endpoints på port `3111`. REST API'et binder til `127.0.0.1` som standard. Beskyttede endpoints kræver `Authorization: Bearer `, og mesh-sync-endpoints kræver en eksplicit sat `AGENTMEMORY_SECRET` på begge peers. **Autentificering er slået til som standard.** Hvis `AGENTMEMORY_SECRET` hverken er sat i shellen eller i `~/.agentmemory/.env`, opretter CLI’en en tilfældig hemmelighed ved første start i `~/.agentmemory/secret` og en kopi med navnet `secret` i den valgte datamappe, med filtilstanden `0600`. Alle medfølgende klienter læser den derfra, når de taler med en lokal server: CLI’en, viewer, hooks under `plugin/scripts`, MCP-serveren og `@agentmemory/mcp`-shimmen, konfigurationerne skrevet af `agentmemory connect`, og de medfølgende OpenCode-, Pi-, OpenClaw-, Hermes- og filesystem-watcher-integrationer. Den lagrede secret sendes kun til loopback-URL’er (`localhost`, `127.0.0.0/8`, `::1`). En eksplicit `AGENTMEMORY_SECRET` vinder altid, og eksterne klienter skal have den i deres miljø. Docker-self-hosting fra repositoryet og `deploy/`-entrypoints genererer og eksporterer deres egen secret. Sådan kaldes API’et manuelt: ```bash curl -H "Authorization: Bearer " http://localhost:3111/agentmemory/health ``` **Request-regler for skrivninger.** `POST`-, `PUT`-, `PATCH`- og `DELETE`-forespørgsler til REST API'et og viewer skal sende `Content-Type: application/json` (en `charset`-parameter er fint) når de bærer en body, og en `Origin`-header, når den er til stede, skal være en loopback-origin for den konfigurerede REST- eller viewer-port eller være listet i `VIEWER_ALLOWED_ORIGINS` (kommasepareret, f.eks. `https://memory.example.com`). Klienter, der ikke sender en `Origin`-header (CLI, hooks, MCP, curl, server-til-server), er ikke påvirket. Viewer accepterer også sin egen origin. **Filstier.** Endpoints, der læser eller skriver filer (`/compress-file`, `/replay/import-jsonl`, `/graph/import-graphify`), accepterer kun paths under `~/.agentmemory`, instansens data-mappe, eller en mappe listet i `AGENTMEMORY_IMPORT_ROOT` (separér flere med `:`, eller `;` på Windows). `/replay/import-jsonl` accepterer også sin standard `~/.claude/projects`. `/obsidian/export` forbliver inden for `AGENTMEMORY_EXPORT_ROOT`, og `/migrate` inden for `~/.agentmemory`. Symlinks opløses før hvert check. **Secret-scrubbing.** API-nøgler, bearer-tokens, PEM private key-blokke og credentials indlejret i URL'er (`scheme://user:password@host`) redigeres (redacted), før tekst lagres, på hver skrivevej: observations, remember, evolve, slots, lessons, actions, sketches, signals, checkpoints, imports, jsonl replay, mesh sync, team shares, komprimerings- og opsummeringsoutput, crystals og graf-noder.
Centrale endpoints | Method | Path | Description | |--------|------|-------------| | `GET` | `/agentmemory/health` | Health-check (altid offentlig) | | `GET` | `/agentmemory/status` | Hvad der er forkert, og hvordan det fikses (HTML til browsere, JSON i øvrigt) | | `GET` | `/agentmemory/viewer/snapshot` | Alt det, viewer viser, i ét svar | | `POST` | `/agentmemory/session/start` | Start session + få kontekst | | `POST` | `/agentmemory/session/end` | Afslut session | | `POST` | `/agentmemory/observe` | Indsaml observation (se capture-levering nedenfor) | | `GET` | `/agentmemory/capture` | Capture-inbox, dead letters og offline-spool | | `POST` | `/agentmemory/capture/retry` | Gentag dead-letter-captures | | `POST` | `/agentmemory/capture/drain` | Send den lokale offline-spool nu | | `POST` | `/agentmemory/smart-search` | Hybrid søgning | | `POST` | `/agentmemory/context` | Generér kontekst | | `POST` | `/agentmemory/remember` | Gem til langtidshukommelse | | `POST` | `/agentmemory/forget` | Slet observationer | | `POST` | `/agentmemory/enrich` | Filkontekst + hukommelser + bugs | | `GET` | `/agentmemory/profile` | Projektprofil | | `GET` | `/agentmemory/export` | Eksportér alle data | | `POST` | `/agentmemory/import` | Importér fra JSON | | `POST` | `/agentmemory/graph/query` | Videngraf-forespørgsel | | `POST` | `/agentmemory/graph/compact` | Beskær overdimensioneret graf-herkomst | | `POST` | `/agentmemory/team/share` | Del med team | | `GET` | `/agentmemory/audit` | Audit trail | Fuld endpoint-liste: [REST API](../plugin/skills/agentmemory-rest-api/REFERENCE.md)
**Capture-levering.** Hooks sender hver observation én gang til `POST /agentmemory/observe` med et `eventId`. Det er hostens eget id for kaldet, når payloaden har et (for eksempel Claude Codes `tool_use_id`), ellers en hash af sessionen, hook-typen, tool-navnet, input, output og host-timestamp. Serveren skriver eventet til en capture-inbox i state-store'en, lagrer observationen, og fjerner derefter inbox-indgangen. Statuskoden siger, hvad der skete: | Status | `status` field | Meaning | |---|---|---| | `201` | `accepted` | Lagret. `observationId` er den nye observation. | | `202` | `accepted` (`state: "retrying"`) | Accepteret, men lagring fejlede. Serveren gentager den, også efter en genstart. | | `200` | `duplicate` | Dette `eventId` var allerede accepteret. `observationId` er den eksisterende observation; intet nyt lagres. | | `400` / `422` | `rejected` | Ugyldig payload, eller lagring fejlede permanent (eventet bevares som en dead letter). | | `503` | `rejected` (`retryable: true`) | Inbox'en er fuld (`AGENTMEMORY_CAPTURE_INBOX_MAX`). Hooks spooler eventet og sender det senere. | Mislykkede events gentages hvert `AGENTMEMORY_CAPTURE_RETRY_INTERVAL_MS` (10 sek.) med fordoblende backoff, op til `AGENTMEMORY_CAPTURE_MAX_ATTEMPTS` (5). Events, der stadig fejler, forbliver i inbox'en som dead letters, listes på `/agentmemory/status` og viewerens Health-side, og kan gentages med `POST /agentmemory/capture/retry` (`{"eventId": "..."}` eller `{"all": true}`). Accepterede event-id'er huskes i `AGENTMEMORY_CAPTURE_DEDUP_HOURS` (168 timer, højst `AGENTMEMORY_CAPTURE_EVENTS_MAX` id'er), så en hook, der afspilles igen efter en timeout eller en genstart, lagres én gang, mens to separate tool-kald med deres egne host-id'er lagres to gange, selv når deres indhold er identisk. Når en observation slettes (forget, sessionssletning, eviction, auto-forget eller en import, der udskifter lageret), markeres dens event som slettet, før observationen fjernes, så en afspilning af det event inden for samme vindue besvares som en duplikat og lagrer intet. State-store'en skriver til disk hvert 2. sekund, så et besvaret event stadig kan være kun i hukommelsen et øjeblik. For at dække det bærer hvert `2xx`-svar også serverens `bootId` (ny ved hver opstart), `acceptedAt` og `durableAfterMs` (save-intervallet plus 1.5 s på fillagret, 1.5 s på redis, hvor persistens er operatørens indstilling). Hooks holder eventet i den lokale spool, indtil dette vindue er gået, og sletter det ved et senere kald uden endnu en forespørgsel. Hvis `bootId` er ændret til da, genstartede serveren, så hooken sender eventet igen med samme `eventId`; et event, der nåede disken, lagres ikke to gange. Serveren sender også selv sådanne events ved opstart og ved hvert retry-interval, så en genstart taber intet, selv når ingen hook kører bagefter. Ældre hooks ignorerer de ekstra felter, og nye hooks mod en ældre server kasserer eventet ved `2xx` som før. Når serveren er nede, ikke svarer i tide, eller returnerer en 5xx, tilføjer hooken observationen til en lokal spool-fil, `/capture-spool/-.jsonl` (overskriv mappen med `AGENTMEMORY_CAPTURE_SPOOL_DIR`). Filen er privat for din bruger (rettighed 600), secrets redigeres (redacted) på samme måde som serveren redigerer dem, den holder højst `AGENTMEMORY_CAPTURE_SPOOL_MAX_BYTES` (5 MiB) og smider indgange ud, der er ældre end `AGENTMEMORY_CAPTURE_SPOOL_MAX_AGE_HOURS` (168). Når den er fuld, smides nye indgange ud og tælles, og `/agentmemory/status` rapporterer det. Hooken afslutter stadig med 0 inden for sin tidsgrænse og tilføjer ingen forespørgsel, når serveren er sund. Spool'en sendes ved næste opstart og af den første hook, der når serveren igen, i en baggrundsproces, så agenten ikke venter. Event-id'er gør dette sikkert: en observation, der nåede frem før en timeout, lagres ikke to gange. `npx @agentmemory/agentmemory capture` viser spool'en og server-inbox'en, `--drain` sender spool'en nu, og `GET /agentmemory/capture` returnerer det samme som JSON. Sæt `AGENTMEMORY_CAPTURE_SPOOL=false` for at slå spool'en fra. **Komprimering af graf-herkomst.** Komprimering af ældre herkomstdata udskydes ved opstart, fordi den læser hele de ældre scopes. `/agentmemory/status` viser `deferred`, eller `off` med `AGENTMEMORY_GRAPH_COMPACT_ON_BOOT=false`. Kør den manuelle komprimering nedenfor under vedligeholdelse. Migrering af søgeindekset er separat: brug `agentmemory graph-index migrate --allow-legacy-scan` som beskrevet i [vedligeholdelsesvejledningen](../docs/reliability/graph-index-migration.md). For at køre den manuelt, kald `POST /agentmemory/graph/compact`. Den gennemgår navne- og edge-key-indekserne i stedet for at liste hver node og kant, og er sikker at køre igen. Når den beskærer id'er, skriver den en `graph_compact`-audit-indgang. ```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 kaldet returnerer 504, så kør den i skiver. Send `scope` (`nodes`, `edges` eller `history`), `offset` og `limit`, og kald derefter igen med den returnerede `nextOffset`, indtil den er `null`. Gør dette for `nodes`, `edges` og `history`, og afslut med ét `{"scope":"snapshot"}`-kald, fordi en skive-kørsel ikke rører det cachede snapshot. ```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"}' ``` ---

Udvikling

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

Licens

[Apache-2.0](../LICENSE)