{"id":47718381,"url":"https://github.com/3vilm33pl3/memory","last_synced_at":"2026-05-11T11:04:38.269Z","repository":{"id":345104122,"uuid":"1183574320","full_name":"3vilM33pl3/memory","owner":"3vilM33pl3","description":"Local knowledge base for coding agents with a Rust CLI/TUI, PostgreSQL storage, and optional background capture.","archived":false,"fork":false,"pushed_at":"2026-05-03T09:56:35.000Z","size":8869,"stargazers_count":0,"open_issues_count":6,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-05-03T11:02:27.202Z","etag":null,"topics":["coding-agents","developer-tools","knowledge-base","memory","postgresql","rust","semantic-search","terminal-ui"],"latest_commit_sha":null,"homepage":"https://github.com/3vilM33pl3/memory","language":"Rust","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"agpl-3.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/3vilM33pl3.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":"CONTRIBUTING.md","funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":"NOTICE","maintainers":null,"copyright":null,"agents":"AGENTS.md","dco":null,"cla":null}},"created_at":"2026-03-16T18:40:19.000Z","updated_at":"2026-05-03T09:56:39.000Z","dependencies_parsed_at":null,"dependency_job_id":"30e9359b-6d5e-42a0-9c63-05e453295311","html_url":"https://github.com/3vilM33pl3/memory","commit_stats":null,"previous_names":["3vilm33pl3/memory"],"tags_count":32,"template":false,"template_full_name":null,"purl":"pkg:github/3vilM33pl3/memory","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/3vilM33pl3%2Fmemory","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/3vilM33pl3%2Fmemory/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/3vilM33pl3%2Fmemory/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/3vilM33pl3%2Fmemory/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/3vilM33pl3","download_url":"https://codeload.github.com/3vilM33pl3/memory/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/3vilM33pl3%2Fmemory/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":32891967,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-10T13:40:02.631Z","status":"online","status_checked_at":"2026-05-11T02:00:05.975Z","response_time":120,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["coding-agents","developer-tools","knowledge-base","memory","postgresql","rust","semantic-search","terminal-ui"],"created_at":"2026-04-02T19:10:03.817Z","updated_at":"2026-05-11T11:04:38.262Z","avatar_url":"https://github.com/3vilM33pl3.png","language":"Rust","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Memory Layer\n\nMemory Layer is a local-first memory system for coding agents and developers. It turns project work into durable, searchable knowledge so the next Codex, Claude, or human session can start with evidence instead of guesswork.\n\nIt captures what happened, curates what matters, stores it in PostgreSQL with pgvector, and exposes it through a fast TUI, browser UI, and agent-friendly CLI.\n\n![Memory Layer memories tab](docs/img/tui/memories-tab.png)\n\n## Measured Impact\n\nMemory Layer is built to be evaluated, not just demoed. Its eval harness runs\npaired ablations such as `no-memory` vs `full-memory`, writes immutable\nartifacts, compares item-by-item results, applies gates, and reports token and\nlatency cost.\n\n**Latest report:** the valid `2026-05-03` Dockerized\n[`memory-improvement-v1` benchmark](docs/developer/evaluation-runs/2026-05-03-memory-improvement-v1-full.md)\nran five paired repeats against hidden memory-only facts, graph-backed\nretrieval checks, and grounded-answer tasks. Full Memory moved aggregate\nsuccess from `0.0%` to `18.1%`, Recall@K/MRR/nDCG from `0.000` to `1.000`,\nassertion recall from `0.000` to `0.725`, and total tokens from `22,069,461`\nto `12,970,186`, a `41.2%` reduction.\n\nThe result is deliberately specific: it shows strong improvement for retrieval\nand grounded answers, while the report calls out that long-running autonomous\ncoding continuity still needs verified Memory-query evidence before making a\nstronger claim.\n\nRead the [Beginner Guide To Evaluations](docs/user/evaluation-guide.md), the\n[`memory eval` CLI reference](docs/user/cli/eval.md), and the full\n[benchmark report](docs/developer/evaluation-runs/2026-05-03-memory-improvement-v1-full.md).\n\n## Why It Is Interesting\n\n- **Answers with evidence:** ask a project question and see both the synthesized answer and the exact memories used to produce it.\n- **Code graph-aware retrieval:** extract parser-backed symbols, references, and graph edges, then let query use that structure to find memories connected to the code you ask about.\n- **Multi-embedding search:** keep OpenAI, Voyage, Cohere, Gemini, or local OpenAI-compatible embedding spaces side by side, then switch the active retrieval backend without recomputing.\n- **Distributed agents:** monitor Codex and Claude sessions across projects, including token pressure, context usage, rate limits, process details, and open ports.\n- **Agent-linked watchers:** background watchers attach to agent sessions, identify the project automatically, heartbeat to the service, and stop when the owning agent exits.\n- **Get up to speed:** persisted activity events, recent memory changes, commits, warnings, and token summaries become a briefing for new or returning agents.\n- **Repeatable evaluation:** run paired no-memory vs full-memory ablations with artifacted results, gates, token accounting, and concrete retrieval-quality metrics.\n- **Human review loop:** curation can queue replacement proposals so important memory changes can be approved before older knowledge is superseded.\n\n![How Memory Layer turns project work into cited context](docs/img/infograph.png)\n\n## Table of Contents\n\n- [Quick Start](#quick-start)\n- [Quick Start (Developers)](#quick-start-developers)\n- [Feature Tour](#feature-tour)\n- [Documentation](#documentation)\n- [Development](#development)\n- [License](#license)\n\n## Quick Start\n\nThe fastest path is:\n\n1. Create a PostgreSQL database for Memory Layer and enable the `vector` extension in that database.\n2. Install the package.\n3. Run `memory wizard --global` once per machine and enter the database URL.\n4. Choose the project directory or repository Memory Layer should manage.\n5. Run `memory wizard` inside that project to create or refresh repo-local Memory Layer config.\n6. Let Memory Layer auto-derive a writer identity, or set `writer.id` only if you want a custom shared label.\n7. Start `memory service run` or enable the packaged service.\n8. Open the TUI or web UI.\n\nExample database URL:\n\n```text\npostgres://memory_layer:\u003cpassword\u003e@127.0.0.1:5432/memory_layer\n```\n\nIf you are running PostgreSQL locally, create a dedicated database and user first:\n\n```bash\nsudo -u postgres createuser --pwprompt memory_layer\nsudo -u postgres createdb --owner=memory_layer memory_layer\n```\n\nOn macOS/Homebrew PostgreSQL, the same commands usually run without `sudo -u postgres`:\n\n```bash\ncreateuser --pwprompt memory_layer\ncreatedb --owner=memory_layer memory_layer\n```\n\nBefore running the wizard, verify that the database exists and is reachable from the same machine:\n\n```bash\nexport DATABASE_URL='postgres://memory_layer:\u003cpassword\u003e@127.0.0.1:5432/memory_layer'\npsql \"$DATABASE_URL\" -c \"SELECT 1;\"\npsql \"$DATABASE_URL\" -c \"CREATE EXTENSION IF NOT EXISTS vector;\"\npsql \"$DATABASE_URL\" -c \"SELECT extversion FROM pg_extension WHERE extname = 'vector';\"\n```\n\nPreview and create repo-local Memory Layer configuration inside the project:\n\n```bash\ncd /path/to/your-project\nmemory wizard --dry-run\nmemory wizard\n```\n\nDebian:\n\n```bash\nsudo dpkg -i memory-layer_\u003cversion\u003e_amd64.deb\nmemory wizard --global\ncd /path/to/your-project\nmemory wizard --dry-run\nmemory wizard\nsudo systemctl enable --now memory-layer.service\nmemory tui\n```\n\nmacOS:\n\n```bash\nbrew tap 3vilM33pl3/memory https://github.com/3vilM33pl3/memory\nbrew install 3vilM33pl3/memory/memory-layer\nmemory wizard --global\ncd /path/to/your-project\nmemory wizard --dry-run\nmemory wizard\nmemory service enable\nmemory tui\n```\n\nFor unreleased changes from `main`:\n\n```bash\nbrew install --HEAD 3vilM33pl3/memory/memory-layer\n```\n\nFor the full onboarding flow, prerequisites, upgrade path, and troubleshooting, use [Getting Started](docs/user/getting-started.md).\n\n### Agent Install Prompt\n\nGive this prompt to an agent when you want it to install Memory Layer for you:\n\n````\n# Install Memory Layer\n\nYou are installing Memory Layer for me. Work in the terminal, explain before using sudo, and stop before destructive changes.\n\n## Goal\n\nInstall Memory Layer completely on this machine and configure it for the project I choose.\n\nRepository: https://github.com/3vilM33pl3/memory\nGitHub Releases: https://github.com/3vilM33pl3/memory/releases\n\n## Rules\n\n- Detect whether this is Linux/Debian-style or macOS.\n- Do not invent secrets.\n- PostgreSQL is required. Before running `memory wizard --global`, find an existing database URL or ask me whether to use an existing/hosted PostgreSQL database or create a local one.\n- If creating a local PostgreSQL database, create a dedicated database and user named `memory_layer` unless I ask for different names.\n- Do not invent the database password; ask me for it or generate one only after confirming that is OK.\n- Make sure the PostgreSQL server has pgvector installed and that the target database has `CREATE EXTENSION IF NOT EXISTS vector;` applied.\n- Verify PostgreSQL with `psql \"$DATABASE_URL\" -c \"SELECT 1;\"` and verify pgvector with `psql \"$DATABASE_URL\" -c \"SELECT extversion FROM pg_extension WHERE extname = 'vector';\"` before configuring Memory Layer.\n- Ask me for optional LLM or embedding API keys only if I want scan or semantic retrieval.\n- Make sure Go is available on PATH so repo-local Memory Layer skills can run.\n- Run health checks before saying the install is done.\n\n## Linux / Debian path\n\n1. Download the latest Memory Layer `.deb` from https://github.com/3vilM33pl3/memory/releases.\n2. Install it with `sudo dpkg -i memory-layer_\u003cversion\u003e_amd64.deb`.\n3. Prepare PostgreSQL before configuring Memory Layer:\n   - If using a hosted/existing database, verify that it accepts connections from this machine and supports pgvector.\n   - If creating a local database, install PostgreSQL and the matching pgvector package for the server major version, for example `postgresql-16-pgvector` when the server is PostgreSQL 16.\n   - Create or receive a database URL such as `postgres://memory_layer:\u003cpassword\u003e@127.0.0.1:5432/memory_layer`.\n   - Run `psql \"$DATABASE_URL\" -c \"CREATE EXTENSION IF NOT EXISTS vector;\"`.\n   - Run `psql \"$DATABASE_URL\" -c \"SELECT 1;\"` and `psql \"$DATABASE_URL\" -c \"SELECT extversion FROM pg_extension WHERE extname = 'vector';\"`.\n4. Run `memory wizard --global` and configure the verified database URL and optional LLM/embedding settings.\n5. Go to my target project directory.\n6. Run `memory wizard --dry-run`, then `memory wizard` for repo-local setup.\n7. Start the backend with `sudo systemctl enable --now memory-layer.service`.\n8. Run `memory doctor`, `memory health`, and then open `memory tui`.\n\n## macOS path\n\n1. Run `brew tap 3vilM33pl3/memory https://github.com/3vilM33pl3/memory`.\n2. Run `brew install 3vilM33pl3/memory/memory-layer`.\n3. Prepare PostgreSQL before configuring Memory Layer:\n   - If using a hosted/existing database, verify that it accepts connections from this machine and supports pgvector.\n   - If creating a local database, use Homebrew PostgreSQL and pgvector, then create a dedicated `memory_layer` database and user.\n   - Create or receive a database URL such as `postgres://memory_layer:\u003cpassword\u003e@127.0.0.1:5432/memory_layer`.\n   - Run `psql \"$DATABASE_URL\" -c \"CREATE EXTENSION IF NOT EXISTS vector;\"`.\n   - Run `psql \"$DATABASE_URL\" -c \"SELECT 1;\"` and `psql \"$DATABASE_URL\" -c \"SELECT extversion FROM pg_extension WHERE extname = 'vector';\"`.\n4. Run `memory wizard --global` and configure the verified database URL and optional LLM/embedding settings.\n5. Go to my target project directory.\n6. Run `memory wizard --dry-run`, then `memory wizard` for repo-local setup.\n7. Start the backend with `memory service enable`.\n8. Run `memory doctor`, `memory health`, and then open `memory tui`.\n\n## Finish\n\nReport what was installed, where the config files are, whether the service is healthy, and what I should run next.\n````\n\n### Agent Repo Memory Init Prompt\n\nGive this separate prompt to an agent when Memory Layer is installed already and you want it to configure a specific project:\n\n````\n# Initialize Repository For Memory Layer\n\nYou are configuring an existing project for Memory Layer. Work in the terminal, explain before changing files, and stop before destructive changes.\n\n## Goal\n\nCreate or refresh repo-local Memory Layer configuration so agents can write, query, and curate project memory safely.\n\n## Rules\n\n- Work in the target project directory I give you.\n- Do not install the system package; this prompt is only for repo-local Memory Layer setup.\n- Do not create or reinitialize git history.\n- Do not delete existing `.mem/`, `.agents/`, or config files.\n- If `.mem/config.toml`, `.mem/project.toml`, `.agents/memory-layer.toml`, or `.agents/skills/` already exist, inspect them and preserve local customizations.\n- Ask me before overwriting files, rotating credentials, importing history, or running a write operation that was not previewed.\n- Make sure the shared backend is configured and healthy before saying setup is done.\n- Make sure Go is available on `PATH` because repo-local Memory Layer skills use the Go helper.\n\n## Steps\n\n1. Run `memory health` and `memory doctor`.\n2. Run `memory wizard --dry-run` in the target project to preview repo-local setup.\n3. Run `memory wizard` to create or refresh `.mem/` and `.agents/` Memory Layer files.\n4. Run `memory doctor` again.\n5. If commit history should be available as evidence, run `memory commits sync --project \u003cproject-slug\u003e --dry-run`, then run it for real only if the preview looks correct.\n6. If an initial scan is wanted, run `memory scan --project \u003cproject-slug\u003e --dry-run`, then run it for real only after I approve the preview.\n7. Open `memory tui` or report the project slug and next commands.\n\n## Finish\n\nReport which repo-local files were created or preserved, the project slug, backend health, and any follow-up actions.\n````\n\nKey docs after setup:\n\n- [TUI Guide](docs/user/tui/README.md) for the visual workflow.\n- [Embedding Operations](docs/user/cli/embeddings.md) for multi-backend semantic search and model switching.\n- [Code Graph Extraction](docs/user/cli/graph.md) for parser-backed code structure and graph-aware query ranking.\n- [Watcher Health](docs/user/cli/watchers.md) for distributed watcher behavior.\n- [Query Command](docs/user/cli/query.md) for cited answers from memory.\n- [Get Up To Speed](docs/user/cli/up-to-speed.md) for new-agent briefings.\n- [Beginner Guide To Evaluations](docs/user/evaluation-guide.md) for measuring whether Memory improves agent behavior.\n- [Memory Bundles](docs/user/cli/bundles.md) for shareable backup and restore.\n\nMost mutating `memory` commands support `--dry-run` so agents can preview writes, service actions, and plan/checkpoint flows before applying them.\n\n## Quick Start (Developers)\n\nIf you are working on Memory Layer itself, you can run a development copy from a `cargo` checkout that is **fully isolated** from any packaged install on the same machine — separate ports, separate Cap'n Proto socket, separate runtime directory. The TUI shows `[dev]` in its header so you cannot mistake one for the other.\n\nThe mechanism: any `memory` binary launched from `target/{debug,release}/` activates the `dev` profile, which layers `.mem/config.dev.toml` on top of `.mem/config.toml` and ignores the global config entirely. Override with `MEMORY_LAYER_PROFILE=dev|prod` when needed.\n\n```bash\ngit clone https://github.com/3vilM33pl3/memory\ncd memory\nnpm --prefix web ci \u0026\u0026 npm --prefix web run build\n\n# Bootstrap the repo-local base config and the dev overlay.\ncargo run --bin memory -- init\ncargo run --bin memory -- dev init --copy-from-global\n\n# Each piece in its own shell, all on the dev stack.\ncargo run --bin memory -- service run            # backend (4250 HTTP, 4251 capnp)\ncargo run --bin memory -- watcher manager run    # optional\ncargo run --bin memory -- tui                    # header reads [dev]\n```\n\n`--copy-from-global` lifts the database URL and LLM/embedding endpoints from the installed config into the dev overlay so credentials are not duplicated.\n\n| Stack | HTTP | capnp TCP | capnp Unix socket |\n| --- | --- | --- | --- |\n| Installed (Debian/Homebrew package) | `127.0.0.1:4040` | `127.0.0.1:4041` | `/tmp/memory-layer.capnp.sock` |\n| Dev (cargo-run from repo) | `127.0.0.1:4250` | `127.0.0.1:4251` | `\u003crepo\u003e/.mem/runtime/dev/memory-layer.capnp.sock` |\n\nFor the full isolation contract, override flags, troubleshooting, and the verification recipe, see [Dev Stack vs Installed Stack](docs/developer/dev-stack.md).\n\n## Feature Tour\n\n### Search That Explains Itself\n\nThe Query tab and `memory query` combine lexical search, vector search, relation boosts, graph boosts, and memory filters. Results are labelled as `lexical`, `semantic`, or `hybrid`, and answers cite the ranked memories that supported them.\n\nWhen a completed code graph exists, query also looks at parser-backed symbols, references, and one-hop graph edges. Those graph hits are mapped back to curated memories through file provenance, so the system can explain why a memory about a function, module, or call path was retrieved without treating raw graph rows as answer citations.\n\n![Memory Layer query tab](docs/img/tui/query-tab.png)\n\n### Evaluation That Measures Memory\n\nMemory Layer includes a repeatable evaluation harness so improvements can be\nmeasured instead of guessed. Eval suites run the same tasks under paired\nconditions, such as `no-memory` and `full-memory`, then write immutable\nartifacts, compare item-by-item results, apply gate policies, and report token\nand latency deltas.\n\nThe current featured run is the valid `2026-05-03` Dockerized\n`memory-improvement-v1` benchmark highlighted above. It combines hidden\nmemory-only facts, reasoning-mode groups, multi-step continuity tasks,\ngraph-backed retrieval checks, token accounting, latency tracking, and optional\nLLM judging. That is the point of the harness: it shows where Memory helps and\nwhere the next engineering work belongs.\n\nStart with the [Beginner Guide To Evaluations](docs/user/evaluation-guide.md),\nuse [`memory eval`](docs/user/cli/eval.md) for the command reference, and see\nthe latest recorded\n[memory-improvement run](docs/developer/evaluation-runs/2026-05-03-memory-improvement-v1-full.md)\nfor the current evidence and caveats.\n\n### Code Graph Memory\n\n`memory graph extract` turns the repository into durable code structure: symbols, references, resolved edges, unresolved references, and evidence spans. This makes Memory Layer more than a vector database: it can connect natural-language project memory to concrete code relationships.\n\nWhy this matters:\n\n- questions about a symbol can retrieve memories attached to the files and neighboring symbols around it\n- graph diagnostics show whether retrieval used code structure, how many graph candidates were found, and which connections affected ranking\n- graph extraction itself is persisted as an activity, so new agents can see when the project’s code map was refreshed\n- unresolved and ambiguous references are stored explicitly, giving future analyzers and curation workflows a measurable improvement path\n\nSee [Code Graph Extraction](docs/user/cli/graph.md) and [Query Command](docs/user/cli/query.md).\n\n### Multiple Embedding Backends\n\nMemory Layer can keep several embedding spaces populated at once. That means you can compare OpenAI and Voyage retrieval, migrate models safely, or keep a local OpenAI-compatible backend around without losing existing vectors.\n\n![Memory Layer embeddings tab](docs/img/tui/embeddings-tab.png)\n\n### Distributed Agent Awareness\n\nThe Agents and Watchers tabs show what is running now: agent sessions, project ownership, context pressure, rate limits, watcher heartbeats, restart attempts, and stale processes.\n\n![Memory Layer watchers tab](docs/img/tui/watchers-tab.png)\n\n### Activity And Re-Entry\n\nThe Activity and Resume views turn persisted interactions into operational history and concise re-entry briefings. This is the \"get up to speed\" path for a fresh agent joining an active project.\n\n![Memory Layer activity tab](docs/img/tui/activity-tab.png)\n\n### Durable Project Knowledge\n\nMemory is scoped by project, typed by purpose, linked to provenance, and curated into canonical entries. The Memories and Review tabs make it possible to inspect, maintain, and approve changes to that knowledge base.\n\n![Memory Layer memories tab](docs/img/tui/overview.png)\n\nProject-local customization now has two layers:\n\n- `.mem/` for runtime overrides and generated state\n- `.agents/memory-layer.toml` for project-owned memory behavior such as include/ignore paths and future analyzers/plugins\n\n## Documentation\n\n### User Docs\n\n- [User Documentation Index](docs/user/README.md)\n- [Getting Started](docs/user/getting-started.md)\n- [TUI Guide](docs/user/tui/README.md)\n- [TUI Query Tab](docs/user/tui/query.md)\n- [TUI Agents Tab](docs/user/tui/agents.md)\n- [TUI Embeddings Tab](docs/user/tui/embeddings.md)\n- [Embedding Operations](docs/user/cli/embeddings.md)\n- [Memory Bundles](docs/user/cli/bundles.md)\n- [Watcher Health](docs/user/cli/watchers.md)\n- [Activities And Get Up To Speed](docs/user/cli/activities.md)\n- [Resume Briefings](docs/user/cli/resume.md)\n- [Wizard And Bootstrap](docs/user/cli/wizard.md)\n- [Init Bootstrap](docs/user/cli/init.md)\n- [Service Commands](docs/user/cli/service.md)\n- [Doctor Diagnostics](docs/user/cli/doctor.md)\n- [Health And Stats](docs/user/cli/health.md)\n- [Query Command](docs/user/cli/query.md)\n- [Code Graph Extraction](docs/user/cli/graph.md)\n- [Checkpoint Workflow](docs/user/cli/checkpoint.md)\n- [Capture Command](docs/user/cli/capture.md)\n- [Remember Command](docs/user/cli/remember.md)\n- [Curate Command](docs/user/cli/curate.md)\n- [Repository Index](docs/user/cli/repo.md)\n- [Scan Command](docs/user/cli/scan.md)\n- [Commit History](docs/user/cli/commits.md)\n- [Archive Command](docs/user/cli/archive.md)\n- [Automation Commands](docs/user/cli/automation.md)\n\n### Developer Docs\n\n- [Developer Documentation Index](docs/developer/README.md)\n- [Dev Stack vs Installed Stack](docs/developer/dev-stack.md)\n- [How Skills Work](docs/developer/skills/how-skills-work.md)\n- [Architecture Overview](docs/developer/architecture/overview.md)\n- [How Memory Layer Works](docs/developer/architecture/how-it-works.md)\n- [Hidden Memory Daemon](docs/developer/architecture/hidden-memory-daemon.md)\n- [Refactor Baseline](docs/developer/refactor-baseline.md)\n\n## License\n\nMemory Layer is dual-licensed:\n\n- **Open source:** GNU Affero General Public License v3.0 or later, see [LICENSE](LICENSE)\n- **Commercial:** available under a separate commercial license from the copyright holder, see [LICENSE-COMMERCIAL.md](LICENSE-COMMERCIAL.md)\n\n### What this means\n\nIf you use, modify, or host Memory Layer under the open source license, you must comply with the AGPL, including providing source code for modified networked versions.\n\nIf you want to use Memory Layer in a proprietary or closed-source commercial setting, contact the copyright holder for a commercial license.\n\n### Contributions\n\nUnless explicitly agreed otherwise in writing, contributions are accepted under the repository's open source license, while the maintainer retains the right to offer the project under separate commercial terms. See [CONTRIBUTING.md](CONTRIBUTING.md).\n\n## Development\n\nFor working on this repository itself, start with [Quick Start (Developers)](#quick-start-developers) above and then [Dev Stack vs Installed Stack](docs/developer/dev-stack.md) for the isolation contract.\n\nPackaging, architecture, and implementation details live under [Developer Documentation](docs/developer/README.md).\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2F3vilm33pl3%2Fmemory","html_url":"https://awesome.ecosyste.ms/projects/github.com%2F3vilm33pl3%2Fmemory","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2F3vilm33pl3%2Fmemory/lists"}