Explain how to use this server effectively — the intended workflow for sessions and documents. Call this once if you have not used these tools before.

Start or resume a named memory session. Call this ONCE at the beginning of any task that will run long enough to risk losing earlier details, then reuse the same session_id for every later call. Returns what is already stored, so resuming a session after a restart tells you what you previously knew.

Record something worth remembering into the session. Use this as you go — after discovering a fact, making a decision, or hitting a dead end — rather than trying to hold it all in your reply. Keep each entry self-contained: it may be read back much later without the surrounding conversation. Set pinned for facts that must never be dropped during compaction, such as the goal or a hard constraint.

Retrieve the most relevant stored entries for a query, packed to fit a token budget. This is the main way to get memory back into your working context: ask for what you need rather than reading the whole session. Pinned entries are always included. Omit the query to get the most recent entries instead.

Fold older entries into a single summary to free budget, keeping the most recent entries verbatim. Call this when context_status or context_append warns that the session is over budget. Pinned entries are never compacted. The originals are kept on disk and can be recovered, so this is safe to run. Use dry_run first to see what would happen.

Report how full a session is, what is pinned, and whether compaction is advisable. Cheap to call — use it to decide whether you need to compact before adding more.

Pin, unpin, or delete a single entry by its id. Pin what must survive compaction; delete what turned out to be wrong, so it stops polluting recall.

List stored sessions, newest first. Use this to find a session id from earlier work when you do not remember it.

Load a large text into the store and split it into addressable chunks. Use this INSTEAD OF reading a big file into your context: the content stays on disk and you page through it with doc_outline, doc_search and doc_window. Accepts inline text, or a file path if the server was started with an ingest root. Returns a document id.

Show the structure of an ingested document: every chunk with its index, heading and size. Call this right after doc_ingest to decide what is worth reading. Set summarize to also generate a one-line summary per chunk — more useful, but it runs the summarizer once per chunk, so it is slow on large documents.

Read a range of chunks verbatim. This is the sliding window: ask for chunks 0-2, then 3-5, and so on, keeping each read inside your budget. Omit from/to to continue from where the last window left off — the read cursor is stored server-side, so sequential paging works without you tracking position.

Find the chunks of a document most relevant to a query and return them verbatim, packed into a token budget. Prefer this over paging when you know what you are looking for — it is the difference between reading a manual and using its index. Omit doc_id to search across every ingested document.

Summarize a whole document or a range of its chunks. Use this to get the gist of something too large to read, before deciding which parts to pull verbatim. The whole-document summary is cached, so asking again is free.

List ingested documents with their ids, sizes and read positions.

Permanently delete an ingested document and everything derived from it. Use when a document is stale or was ingested by mistake.