understory π±
Memory framework
First committed by thecodacus
Published in thecodacus/understory. Publisher page
345 GitHub stars
What it is
LLM-managed knowledge base following the OKF spec β MCP server + web UI
AutoGineer overview, from the brainβs own files
Understory is a memory framework designed to act as the persistent knowledge layer for AI agents. It organizes information as a living knowledge graph of plain markdown files, adhering to the Open Knowledge Format (OKF) v0.1 specification. By providing an MCP server and a web UI, it allows agents to query, add, and maintain their own knowledge base. The system emphasizes graph health through deterministic maintenance tools that automatically resolve orphans and broken links, ensuring the knowledge base remains structured and navigable. It supports multiple isolated memory profiles, making it suitable for managing distinct contexts like work, health, or personal projects, all while remaining human-readable and git-diffable.
How it works
Memory model: LLM wiki
AutoGineer overview, from the brainβs own files
Understory stores information as markdown files with YAML frontmatter in a bundle directory. It provides an MCP server that exposes tools for agents to query, add, update, and maintain these files. The system uses an internal agent to manage the knowledge graph, ensuring that new information is either integrated into existing concepts or back-linked correctly. A web UI provides a visual representation of the graph, while a maintenance tool automatically identifies and fixes orphaned concepts or broken links. The system can be configured to run locally or via Docker, supporting various LLM providers for the agent's reasoning tasks.
| Folder | Role | Files |
|---|---|---|
| .github | agent-config | 1 |
| packages | source-code | 78 |
| scripts | scripts | 1 |
| sample-bundle | folder | 8 |
The agent writes
- docker-compose.yml evidence: README.md
Requirements
Apps: Docker
Runtimes: Node.js >=20
API keys (by name): ADMIN_TOKEN, ANTHROPIC_API_KEY, AUTH_TOKEN, DEEPSEEK_API_KEY, LLAMACPP_API_KEY, LLM_API_KEY, LLM_FALLBACK_API_KEY, LOCAL_API_KEY, OPENROUTER_API_KEY
Works with: Claude Code
Set it up
- Not scanned by AutoGineerThe authorβs README also describes installing it with Docker Compose. Read its install section: AutoGineer did not scan that path. https://github.com/thecodacus/understory/blob/7625aa400086d2c1fb81cbbc4975ce00cc23ec77/README.md#quick-start-docker
First committed by thecodacus. Published in thecodacus/understory. Licence: Apache License 2.0.
Usage
AutoGineer overview, from the brainβs own files
- Connect the MCP server to an AI agent to provide persistent, long-term memory.
- Use the web UI to visualize the knowledge graph and manually inspect or chat with the agent about the stored data.
- Run maintenance tasks to automatically clean up and wire orphaned concepts within the knowledge base.
- Manage multiple isolated memory bundles using the profile system for different project contexts.
- Track agent reasoning paths through trace logs to understand how information was retrieved or updated.
- βmemory_add: We deploy on Fridays, never Mondays.β
- The agent creates or updates a concept in the markdown bundle and wires it into the knowledge graph.
- βmemory_maintainβ
- The agent scans the graph for orphans or broken links and automatically repairs them to ensure structural integrity.
Documentation by thecodacus
understory π±
Memory that grows.
The layer beneath your agents: a self-wiring, plain-markdown memory. Every fact your agents learn is filed as a markdown concept, cross-linked into a living knowledge graph, and kept healthy by the agent itself β searchable, diffable, and entirely yours. Runs great on local models.
Bundles follow the Open Knowledge Format (OKF) v0.1 spec β plain markdown files with YAML frontmatter, readable by humans, diffable in git, portable across tools.
Three ways in, one agent:
MCP server β
memory_query/memory_add/memory_update/memory_status/memory_maintaintools over stdio or streamable HTTP. Each call drives an internal LLM agent with the OKF spec in its system prompt.Web UI β browse the bundle (tree, concept viewer with Mermaid diagrams, update log, conformance badge), see the memory as an Obsidian-style force-directed graph (drag/pan/zoom, colored by type, sized by connections, orphans ringed red, click to open), and chat with the same agent to test it. Tool calls render inline so you can watch it work.
Query-path replay β every agent run (query/mutation/chat) records its traversal (searches β reads β writes) as a compact notation, persisted under
<bundle>/.traces/. The graph view lists recent runs; selecting one replays the path as numbered directed hops over the graph β visited concepts ringed, search hits dotted, everything else faded.CLI β
pnpm agent:query "..."/pnpm agent:mutate "..."smoke entries.Profiles β optionally host several isolated memories on one server, each selected by its own API key. See Profiles.
Design rule: conformance is enforced in code, not prompts. The deterministic bundle layer validates frontmatter (type required), regenerates index.md files, appends log.md entries (newest-first, spec Β§7), and sandboxes all paths to the bundle root. The LLM decides what to change; the code guarantees the result is a conformant bundle.
Quick start (Docker)
No clone needed β the image is public. Save this as docker-compose.yml:
services:
understory:
image: ghcr.io/thecodacus/understory:latest
ports:
- "3800:3800"
# Lets the container reach a llama.cpp server running on the host via
# http://host.docker.internal:8080/v1 (see "Local llama.cpp" below).
extra_hosts:
- "host.docker.internal:host-gateway"
volumes:
# Your memory lives here as plain markdown β a named volume, or point
# a bind mount (e.g. ./my-memory:/bundle) at any OKF bundle.
- understory-memory:/bundle
environment:
BUNDLE_ROOT: /bundle
LLM_API_BASE_URL: ${LLM_API_BASE_URL}
LLM_API_KEY: ${LLM_API_KEY}
LLM_API_FORMAT: openai
LLM_MODEL: ${LLM_MODEL:-}
# Optional fallback
LLM_FALLBACK_API_BASE_URL: ${LLM_FALLBACK_API_BASE_URL:-}
LLM_FALLBACK_API_KEY: ${LLM_FALLBACK_API_KEY:-}
LLM_FALLBACK_API_FORMAT: ${LLM_FALLBACK_API_FORMAT:-openai}
LLM_FALLBACK_MODEL: ${LLM_FALLBACK_MODEL:-}
restart: unless-stopped
volumes:
understory-memory:docker compose up -dChoosing a provider
The generic provider system supports any OpenAI-compatible or Anthropic-compatible API.
Set LLM_API_BASE_URL + LLM_API_KEY + LLM_MODEL and leave LLM_PROVIDER unset.
DeepSeek:
LLM_API_BASE_URL=https://api.deepseek.com/v1 LLM_API_KEY=sk-... LLM_MODEL=deepseek-chatOpenAI:
LLM_API_BASE_URL=https://api.openai.com/v1 LLM_API_KEY=sk-... LLM_MODEL=gpt-4oAnthropic (Claude):
LLM_API_BASE_URL=https://api.anthropic.com/v1 LLM_API_KEY=sk-ant-... LLM_API_FORMAT=anthropic LLM_MODEL=claude-sonnet-5Groq:
LLM_API_BASE_URL=https://api.groq.com/openai/v1 LLM_API_KEY=gsk_... LLM_MODEL=llama-3.3-70b-versatileLocal llama.cpp:
LLM_API_BASE_URL=http://host.docker.internal:8080/v1 LLM_MODEL=When understory runs in Docker,
localhostis the container itself, not the host β so a llama-server on the host is reached athost.docker.internal(the compose files above already map it viaextra_hosts). Running from source on the same box as llama-server, usehttp://localhost:8080/v1.
Local llama.cpp with DeepSeek fallback:
LLM_API_BASE_URL=http://host.docker.internal:8080/v1 LLM_MODEL= \
LLM_FALLBACK_API_BASE_URL=https://api.deepseek.com/v1 LLM_FALLBACK_API_KEY=sk-... LLM_FALLBACK_MODEL=deepseek-chatThe old LLM_PROVIDER + per-provider key env vars still work (backward-compatible) but are deprecated.
Then:
Web UI β http://localhost:3800 β browse the memory, watch the graph, chat with the agent
MCP endpoint β
http://localhost:3800/mcp(streamable HTTP) β register it in any MCP client:claude mcp add --transport http ustory http://localhost:3800/mcpYour agent now has
memory_query/memory_add/memory_update/memory_status/memory_maintain, and gets a seed overview of the memory at every session start.
Teach it something (memory_add: "We deploy on Fridays, never Mondays"), then open the graph and watch the concept wire itself in. Deploying with Portainer? Use docker-compose.portainer.yml as a repository stack.
Stack
pnpm monorepo:
| Package | What |
|---|---|
packages/core | OKF bundle layer (zero LLM) + agent (Vercel AI SDK tool loop: search/read/list/write/patch/delete) + provider registry |
packages/server | Express: MCP streamable-HTTP at /mcp, stdio bin, REST browse API at /api/*, streaming chat at /api/chat, serves the web build |
packages/web | Vite + React + TS + Tailwind: bundle browser + agent chat (useChat) |
Providers are configured through LLM_API_BASE_URL, LLM_API_KEY, LLM_API_FORMAT (openai or anthropic), and LLM_MODEL. Any OpenAI-compatible endpoint (DeepSeek, OpenAI, Groq, OpenRouter, llama.cpp, etc.) works with LLM_API_FORMAT=openai; Anthropic-compatible endpoints use LLM_API_FORMAT=anthropic. Optional fallback uses the matching LLM_FALLBACK_* variables.
llama.cpp
# on the inference box β --jinja enables OpenAI-style tool calling
llama-server -m model.gguf --jinja --host 0.0.0.0 --port 8080
# here β no model id needed, it's discovered for llama-server-like local endpoints
LLM_API_BASE_URL=http://inference-box:8080/v1 LLM_API_FORMAT=openai LLM_MODEL= \
BUNDLE_ROOT=./sample-bundle node packages/server/dist/index.jsWorks behind llama-swap too: discovery prefers the currently loaded model so a query doesn't trigger a multi-minute model swap. Pin a specific model with LLM_MODEL=.
From source
pnpm install
pnpm build
cp .env.example .env # add your API key
BUNDLE_ROOT=./sample-bundle \
LLM_API_BASE_URL=https://api.deepseek.com/v1 \
LLM_API_KEY=sk-... \
LLM_API_FORMAT=openai \
LLM_MODEL=deepseek-chat \
node packages/server/dist/index.js
# β http://localhost:3800 (web UI + /api + /mcp)Or build the container yourself: docker compose up --build (the repo's docker-compose.yml builds from source and mounts ./sample-bundle).
Dev mode (server on :3800, Vite HMR on :5180 with proxy):
BUNDLE_ROOT=./sample-bundle pnpm --filter @understory/server dev
pnpm --filter @understory/web devMCP registration (Claude Code / Desktop)
claude mcp add ustory \
-e BUNDLE_ROOT=/path/to/your/bundle \
-e LLM_API_BASE_URL=https://api.deepseek.com/v1 \
-e LLM_API_KEY=sk-... \
-e LLM_API_FORMAT=openai \
-e LLM_MODEL=deepseek-chat \
-- node /path/to/understory/packages/server/dist/mcp/stdio.jsOr point an HTTP MCP client at http://host:3800/mcp.
Auth
By default the server is open β fine on localhost or a trusted LAN. Before exposing it anywhere else, set AUTH_TOKEN:
AUTH_TOKEN=$(openssl rand -hex 24)With it set, /mcp and /api require Authorization: Bearer <token> (the web UI stays reachable and prompts for the token). Register authenticated MCP clients with a header:
claude mcp add --transport http ustory http://host:3800/mcp \
--header "Authorization: Bearer <token>"The stdio transport needs no token β it's a local process spawned by the client.
Profiles: several isolated memories on one server
One server can host a separate memory per profile, for example work, health and a side project. Each profile has its own bundle on disk and its own API key, and the key is the only thing that selects a memory. A request made with the work key is served from the work bundle and cannot name, read or search any other profile. The URLs stay the same for everyone.
Turn it on by pointing PROFILES_ROOT at a directory (it takes precedence over BUNDLE_ROOT):
services:
understory:
# ...as in the quick start, plus:
volumes:
- understory-profiles:/profiles
environment:
PROFILES_ROOT: /profiles
ADMIN_TOKEN: ${ADMIN_TOKEN:-} # optional, enables the /admin API
volumes:
understory-profiles:Manage profiles with the bundled CLI. It works against a running server, which picks up changes on the next request:
docker compose exec understory node server/dist/profiles-cli.js create work
# profile: work
# api key: usk_... <- shown once; only a hash is stored
docker compose exec understory node server/dist/profiles-cli.js list
docker compose exec understory node server/dist/profiles-cli.js rotate work # old key stops working
docker compose exec understory node server/dist/profiles-cli.js remove work # revokes the key, keeps the memory
docker compose exec understory node server/dist/profiles-cli.js remove work --purge # also deletes the memoryFrom a source checkout the same commands are PROFILES_ROOT=... pnpm --filter @understory/server profiles <command>.
Give each agent its profile's key:
claude mcp add --transport http work-memory http://host:3800/mcp \
--header "Authorization: Bearer usk_..."The web UI asks for a key and opens that profile's memory. The sidebar shows which profile you are in, with a switch button to enter a different key.
Things worth knowing:
In profile mode every request needs a profile key.
AUTH_TOKENis not used.With
ADMIN_TOKENset,GET/POST /admin/profiles,POST /admin/profiles/<name>/rotateandDELETE /admin/profiles/<name>[?purge=true]do what the CLI does. The admin token manages profiles but cannot open any memory, and a profile key cannot reach/admin.Layout is
PROFILES_ROOT/<name>/per bundle plusPROFILES_ROOT/profiles.jsonfor the registry. To move an existing bundle into a profile, put it atPROFILES_ROOT/<name>/and runcreate <name>, which adopts the directory.The query cache, hot memory, traces, git history and dreaming are all per profile. Dreams run one profile after another.
The stdio transport serves one bundle. Point its
BUNDLE_ROOTat a profile's directory to use that memory locally.
Serving under a sub-path
The web UI uses relative URLs throughout, so it works behind a path-prefixing reverse proxy β no configuration needed. Any proxy that strips the prefix before forwarding works:
# Tailscale
tailscale serve --bg --set-path=/understory http://localhost:3800# Caddy
handle_path /understory/* {
reverse_proxy localhost:3800
}One rule: open the UI with a trailing slash (https://host/understory/, not .../understory) β relative URLs resolve against the last path segment, so without the slash they escape the prefix. If your proxy can redirect /understory β /understory/, do that.
Seed memory
A client LLM that only sees four bare tool names never gets the instinct to check memory. So at session start the server injects a compact overview of what the knowledge base contains (directories, concepts with types + descriptions, recent activity) through both channels that reach the model:
the MCP initialize
instructionsfield (clients like Claude put it in the system prompt), andthe
memory_querytool description β the universal fallback every tool-calling client loads.
The seed regenerates fresh for every new session. After memory_add / memory_update in a long-lived (stdio) session, the tool description refreshes via tools/list_changed, so the session sees its own writes. Out-of-band edits (hand edits, other clients) are picked up on the next session.
Graph health & maintenance
Memory is a graph, not a pile of notes, and graphs rot: concepts go orphaned (nothing links to them) and links go broken. Two mechanisms keep it healthy:
Write-time linking β new knowledge either enriches the concept it belongs to (an attribute of an existing entity is patched in, not filed separately) or, when it's a distinct entity, is created and back-linked from related concepts. Contradictions are superseded in place, never left standing alongside the old value.
memory_maintainβ a deterministic lint (orphans + broken links, surfaced inmemory_statusundergraph) drives an internal agent to wire orphans into related concepts and fix dangling links. Run it periodically to counter drift; it's a no-op when the graph is already healthy.
This design mirrors the pattern in Karpathy's LLM Wiki (index.md + log.md, create-vs-enrich, lint for orphans). Deferred from that pattern until scale warrants: an explicit page-type schema, and hybrid FTS5+embedding search (the naive scan in search.ts is fine into the low thousands of concepts).
Tests
pnpm test # core: 18 tests (spec Β§5/Β§6/Β§7/Β§9, sandbox, search, concurrency)
pnpm --filter @understory/server exec tsx scripts/mcp-smoke.mts # MCP stdio round-trip (needs SMOKE_BUNDLE + an API key)Environment
See .env.example. BUNDLE_ROOT is required; GIT_AUTOCOMMIT=true commits every mutation.
LICENSE
Shown as plain text.
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2026 Anirban Kar
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
101 files Β· 98 not served here
- .dockerignore (not served here)
- .env.example (not served here)
- .github/workflows/docker.yml (not served here)
- .gitignore (not served here)
- ATTRIBUTION.md
- Dockerfile (not served here)
- LICENSE
- README.md
- docker-compose.portainer.yml (not served here)
- docker-compose.yml (not served here)
- package.json (not served here)
- packages/core/package.json (not served here)
- packages/core/src/agent/agent.ts (not served here)
- packages/core/src/agent/cli.ts (not served here)
- packages/core/src/agent/dream.ts (not served here)
- packages/core/src/agent/hot-memory.ts (not served here)
- packages/core/src/agent/index.ts (not served here)
- packages/core/src/agent/query-cache.ts (not served here)
- packages/core/src/agent/system-prompt.ts (not served here)
- packages/core/src/agent/tools.ts (not served here)
- packages/core/src/agent/trace.ts (not served here)
- packages/core/src/index.ts (not served here)
- packages/core/src/okf/bundle.ts (not served here)
- packages/core/src/okf/frontmatter.ts (not served here)
- packages/core/src/okf/graph.ts (not served here)
- packages/core/src/okf/index.ts (not served here)
- packages/core/src/okf/indexer.ts (not served here)
- packages/core/src/okf/knowledge-base.ts (not served here)
- packages/core/src/okf/lint.ts (not served here)
- packages/core/src/okf/logger.ts (not served here)
- packages/core/src/okf/search.ts (not served here)
- packages/core/src/okf/types.ts (not served here)
- packages/core/src/okf/validate.ts (not served here)
- packages/core/src/providers/fallback.ts (not served here)
- packages/core/src/providers/index.ts (not served here)
- packages/core/src/providers/transport.ts (not served here)
- packages/core/src/util/duration.ts (not served here)
- packages/core/test/agent.test.ts (not served here)
- packages/core/test/dream.test.ts (not served here)
- packages/core/test/hot-memory.test.ts (not served here)
- packages/core/test/okf.test.ts (not served here)
- packages/core/test/providers.test.ts (not served here)
- packages/core/test/query-cache.test.ts (not served here)
- packages/core/test/stream-tool-calls.test.ts (not served here)
- packages/core/test/tools-frontmatter.test.ts (not served here)
- packages/core/test/trace-usage.test.ts (not served here)
- packages/core/test/transport.test.ts (not served here)
- packages/core/tsconfig.json (not served here)
- packages/server/bin/ustory (not served here)
- packages/server/package.json (not served here)
- packages/server/scripts/mcp-smoke.mts (not served here)
- packages/server/scripts/seed-refresh-test.mts (not served here)
- packages/server/src/admin.ts (not served here)
- packages/server/src/api/browse.ts (not served here)
- packages/server/src/api/chat.ts (not served here)
- packages/server/src/app.ts (not served here)
- packages/server/src/auth.ts (not served here)
- packages/server/src/dreamer.ts (not served here)
- packages/server/src/host.ts (not served here)
- packages/server/src/index.ts (not served here)
- packages/server/src/mcp/http.ts (not served here)
- packages/server/src/mcp/seed.ts (not served here)
- packages/server/src/mcp/server.ts (not served here)
- packages/server/src/mcp/stdio.ts (not served here)
- packages/server/src/profiles-cli.ts (not served here)
- packages/server/src/profiles.ts (not served here)
- packages/server/test/auth.test.ts (not served here)
- packages/server/test/chat-abort.test.ts (not served here)
- packages/server/test/mcp/seed.test.ts (not served here)
- packages/server/test/profiles.test.ts (not served here)
- packages/server/tsconfig.json (not served here)
- packages/server/tsconfig.test.json (not served here)
- packages/web/index.html (not served here)
- packages/web/package.json (not served here)
- packages/web/postcss.config.js (not served here)
- packages/web/src/App.tsx (not served here)
- packages/web/src/api.ts (not served here)
- packages/web/src/components/ChatPanel.tsx (not served here)
- packages/web/src/components/ConceptView.tsx (not served here)
- packages/web/src/components/GraphView.tsx (not served here)
- packages/web/src/components/LogView.tsx (not served here)
- packages/web/src/components/MarkdownRenderer.tsx (not served here)
- packages/web/src/components/MermaidDiagram.tsx (not served here)
- packages/web/src/components/Tree.tsx (not served here)
- packages/web/src/index.css (not served here)
- packages/web/src/main.tsx (not served here)
- packages/web/tailwind.config.js (not served here)
- packages/web/tsconfig.json (not served here)
- packages/web/vite.config.ts (not served here)
- pnpm-lock.yaml (not served here)
- pnpm-workspace.yaml (not served here)
- sample-bundle/apis/billing-api.md (not served here)
- sample-bundle/apis/index.md (not served here)
- sample-bundle/index.md (not served here)
- sample-bundle/log.md (not served here)
- sample-bundle/playbooks/index.md (not served here)
- sample-bundle/playbooks/oncall-billing.md (not served here)
- sample-bundle/tables/customers.md (not served here)
- sample-bundle/tables/index.md (not served here)
- scripts/dev-server.sh (not served here)
- tsconfig.base.json (not served here)
Advantages
- The memory is stored as plain markdown files, making it human-readable, portable, and easily diffable in git. evidence: README.md
- Deterministic maintenance tools automatically resolve graph rot like orphaned concepts and broken links. evidence: README.md
- Supports isolated memory profiles, allowing one server to manage multiple distinct knowledge bases securely. evidence: README.md
Limitations
- The current search implementation is a naive scan, which may become inefficient as the number of concepts grows into the thousands. evidence: README.md
- Requires an external LLM provider to perform reasoning and tool-calling tasks. evidence: README.md
Security
Risk level: No risk found
This brain runs
This brain runs nothing: AutoGineer found no hooks, scripts, plugin code or MCP servers in its files.
Attribution and licence
- First committed by
thecodacus
- Publisher
- Anirban Kar (Community)
- Source
- thecodacus/understory Β· commit 7625aa4
- Licence
- Apache License 2.0 (files served here)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
- Contributors
- thecodacus, michaelherold, Lathly, Piggidragon, TheAmericanMaker
AutoGineer is not affiliated with or endorsed by thecodacus.
Install from source
98 of its files are not served here, so there is no ZIP. thecodacus/understory at 7625aa4