> ## Documentation Index
> Fetch the complete documentation index at: https://docs.nora.my/llms.txt
> Use this file to discover all available pages before exploring further.

# Wiki memory

> Markdown notes both people and the Agent write: long-lived team knowledge and standing procedures.

export const DocImage = ({src, alt, width, caption}) => <Frame caption={caption}>
    <img src={src} width={width} style={{
  padding: "8px 0"
}} alt={alt} />
  </Frame>;

**Wiki memory** is a markdown notebook shared by people and the Agent. Like a team wiki: long-lived, edited in-place, and retrieved by semantic search.

## When to use it

* Standing operating procedures: "always look up the order status before starting a refund"
* Team knowledge that isn't in any external doc: tone, exception-handling patterns, tribal decisions
* Findings the Agent needs to keep referencing across runs

<DocImage src="/images/docs/memory-wiki-note.png" alt="Wiki space with notes: left-hand note list, right-hand markdown editor" />

## Creating one

**Memory → New space → Wiki (notes)** creates one immediately. See [Memory overview → Creating a space](/build/memory/overview#creating-a-space) for the full flow.

## The detail page

Opening a Wiki shows:

* **Notes** tab: note list on the left, markdown editor on the right. A filter at the top narrows by scope.
* **Log** tab: every event in chronological order (see below).
* **Settings** tab: covered below.

The editor has three fields:

* **Path** optional. The address the Agent references the note by. Rendered in monospace; use a folder-style path like `docs/refund-policy` to group related notes.
* **Title** optional. Human-facing name.
* **Body** markdown. An edit/preview toggle at the top of the editor lets you check the rendered output.

Saving refreshes the retrieval embedding automatically.

## What you configure in Settings

**Basics** rename the space. Paradigm (Wiki) is fixed at creation.

**Flow binding** bind the space to a specific Flow and every Agent in that Flow reads/writes it automatically. Leave unbound and you attach it per-Agent in the flow builder.

**Scope** which request parameters partition notes. Combine `flow_id` / `thread_id` / `user_id` / custom keys. See [Scoping](/build/memory/scoping).

**Access** (optional) a partition key (auto-filter by caller identity) and a required-permissions gate to lock access at the space level. See [Scoping → Access control](/build/memory/scoping#access-control-optional).

**Memory agent (curator)** the agent that manages this Wiki. Decides what to keep, grow, and retire.

* **Model** runs extraction and consolidation. Pick from providers with keys registered in the workspace. Leave blank for a low-cost default.
* **Policy prompt** free-text instructions for what to save vs discard. Example: *"Keep stable customer preferences and decisions; discard chitchat; if a preference changes, supersede the old one."*
* **Multimodal** how images, audio, and video reach memory (`reuse` / `reference` / `re-analyze`). `Re-analyze` costs extra.
* **Background writes** when on, saves and deletes happen off the response path so latency isn't affected. Reads are always synchronous. Recommended on.

## Attaching to an Agent

In the flow builder, open the Agent, go to the **Memory** tab, and click **Add memory**. Cap runaway cost with **Max memory cost** on the same tab. If the whole Flow should share one Wiki, use **Flow binding** in the space's Settings instead.

## How notes get written

Three paths:

**The memory agent, automatically** at the end of a run, the curator picks what to keep per the **policy prompt** above. Most notes land this way with no intervention.

**The Agent explicitly** instruct the Agent in its system prompt to save findings. Shows up in the trace as a tool call, gives you tight prompt-level control over what gets saved.

**You directly, or via CLI** write notes by hand from the Wiki detail page, or script it with [`nora memory`](/cli/memory). Handy for pre-seeding known facts or migrating from an existing store.

## How notes get retrieved

Every model call from an Agent with the Wiki attached triggers a retrieval automatically. Similar to knowledge search, but scoped and with memory-tuned ranking.

* **Relevance** semantic distance between the query and the note
* **Recency** recent notes rank higher, then decay over time
* **Importance** high-importance notes float up

Tune retrieval per-Agent: in the Agent Inspector's **Memory** tab, each attached space has a **Retrieval preset** dropdown.

## Rule-style notes

For standing rules, write notes that spell out the trigger and the action clearly: the memory agent will surface them well.

```markdown theme={null}
# Refund handling rule

Trigger: user mentions `refund`
Action: always call `lookup_order` first to check refund eligibility.
```

Add "always include rule-style notes in context for related turns" to the policy prompt and rules will land in the prompt every turn. There's no built-in "rule" type: it's just a convention for markdown notes.

## Note maintenance

* **Edit** click a note → edit in the editor. Save refreshes the embedding.
* **Exclude from search** the `⋯` menu at the top-right of the editor → **Exclude from search**. Soft-deletes the note: it disappears from retrieval and a brief Undo toast lets you revert.
* **Dedupe** near-duplicate notes in the same scope are merged automatically. The Agent can't rewrite "Alice prefers email" five times.

See [Forgetting](/build/memory/forgetting) for the full clean-up story.

## Watching writes in the trace

Draft runs show every memory read and write in the trace view.

* Reads: query, top-N items returned, scope
* Writes: content, scope, whether it was a new item or a dedupe update

Handy for checking memory behaviour on a Draft before publishing.