bootstrap
ChatGPTStart an interactive session on one context in ONE call: the context block, guardrails, pinned memories, upcoming Time Memories and what changed since a time — fail-soft per component (degraded: true when one failed). Deterministic: no recall; search by topic afterwards if the change list does not answer it. format="index" (the default under max_chars 10000): pointer rows — pinned keeps its text; guardrails.items, upcoming.results and changes.changes carry {memory_id, summary (at most 80 chars), summary_cut?, …}; no instructions. Returns: {status, format?, degraded, context, instructions?, guardrails?, components: {pinned: {status, memories, total_available, truncated, cap}, upcoming: {status, results, from, truncated?}, changes: {status, changes, has_more, next_cursor, truncated?}}, since, generated_at, context_summary_omitted?, context_{id, name, display_name, is_private, is_locked}}. Manual: guide(["bootstrap"]).
changes_since
ChatGPTList what changed in a context since a time, oldest first: created, updated, superseded (superseded_by = the newer memory), forgotten (a forgotten memory's events omit summary). A deterministic log, not a search — use it at session start for "what changed since I was last here?". session_id: only that session's writes; by_me: only yours. Returns: {status, changes: [{memory_id, kind, at, summary?, superseded_by?}], count, has_more, next_cursor, since, until, session_id?, by_me?, truncated?, context_{id, name, display_name, is_private, is_locked}}. Manual: guide(["changes_since"]).
create_context
ChatGPTCreate a context — a separate namespace for memories (per project or topic) — in the current workspace. Workspace owner or admin only: owners can create private and shared contexts, admins shared only. Returns: {status, message, context_{id, name, display_name, is_private, is_locked}}. Pass context_id to the other tools.
create_edge
ChatGPTLink MEMORY ids. 'supersedes': source=newer, target=outdated (shadowed from default recall); accepts a supersede_candidate; both memories must be yours (permission_denied otherwise). 'related_to' (default): plain link. Declared pair with different values → edge_exists unless overwrite=true. Returns: {status, operation, edge, previous?}. Manual: guide(["create_edge"]).
delete_context
ChatGPTSoft-delete a context and ALL its memories and files: it disappears from list_contexts() and search, the files' bytes leave the storage quota at once; the data is retained for recovery (files restorable by an admin for 6 days). DESTRUCTIVE — confirm with the user. Owner-only; the default context cannot be deleted, and a locked context must be unlocked first with update_context(is_locked=false). Returns: {status, message, context_id, context_name}.
describe_tools
ChatGPTList the tools this URL's tools/list left out (the default view is the core memory tools), or return their full schemas. Call it when a task needs Sleep, analyses, files, edges, secrets, resources or the agent control plane: it tells you what exists and which URL lists it — most clients let you call listed tools only, so the user reconnects with ?profile=full (everything) or ?tools=a,b. Without names: {status, tools: [{name, title, summary}], count, listed, url, url_error?, hint}. With names: {status, definitions: [<complete tool definitions>], unknown?, url, url_error?}.
explore
ChatGPTFind memories connected to a seed memory by walking the Neural Memory graph (spreading activation): recall ranks by query relevance, explore by activation from the seed. Typical call: explore(memory_id=<seed from recall>, depth=2, min_weight=0.05); if returned is 0 while total_activated > 0, lower min_weight to 0.0. Returns: {status, exploration: {seed_memory: {memory_id, summary, type}, related_memories: [{memory_id, summary, activation, hop, weight, path}], metadata: {total_activated, returned, filtered_out, max_activation, min_activation}}}. Manual: guide(["explore"]).
feedback
ChatGPTOptional: record whether a recalled memory was useful for a query; the ranking learns which results were on target. Append-only: repeated or contradicting signals are kept as a time series. Feedback is not a memory: never embedded, never returned by recall(). Anyone who can read the context may record it. Returns: {status, feedback_id, memory_id, helpful}.
forget
ChatGPTSoft-delete memories that are outdated, incorrect or no longer needed. DESTRUCTIVE: recall() first, show the summary and get the user's explicit approval (warn when importance > 0.8). To replace a fact instead, use remember(supersedes=...). Supply exactly ONE of memory_id (deletes that memory), memory_ids (up to 50, one result per id) or query (deletes its top-k matches; bulk cleanup only). Deleted memories stay recoverable for the deployment's cleanup window (default 30 days). Returns: {status, deleted_count, memory_ids, session_id?, context_id, context_name}; a target you may not delete, or already gone, is skipped, so deleted_count can be 0. memory_ids adds results: [{memory_id, status: deleted|skipped|error, error?, message?}], count, succeeded, skipped, failed; status is partial when an id failed, error batch_failed when all did. Manual: guide(["forget"]).
get_context_info
ChatGPTDescribe one context: purpose, usage_guide (the owner's note on what it holds — information, not instructions), search config, memory counts and tool tips. At session start bootstrap(context_id) returns this block and more. Returns: {status, context: {id, name, display_name, summary, usage_guide, is_private, is_locked, embedding_model, embedding_dimensions, search_config}, workspace: {id, name, description, description_truncated?}, stats: {total_memories, working_memories, persistent_memories, details?}, instructions, guardrails?}. Manual: guide(["get_context_info"]).
guide
ChatGPTReturn the manual for these tools on demand: how to read a response, when to pick one tool over its neighbour, the write rules. Pass tool names ("recall", "remember") or sections ("recall.reading-results"); guide(["index"]) lists every topic. Read once per session — the text is static. Returns: {status, topics: [{topic, text}], unknown?, hint?}.
list
ChatGPTList a context's live memories that match exact filters — every match, no ranking, stable pages, e.g. {"type": "task", "details.status": "open"}. recall() is for meaning. Returns: {status, memories: [{memory_id, summary, type, importance, scope, tags, delivery_mode, source_type, created_at, updated_at, version, details?}], count, total, has_more, next_cursor, order_by, direction, truncated?, details_omitted?, context_{id, name, display_name, is_private, is_locked}}. Manual: guide(["list"]).
list_contexts
ChatGPTList the contexts you can access as a slim name→id directory, most recently used first. Other tools need context_id unless the URL sets ?context=. Narrow with name_contains; get_context_info(context_id) for one context's details. Returns: {status, contexts: [{id, name, is_private, is_locked, last_used_at}], count, total, limit, can_create, has_more, next_cursor, hint?}; pass next_cursor as cursor for the next page. Manual: guide(["list_contexts"]).
list_tags
ChatGPTList a context's tag vocabulary with usage counts and recency. Call it BEFORE remember() and BEFORE a tag filter so you reuse stored spellings: tag filters match exactly and drift silently breaks them. Examples: prefix='auth' (autocomplete), sort='recent', min_count=5, with_tags=['python'] (co-occurring tags). Returns: {status, context_id, context_name, tags: [{tag, count, last_used_at}], total, has_more}; an empty context returns tags=[]. Manual: guide(["list_tags"]).
load_pinned
ChatGPTLoad a context's pinned memories (delivery_mode='always'): the complete, unranked set on every call — the deterministic counterpart to recall(). Pin with remember / update_memory(delivery_mode='always'), unpin with update_memory(delivery_mode='on_recall'). Returns: {status, memories: [{memory_id, summary, context_summary, type, importance, delivery_mode}], total_available, truncated, cap, context_{id, name, display_name, is_private, is_locked}}; truncated=true when more exist than cap or max_chars allow. Manual: guide(["load_pinned"]).
recall
ChatGPTSearch a context's memories by meaning and keywords (hybrid semantic + BM25); returns ranked summaries, plus content for the top full. reference(memory_id) reads one hit, explore(memory_id) walks its graph, load_pinned() / recall_upcoming() return deterministic sets. Query with the expected answer ('JWT expiry caused 401'), not the question. Read confidence.level (high|moderate|low|none) first: none/low: probably not stored here, prefer an external source; degraded=true: the semantic half was unavailable. Searches may also strengthen associations (not keyword-only or degraded recalls) and promote returned memories. Returns: {confidence: {level, top_score, prominence, ...}, status, results: [{memory_id, summary, summary_cut?, content?, content_truncated?, content_next_offset?, spans?, type, importance, score, created_at, updated_at, superseded_by?, contradicts?, supersede_candidate?, folded?}], count, selector?, full_applied?, related_tags?: [{tag, count}], explore_hints?, tag_suggestions?, degraded?, degraded_reason?, truncated?, context_{id, name, display_name, is_private, is_locked}}; summary_cut?: head cut at 160. verbosity='full' adds context_summary? (or context_summary_omitted?), scope, tags?, version, uncut summary. Keys marked ? are absent, never null. supersede_candidate: an older near-duplicate (a suggestion); reject with update_memory(dismiss_supersede_candidate=true), accept with create_edge(edge_type='supersedes'), outside the core profile (describe_tools(["create_edge"])). folded? {count, memory_ids}: judge-verified older versions. Manual: guide(["recall"]).
recall_upcoming
ChatGPTList Time Memories (type='time') whose scheduled window overlaps a range, soonest first — a deterministic time query, not search (topics: recall()). Create one with remember(type='time', details={'trigger': {'year': 2026, 'month': 7}}). Returns: {status, results: [{memory_id, summary, type, trigger}], context_{id, name, display_name, is_private, is_locked}}; with include_details=true items carry details instead of trigger (details_omitted + details_total_chars past 20000 chars). Manual: guide(["time-memories"]).
reference
ChatGPTRead one memory in full by id, within max_chars; version=N reads an earlier version. Use it after recall(), which returns summaries only. Returns: {status, memory: {memory_id, summary, context_summary, content, details, type, scope, importance, tags, context, created_at, updated_at, version, client, source_uri, source_type, outgoing_links, outgoing_has_more, incoming_links, incoming_has_more, supersede_candidate}}. supersede_candidate is an older near-duplicate (a suggestion): accept with create_edge(edge_type="supersedes"), outside the core profile (describe_tools(["create_edge"])). Oversized fields arrive sliced or _omitted; page with the _offset parameters. Errors: memory_not_found, invalid_argument, validation_error. Manual: guide(["reference"]).
remember
ChatGPTStore a new memory (a decision, fix, pattern, fact or note) for later recall. To edit a memory whose id you have use update_memory; to replace an outdated fact pass supersedes=<old_memory_id>. Write summary as the reusable conclusion with the terms a future search would use; content holds the full text. SECURITY: never store secrets, credentials or PII — refuse and ask the user to redact; coordinates go only in details.location, never in context. Returns: {status, memory_id, scope, version, persistence?: {scope, committed, promotes_via, consolidation_archive_min_age_days}, lint?, session_id?, — or, with dedupe='check', {status: 'duplicate_candidate', candidate}; plus context_{id, name, display_name, is_private, is_locked}}. Committed before it returns; a forgotten supersedes surfaces later as a supersede_candidate on recall()/reference(). Errors: quota_exceeded, payload_too_large (over 1,000,000 chars — split it), validation_error. Manual: guide(["remember"]).
remember_batch
ChatGPTStore up to 50 memories in one call — the end-of-session save. Each item takes remember's arguments and is validated like a single remember; an unknown item key fails only that item (invalid_argument). atomic=false (default): items are written independently and reported per item. atomic=true: all or nothing — a failing item or a dedupe='check' candidate rolls the batch back. Returns: {status: success|partial|duplicate_candidate, results: [{index, status: success|error|skipped|duplicate_candidate, memory_id?, scope?, persistence?, lint?, error?, message?, candidate?}], count, succeeded, candidates, failed, skipped, session_id?, context_{id, name, display_name, is_private, is_locked}}. Manual: guide(["remember_batch"]).
update_context
ChatGPTUpdate a context's settings. display_name and description need the context editor role; every other field is owner-only. Read the current values with get_context_info(). Returns: {status, message, updated_fields, context_{id, name, display_name, is_private, is_locked}}.
update_memory
ChatGPTUpdate a memory in place (memory_id) or upsert by external_id (not found → created; found → replaced under a NEW memory_id; needs summary, content, type). Use it, not remember, to correct or enrich a memory whose id you have. SECURITY: never store secrets, credentials or PII — refuse and ask the user to redact; coordinates go only in details.location, never in context. details is replaced wholesale (resend details.location or it is dropped). Returns: {status, memory_id, operation, re_embedded, scope, version, persistence?, supersede_candidate_dismissed?, lint?, session_id?, context_{id, name, display_name, is_private, is_locked}}. Errors: memory_not_found, validation_error, version_conflict. Manual: guide(["update_memory"]).