MCP App Store
by KeenEthics
Kagura Memory Cloud icon

Kagura Memory Cloud MCP Server for ChatGPT

By Kagura AI, Inc.

Overview

Kagura Memory Cloud gives ChatGPT and Codex a persistent project memory. Restore the context of a project at the start of a session, recall past decisions, bug fixes and lessons by meaning, save reusable knowledge as you work, and keep standing guardrails and dated follow-ups in one place. Memory is organised in contexts (one per project or team), searched with hybrid semantic and keyword retrieval, and linked as a graph you can explore. Every memory carries its provenance, so an agent can tell trusted notes from connector-ingested content. Secrets are never stored as memories. Sign in with your Kagura Memory Cloud account; the plugin reads and writes only the contexts you have access to.

How to connect

  1. ChatGPT: Open the Kagura Memory Cloud listing in the ChatGPT app directory and choose Connect. ChatGPT listing Kagura Memory Cloud exposes 21 tools here.

Tools

bootstrap

ChatGPT
Start 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

ChatGPT
List 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

ChatGPT
Create 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

ChatGPT
Link 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

ChatGPT
Soft-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

ChatGPT
List 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

ChatGPT
Find 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

ChatGPT
Optional: 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

ChatGPT
Soft-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

ChatGPT
Describe 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

ChatGPT
Return 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

ChatGPT
List 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

ChatGPT
List 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

ChatGPT
List 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

ChatGPT
Load 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

ChatGPT
Search 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

ChatGPT
List 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

ChatGPT
Read 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

ChatGPT
Store 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

ChatGPT
Store 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

ChatGPT
Update 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

ChatGPT
Update 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"]).

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/kagura-memory-cloud"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/kagura-memory-cloud)