AgenticMemory MCP

Provides persistent memory for AI agents including short-term message storage, semantic search, context key-value pairs, long-term entries, and FIFO queues via 17 tools over SSE.

Visit Tyga.Cloud Ltd.

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

Community listingLegacy SSENo sign-inEndpoint checked 2026-11-01Published by Tyga.Cloud Ltd.

You need:agmry signup <slug> Create account. Key returned immediately — fully active for a 7-day free trial.

MCP endpoint (Legacy SSE)

https://mcp.agenticmemory.ai/sse

Vendor documentation

What you can do with it

Store and recall agent conversation history
Perform semantic search on memory spaces
Manage context key-value pairs
Handle FIFO agent queues

Source and maintenance

Community listingRegistry 1.10.0

mcp-registry: io.github.jyswee/agenticmemory@1.10.0 Source repository Project website

Maintenance checked: Nov 1, 2026, 6:06 AM UTC

Protocol and capabilities

Server: agenticmemory 1.3.0
MCP protocol: 2025-06-18
Tools: 46 advertised
Resources: Not advertised
Resource templates: Not advertised
Prompts: Not advertised

Server-advertised capabilities

{
  "tools": {}
}

Tools

46 advertised

memory_store

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Store a message in conversation history. Use for remembering what just happened.

memory_store input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "content"
  ],
  "properties": {
    "role": {
      "type": "string",
      "description": "Role: user, assistant, system, tool (default: user)"
    },
    "content": {
      "type": "string",
      "description": "Message content"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

memory_store output schema

{
  "type": "object",
  "properties": {
    "_id": {
      "type": "string",
      "description": "Message ID"
    },
    "seq": {
      "type": "number",
      "description": "Monotonic sequence number within the space"
    },
    "role": {
      "type": "string",
      "description": "Message role: user, assistant, system, or tool"
    },
    "content": {
      "type": "string",
      "description": "Message text"
    },
    "spaceId": {
      "type": "string",
      "description": "Owning memory space ID"
    },
    "metadata": {
      "type": "object",
      "description": "Optional caller-supplied metadata"
    },
    "createdAt": {
      "type": "string",
      "description": "ISO 8601 creation timestamp"
    }
  }
}

memory_store annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

memory_store_batch

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Store multiple messages at once.

memory_store_batch input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "messages"
  ],
  "properties": {
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "messages": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "role": {
            "type": "string"
          },
          "content": {
            "type": "string"
          }
        }
      },
      "description": "Array of {role, content} messages"
    }
  }
}

memory_store_batch output schema

{
  "type": "object",
  "required": [
    "messages"
  ],
  "properties": {
    "messages": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "_id": {
            "type": "string",
            "description": "Message ID"
          },
          "seq": {
            "type": "number",
            "description": "Monotonic sequence number within the space"
          },
          "role": {
            "type": "string",
            "description": "Message role: user, assistant, system, or tool"
          },
          "content": {
            "type": "string",
            "description": "Message text"
          },
          "spaceId": {
            "type": "string",
            "description": "Owning memory space ID"
          },
          "metadata": {
            "type": "object",
            "description": "Optional caller-supplied metadata"
          },
          "createdAt": {
            "type": "string",
            "description": "ISO 8601 creation timestamp"
          }
        }
      },
      "description": "The stored messages"
    }
  }
}

memory_store_batch annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

memory_recall

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Recall recent messages from conversation history. Returns newest first.

memory_recall input schema

{
  "type": "object",
  "required": [
    "spaceId"
  ],
  "properties": {
    "limit": {
      "type": "number",
      "description": "Number of messages to return (default: 20)"
    },
    "before": {
      "type": "string",
      "description": "Cursor: return messages before this message ID"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

memory_recall output schema

{
  "type": "object",
  "required": [
    "messages"
  ],
  "properties": {
    "messages": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "_id": {
            "type": "string",
            "description": "Message ID"
          },
          "seq": {
            "type": "number",
            "description": "Monotonic sequence number within the space"
          },
          "role": {
            "type": "string",
            "description": "Message role: user, assistant, system, or tool"
          },
          "content": {
            "type": "string",
            "description": "Message text"
          },
          "spaceId": {
            "type": "string",
            "description": "Owning memory space ID"
          },
          "metadata": {
            "type": "object",
            "description": "Optional caller-supplied metadata"
          },
          "createdAt": {
            "type": "string",
            "description": "ISO 8601 creation timestamp"
          }
        }
      },
      "description": "Recalled messages, newest first"
    },
    "encrypted": {
      "type": "boolean",
      "description": "True if the space is end-to-end encrypted (content is ciphertext)"
    }
  }
}

memory_recall annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

memory_clear

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Clear all messages in a memory space.

memory_clear input schema

{
  "type": "object",
  "required": [
    "spaceId"
  ],
  "properties": {
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

memory_clear output schema

{
  "type": "object",
  "required": [
    "cleared"
  ],
  "properties": {
    "cleared": {
      "type": "boolean",
      "description": "True when messages were cleared"
    }
  }
}

memory_clear annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

memory_search

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Semantic search across past conversations. Finds by meaning, not keywords.

memory_search input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "query"
  ],
  "properties": {
    "tags": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Filter by tags"
    },
    "limit": {
      "type": "number",
      "description": "Max results (default: 10)"
    },
    "query": {
      "type": "string",
      "description": "Natural language search query"
    },
    "scope": {
      "type": "string",
      "description": "Search scope: all | messages | entries | entities"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "includeEntities": {
      "type": "boolean",
      "description": "Include entity matches in results"
    }
  }
}

memory_search output schema

{
  "type": "object",
  "required": [
    "results",
    "count"
  ],
  "properties": {
    "count": {
      "type": "number",
      "description": "Number of results returned"
    },
    "results": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "_id": {
            "type": "string",
            "description": "Matched entry ID"
          },
          "tags": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "score": {
            "type": "number",
            "description": "Relevance score (higher is closer)"
          },
          "title": {
            "type": "string",
            "description": "Entry title"
          },
          "content": {
            "type": "string",
            "description": "Entry body"
          }
        }
      },
      "description": "Matching entries ranked by semantic relevance"
    }
  }
}

memory_search annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

context_set

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Set a key-value context entry. Stores structured data (JSON or string).

context_set input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "key",
    "value"
  ],
  "properties": {
    "key": {
      "type": "string",
      "description": "Context key name"
    },
    "ttl": {
      "type": "number",
      "description": "Optional TTL in seconds"
    },
    "value": {
      "description": "Value to store (string, number, object, array)"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

context_set output schema

{
  "type": "object",
  "required": [
    "key"
  ],
  "properties": {
    "key": {
      "type": "string",
      "description": "The key that was set"
    },
    "value": {
      "description": "The stored value (string, number, object, or array)"
    }
  }
}

context_set annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

context_get

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Get a context value by key.

context_get input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "key"
  ],
  "properties": {
    "key": {
      "type": "string",
      "description": "Context key name"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

context_get output schema

{
  "type": "object",
  "required": [
    "key"
  ],
  "properties": {
    "key": {
      "type": "string",
      "description": "The requested key"
    },
    "value": {
      "description": "The stored value (string, number, object, or array)"
    },
    "encrypted": {
      "type": "boolean",
      "description": "True if the space is end-to-end encrypted (value is ciphertext)"
    }
  }
}

context_get annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

context_list

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

List all context keys and values in a space.

context_list input schema

{
  "type": "object",
  "required": [
    "spaceId"
  ],
  "properties": {
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

context_list output schema

{
  "type": "object",
  "required": [
    "context"
  ],
  "properties": {
    "context": {
      "type": "object",
      "description": "Map of every context key to its stored value"
    },
    "encrypted": {
      "type": "boolean",
      "description": "True if the space is end-to-end encrypted (values are ciphertext)"
    }
  }
}

context_list annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

context_delete

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Delete a context key.

context_delete input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "key"
  ],
  "properties": {
    "key": {
      "type": "string",
      "description": "Context key to delete"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

context_delete output schema

{
  "type": "object",
  "required": [
    "deleted"
  ],
  "properties": {
    "deleted": {
      "type": "boolean",
      "description": "True when the key was deleted"
    }
  }
}

context_delete annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

entries_list

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

List long-term memory entries. Filter by tags.

entries_list input schema

{
  "type": "object",
  "required": [
    "spaceId"
  ],
  "properties": {
    "tags": {
      "type": "string",
      "description": "Comma-separated tags to filter by"
    },
    "limit": {
      "type": "number",
      "description": "Max entries (default: 20)"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

entries_list output schema

{
  "type": "object",
  "required": [
    "entries"
  ],
  "properties": {
    "entries": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "_id": {
            "type": "string",
            "description": "Entry ID"
          },
          "tags": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Tags for filtering"
          },
          "type": {
            "type": "string",
            "description": "Entry type: extraction, summary, decision, or artifact"
          },
          "title": {
            "type": "string",
            "description": "Entry title"
          },
          "content": {
            "type": "string",
            "description": "Entry body"
          },
          "createdAt": {
            "type": "string",
            "description": "ISO 8601 creation timestamp"
          }
        }
      },
      "description": "Matching long-term entries"
    },
    "encrypted": {
      "type": "boolean",
      "description": "True if the space is end-to-end encrypted (content is ciphertext)"
    }
  }
}

entries_list annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

spaces_list

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

List all memory spaces owned by this API key.

spaces_list input schema

{
  "type": "object",
  "properties": {}
}

spaces_list output schema

{
  "type": "object",
  "required": [
    "spaces"
  ],
  "properties": {
    "spaces": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "_id": {
            "type": "string",
            "description": "Space ID (use as spaceId in other tools)"
          },
          "name": {
            "type": "string",
            "description": "Human-readable space name"
          },
          "slug": {
            "type": "string",
            "description": "URL-safe slug"
          },
          "usage": {
            "type": "object",
            "description": "Usage counters (message count, etc.)"
          },
          "config": {
            "type": "object",
            "description": "Space configuration (TTLs, limits, encoding)"
          },
          "createdAt": {
            "type": "string",
            "description": "ISO 8601 creation timestamp"
          }
        }
      },
      "description": "Every memory space owned by the caller"
    }
  }
}

spaces_list annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

spaces_create

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Create a new memory space.

spaces_create input schema

{
  "type": "object",
  "required": [
    "name",
    "slug"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Space name"
    },
    "slug": {
      "type": "string",
      "description": "URL-safe slug"
    }
  }
}

spaces_create output schema

{
  "type": "object",
  "required": [
    "space"
  ],
  "properties": {
    "space": {
      "type": "object",
      "properties": {
        "_id": {
          "type": "string",
          "description": "Space ID (use as spaceId in other tools)"
        },
        "name": {
          "type": "string",
          "description": "Human-readable space name"
        },
        "slug": {
          "type": "string",
          "description": "URL-safe slug"
        },
        "usage": {
          "type": "object",
          "description": "Usage counters (message count, etc.)"
        },
        "config": {
          "type": "object",
          "description": "Space configuration (TTLs, limits, encoding)"
        },
        "createdAt": {
          "type": "string",
          "description": "ISO 8601 creation timestamp"
        }
      }
    }
  }
}

spaces_create annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

queue_push

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Enqueue a JSON envelope onto a FIFO queue in a memory space. Use to send work/events to other agents sharing the space.

queue_push input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "queue",
    "envelope"
  ],
  "properties": {
    "queue": {
      "type": "string",
      "description": "Queue name (lowercase alphanumeric plus . _ : -, max 64 chars)"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "envelope": {
      "type": "object",
      "description": "JSON envelope to enqueue (opaque to the server)"
    }
  }
}

queue_push output schema

{
  "type": "object",
  "required": [
    "queued",
    "queue",
    "length"
  ],
  "properties": {
    "queue": {
      "type": "string",
      "description": "Queue name"
    },
    "length": {
      "type": "number",
      "description": "Queue length after the push"
    },
    "queued": {
      "type": "boolean",
      "description": "True when the envelope was enqueued"
    }
  }
}

queue_push annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

queue_pop

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dequeue the oldest envelope from a FIFO queue (returns null if empty). Set wait (max 25s) to long-poll for the next envelope.

queue_pop input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "queue"
  ],
  "properties": {
    "wait": {
      "type": "number",
      "description": "Long-poll seconds, 0-25 (default: 0 = return immediately)"
    },
    "queue": {
      "type": "string",
      "description": "Queue name"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

queue_pop output schema

{
  "type": "object",
  "required": [
    "queue"
  ],
  "properties": {
    "item": {
      "type": [
        "object",
        "null"
      ],
      "description": "The dequeued envelope, or null if the queue was empty"
    },
    "empty": {
      "type": "boolean",
      "description": "True when the queue was empty"
    },
    "queue": {
      "type": "string",
      "description": "Queue name"
    },
    "encrypted": {
      "type": "boolean",
      "description": "True if the space is end-to-end encrypted (item is ciphertext)"
    }
  }
}

queue_pop annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

queue_peek

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Peek at a queue without consuming: returns length and the head envelope.

queue_peek input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "queue"
  ],
  "properties": {
    "queue": {
      "type": "string",
      "description": "Queue name"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

queue_peek output schema

{
  "type": "object",
  "required": [
    "queue"
  ],
  "properties": {
    "head": {
      "type": [
        "object",
        "null"
      ],
      "description": "The head envelope without consuming it, or null if empty"
    },
    "queue": {
      "type": "string",
      "description": "Queue name"
    },
    "length": {
      "type": "number",
      "description": "Current queue length"
    }
  }
}

queue_peek annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

memory_bootstrap

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Load full context in one call: recent messages, entries, context, scratchpad. Run this at session start.

memory_bootstrap input schema

{
  "type": "object",
  "required": [
    "spaceId"
  ],
  "properties": {
    "query": {
      "type": "string",
      "description": "Semantic query for relevant entries"
    },
    "entries": {
      "type": "number",
      "description": "Number of entries to include (default: 10)"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "messages": {
      "type": "number",
      "description": "Number of messages to include (default: 20)"
    }
  }
}

memory_bootstrap output schema

{
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "description": "Current working state for the space"
    },
    "shared": {
      "type": "object",
      "description": "Shared world context visible to all agents in the space"
    },
    "entities": {
      "type": "array",
      "description": "Known entities in the space"
    },
    "llnPrimer": {
      "type": "string",
      "description": "LLN primer mode (inline, system, or none)"
    },
    "encryption": {
      "type": "string",
      "description": "Encryption mode: none, managed, or e2e"
    },
    "activeThreads": {
      "type": "array",
      "description": "Active conversation threads"
    },
    "recentEntries": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "_id": {
            "type": "string",
            "description": "Entry ID"
          },
          "tags": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Tags for filtering"
          },
          "type": {
            "type": "string",
            "description": "Entry type: extraction, summary, decision, or artifact"
          },
          "title": {
            "type": "string",
            "description": "Entry title"
          },
          "content": {
            "type": "string",
            "description": "Entry body"
          },
          "createdAt": {
            "type": "string",
            "description": "ISO 8601 creation timestamp"
          }
        }
      },
      "description": "Most recent long-term entries"
    },
    "recentMessages": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "_id": {
            "type": "string",
            "description": "Message ID"
          },
          "seq": {
            "type": "number",
            "description": "Monotonic sequence number within the space"
          },
          "role": {
            "type": "string",
            "description": "Message role: user, assistant, system, or tool"
          },
          "content": {
            "type": "string",
            "description": "Message text"
          },
          "spaceId": {
            "type": "string",
            "description": "Owning memory space ID"
          },
          "metadata": {
            "type": "object",
            "description": "Optional caller-supplied metadata"
          },
          "createdAt": {
            "type": "string",
            "description": "ISO 8601 creation timestamp"
          }
        }
      },
      "description": "Most recent messages"
    },
    "contextEncoding": {
      "type": "string",
      "description": "Context encoding mode (json or lln)"
    },
    "semanticEntries": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "_id": {
            "type": "string",
            "description": "Entry ID"
          },
          "tags": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Tags for filtering"
          },
          "type": {
            "type": "string",
            "description": "Entry type: extraction, summary, decision, or artifact"
          },
          "title": {
            "type": "string",
            "description": "Entry title"
          },
          "content": {
            "type": "string",
            "description": "Entry body"
          },
          "createdAt": {
            "type": "string",
            "description": "ISO 8601 creation timestamp"
          }
        }
      },
      "description": "Entries matched by the optional semantic query"
    }
  }
}

memory_bootstrap annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

memory_bootstrap_batch

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Parallel bulk fetch: named context keys, entities, and optional semantic results in one call.

memory_bootstrap_batch input schema

{
  "type": "object",
  "required": [
    "spaceId"
  ],
  "properties": {
    "keys": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Context keys to fetch"
    },
    "query": {
      "type": "string",
      "description": "Semantic query (with semantic=true)"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "entities": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Entity names to fetch"
    },
    "semantic": {
      "type": "boolean",
      "description": "Include semantic search results"
    },
    "entriesLimit": {
      "type": "number",
      "description": "Max entries to include"
    }
  }
}

memory_bootstrap_batch output schema

{
  "type": "object",
  "properties": {}
}

memory_bootstrap_batch annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

scratchpad_set

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Set the scratchpad content for a memory space (ephemeral working memory).

scratchpad_set input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "data"
  ],
  "properties": {
    "data": {
      "description": "Scratchpad data (any JSON-serializable value)"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

scratchpad_set output schema

{
  "type": "object",
  "properties": {}
}

scratchpad_set annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

scratchpad_get

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Get the scratchpad content from a memory space.

scratchpad_get input schema

{
  "type": "object",
  "required": [
    "spaceId"
  ],
  "properties": {
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

scratchpad_get output schema

{
  "type": "object",
  "properties": {}
}

scratchpad_get annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

spaces_get

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Get a single memory space (config, usage counters).

spaces_get input schema

{
  "type": "object",
  "required": [
    "spaceId"
  ],
  "properties": {
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

spaces_get output schema

{
  "type": "object",
  "properties": {
    "space": {
      "type": "object",
      "properties": {
        "_id": {
          "type": "string",
          "description": "Space ID (use as spaceId in other tools)"
        },
        "name": {
          "type": "string",
          "description": "Human-readable space name"
        },
        "slug": {
          "type": "string",
          "description": "URL-safe slug"
        },
        "usage": {
          "type": "object",
          "description": "Usage counters (message count, etc.)"
        },
        "config": {
          "type": "object",
          "description": "Space configuration (TTLs, limits, encoding)"
        },
        "createdAt": {
          "type": "string",
          "description": "ISO 8601 creation timestamp"
        }
      }
    }
  }
}

spaces_get annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

space_export

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Export all data in a space (all primitives, schema v2) as a restorable payload.

space_export input schema

{
  "type": "object",
  "required": [
    "spaceId"
  ],
  "properties": {
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

space_export output schema

{
  "type": "object",
  "properties": {}
}

space_export annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

space_import

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Restore a space from an export payload. Mode: empty-only (default), merge, or replace.

space_import input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "payload"
  ],
  "properties": {
    "mode": {
      "enum": [
        "empty-only",
        "merge",
        "replace"
      ],
      "type": "string",
      "description": "Import mode (default empty-only)"
    },
    "payload": {
      "type": "object",
      "description": "Export payload (from space_export)"
    },
    "spaceId": {
      "type": "string",
      "description": "Target memory space ID"
    }
  }
}

space_import output schema

{
  "type": "object",
  "properties": {}
}

space_import annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

entry

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Single-entry operations on the tagged/versioned journal: add, get, update, versions, restore.

entry input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "action"
  ],
  "properties": {
    "tags": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Tags (add/update)"
    },
    "type": {
      "type": "string",
      "description": "Entry type: extraction | summary | decision | artifact (add)"
    },
    "title": {
      "type": "string",
      "description": "Entry title (add)"
    },
    "action": {
      "enum": [
        "add",
        "get",
        "update",
        "versions",
        "restore"
      ],
      "type": "string",
      "description": "Operation"
    },
    "reason": {
      "type": "string",
      "description": "Reason for the update (update)"
    },
    "source": {
      "type": "string",
      "description": "Source attribution (add/update)"
    },
    "content": {
      "type": "string",
      "description": "Entry body (add/update)"
    },
    "entryId": {
      "type": "string",
      "description": "Entry ID (required for get/update/versions/restore)"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "version": {
      "type": "number",
      "description": "Version number to restore (restore)"
    }
  }
}

entry output schema

{
  "type": "object",
  "properties": {}
}

entry annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

entries_add_batch

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Append multiple journal entries in one call.

entries_add_batch input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "entries"
  ],
  "properties": {
    "entries": {
      "type": "array",
      "items": {
        "type": "object"
      },
      "description": "Array of {title, content, type?, tags?, source?} entries"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

entries_add_batch output schema

{
  "type": "object",
  "properties": {}
}

entries_add_batch annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

entity

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Entity (knowledge-graph node) operations: upsert (create), get, update, delete.

entity input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "action",
    "name"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Entity name"
    },
    "role": {
      "type": "string",
      "description": "Entity role (upsert)"
    },
    "knows": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Facts this entity knows (upsert/update)"
    },
    "action": {
      "enum": [
        "upsert",
        "get",
        "update",
        "delete"
      ],
      "type": "string",
      "description": "Operation"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "doesNotKnow": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Facts this entity does NOT know (upsert/update)"
    }
  }
}

entity output schema

{
  "type": "object",
  "properties": {}
}

entity annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

entities_list

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

List entities in a memory space, optionally filtered.

entities_list input schema

{
  "type": "object",
  "required": [
    "spaceId"
  ],
  "properties": {
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "namePrefix": {
      "type": "string",
      "description": "Filter by name prefix"
    },
    "knowsContains": {
      "type": "string",
      "description": "Filter: entities that know this fact"
    }
  }
}

entities_list output schema

{
  "type": "object",
  "properties": {}
}

entities_list annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

thread

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Thread (conversation grouping) operations: create, get, update, delete.

thread input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "action"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Thread name (create/update)"
    },
    "action": {
      "enum": [
        "create",
        "get",
        "update",
        "delete"
      ],
      "type": "string",
      "description": "Operation"
    },
    "status": {
      "type": "string",
      "description": "Thread status (update)"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "summary": {
      "type": "string",
      "description": "Thread summary (update)"
    },
    "metadata": {
      "type": "object",
      "description": "Metadata (create)"
    },
    "threadId": {
      "type": "string",
      "description": "Thread ID (required for get/update/delete)"
    }
  }
}

thread output schema

{
  "type": "object",
  "properties": {}
}

thread annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

threads_list

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

List threads in a memory space, optionally filtered by status.

threads_list input schema

{
  "type": "object",
  "required": [
    "spaceId"
  ],
  "properties": {
    "status": {
      "type": "string",
      "description": "Filter by status"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

threads_list output schema

{
  "type": "object",
  "properties": {}
}

threads_list annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

state_get

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Get a space's single JSON state snapshot.

state_get input schema

{
  "type": "object",
  "required": [
    "spaceId"
  ],
  "properties": {
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

state_get output schema

{
  "type": "object",
  "properties": {}
}

state_get annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

state_set

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Replace a space's single JSON state snapshot.

state_set input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "state"
  ],
  "properties": {
    "state": {
      "type": "object",
      "description": "The full state object (replaces existing)"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

state_set output schema

{
  "type": "object",
  "properties": {}
}

state_set annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

shared_memory

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Shared world-memory (one-write, all-see) operations: set, get, list, delete.

shared_memory input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "action"
  ],
  "properties": {
    "key": {
      "type": "string",
      "description": "Shared key (required for set/get/delete)"
    },
    "ttl": {
      "type": "number",
      "description": "TTL in seconds (set)"
    },
    "value": {
      "description": "Value to set (set)"
    },
    "action": {
      "enum": [
        "set",
        "get",
        "list",
        "delete"
      ],
      "type": "string",
      "description": "Operation"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

shared_memory output schema

{
  "type": "object",
  "properties": {}
}

shared_memory annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

queue_lease

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Non-destructive lease (at-least-once): take the oldest envelope with a visibility timeout. Returns {item, leaseToken, deadline}. Ack with queue_ack, requeue with queue_nack.

queue_lease input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "queue"
  ],
  "properties": {
    "wait": {
      "type": "number",
      "description": "Long-poll seconds, 0-25 (default 0)"
    },
    "queue": {
      "type": "string",
      "description": "Queue name"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "visibilitySeconds": {
      "type": "number",
      "description": "Visibility timeout before auto-requeue"
    }
  }
}

queue_lease output schema

{
  "type": "object",
  "properties": {}
}

queue_lease annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

queue_ack

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Acknowledge a leased envelope (deletes it permanently).

queue_ack input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "queue",
    "leaseToken"
  ],
  "properties": {
    "queue": {
      "type": "string",
      "description": "Queue name"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "leaseToken": {
      "type": "string",
      "description": "Lease token from queue_lease"
    }
  }
}

queue_ack output schema

{
  "type": "object",
  "properties": {}
}

queue_ack annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

queue_nack

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Negative-acknowledge a leased envelope (requeues it to the tail).

queue_nack input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "queue",
    "leaseToken"
  ],
  "properties": {
    "queue": {
      "type": "string",
      "description": "Queue name"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "leaseToken": {
      "type": "string",
      "description": "Lease token from queue_lease"
    }
  }
}

queue_nack output schema

{
  "type": "object",
  "properties": {}
}

queue_nack annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

queue_dlq

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Dead-letter queue operations: push a failed envelope, or list DLQ items.

queue_dlq input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "queue",
    "action"
  ],
  "properties": {
    "limit": {
      "type": "number",
      "description": "Max items (list)"
    },
    "queue": {
      "type": "string",
      "description": "Queue name"
    },
    "action": {
      "enum": [
        "push",
        "list"
      ],
      "type": "string",
      "description": "Operation"
    },
    "offset": {
      "type": "number",
      "description": "Offset (list)"
    },
    "reason": {
      "type": "string",
      "description": "Failure reason (push)"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "envelope": {
      "type": "object",
      "description": "Envelope to dead-letter (push)"
    }
  }
}

queue_dlq output schema

{
  "type": "object",
  "properties": {}
}

queue_dlq annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

stream_append

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Append an entry to a stream (XADD). Returns the entry ID.

stream_append input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "stream",
    "data"
  ],
  "properties": {
    "data": {
      "type": "object",
      "description": "Entry data (flat object)"
    },
    "maxlen": {
      "type": "number",
      "description": "Approximate max stream length (trim)"
    },
    "stream": {
      "type": "string",
      "description": "Stream name"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

stream_append output schema

{
  "type": "object",
  "properties": {}
}

stream_append annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

stream_read

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Ranged read from a stream (XRANGE/XREVRANGE).

stream_read input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "stream"
  ],
  "properties": {
    "end": {
      "type": "string",
      "description": "End ID (default +)"
    },
    "count": {
      "type": "number",
      "description": "Max entries"
    },
    "start": {
      "type": "string",
      "description": "Start ID (default -)"
    },
    "stream": {
      "type": "string",
      "description": "Stream name"
    },
    "reverse": {
      "type": "boolean",
      "description": "Read newest-first (XREVRANGE)"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

stream_read output schema

{
  "type": "object",
  "properties": {}
}

stream_read annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

stream_info

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Stream info: length and consumer groups (XLEN + XINFO GROUPS).

stream_info input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "stream"
  ],
  "properties": {
    "stream": {
      "type": "string",
      "description": "Stream name"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

stream_info output schema

{
  "type": "object",
  "properties": {}
}

stream_info annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

stream_delete

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Delete a stream entirely (hot + durable) — irreversible.

stream_delete input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "stream"
  ],
  "properties": {
    "stream": {
      "type": "string",
      "description": "Stream name"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

stream_delete output schema

{
  "type": "object",
  "properties": {}
}

stream_delete annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

stream_group

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Consumer-group operations on a stream: create, destroy, read (XREADGROUP), ack (XACK), pending (XPENDING), claim (XCLAIM/XAUTOCLAIM).

stream_group input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "stream",
    "action",
    "group"
  ],
  "properties": {
    "ids": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Entry IDs (ack/claim)"
    },
    "from": {
      "type": "string",
      "description": "Start position for create (default $ = new entries only, use 0 for all)"
    },
    "count": {
      "type": "number",
      "description": "Max entries (read/pending/claim)"
    },
    "group": {
      "type": "string",
      "description": "Consumer group name"
    },
    "start": {
      "type": "string",
      "description": "Autoclaim scan start (claim)"
    },
    "action": {
      "enum": [
        "create",
        "destroy",
        "read",
        "ack",
        "pending",
        "claim"
      ],
      "type": "string",
      "description": "Operation"
    },
    "stream": {
      "type": "string",
      "description": "Stream name"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "consumer": {
      "type": "string",
      "description": "Consumer name (read/pending/claim)"
    },
    "minIdleMs": {
      "type": "number",
      "description": "Min idle ms before claim (claim)"
    },
    "waitSeconds": {
      "type": "number",
      "description": "Long-poll seconds ≤25 (read)"
    }
  }
}

stream_group output schema

{
  "type": "object",
  "properties": {}
}

stream_group annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

kv_hash

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Hash operations (Redis-hash semantics, write-through durable): set, get (whole hash), keys, get_field, del_field, delete, setnx (atomic set-if-absent), cas (atomic compare-and-set).

kv_hash input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "name",
    "action"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Hash name"
    },
    "field": {
      "type": "string",
      "description": "Single field (get_field/del_field/setnx/cas)"
    },
    "value": {
      "description": "Value (setnx/cas)"
    },
    "action": {
      "enum": [
        "set",
        "get",
        "keys",
        "get_field",
        "del_field",
        "delete",
        "setnx",
        "cas"
      ],
      "type": "string",
      "description": "Operation"
    },
    "fields": {
      "type": "object",
      "description": "Fields to set (set)"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "expected": {
      "description": "Expected current value (cas — omit to require absent)"
    },
    "deleteField": {
      "type": "boolean",
      "description": "CAS: delete the field instead of setting (cas)"
    }
  }
}

kv_hash output schema

{
  "type": "object",
  "properties": {}
}

kv_hash annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

kv_string

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

String operations with optional TTL (survives rebuild): set, get (includes remaining ttlMs), delete.

kv_string input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "name",
    "action"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "String key name"
    },
    "value": {
      "type": "string",
      "description": "Value to set (set)"
    },
    "action": {
      "enum": [
        "set",
        "get",
        "delete"
      ],
      "type": "string",
      "description": "Operation"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "ttlSeconds": {
      "type": "number",
      "description": "TTL in seconds (set)"
    }
  }
}

kv_string output schema

{
  "type": "object",
  "properties": {}
}

kv_string annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

kv_set

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Set operations (Redis-set semantics): add, members (with size), contains, remove, delete.

kv_set input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "name",
    "action"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Set name"
    },
    "action": {
      "enum": [
        "add",
        "members",
        "contains",
        "remove",
        "delete"
      ],
      "type": "string",
      "description": "Operation"
    },
    "member": {
      "type": "string",
      "description": "Single member (contains)"
    },
    "members": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Members (add/remove)"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

kv_set output schema

{
  "type": "object",
  "properties": {}
}

kv_set annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

usage_get

Advertised by the server during the last successful anonymous check.

Advertised read-onlyOpen-world

Get current usage vs plan limits for the authenticated tenant.

usage_get input schema

{
  "type": "object",
  "properties": {}
}

usage_get output schema

{
  "type": "object",
  "properties": {}
}

usage_get annotations

{
  "readOnlyHint": true,
  "openWorldHint": true,
  "destructiveHint": false
}

webhook

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Per-space webhook subscriptions: create, list, delete.

webhook input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "action"
  ],
  "properties": {
    "url": {
      "type": "string",
      "description": "Webhook URL (create)"
    },
    "action": {
      "enum": [
        "create",
        "list",
        "delete"
      ],
      "type": "string",
      "description": "Operation"
    },
    "events": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Event types to subscribe to (create)"
    },
    "filter": {
      "type": "object",
      "description": "Event filter (create)"
    },
    "hookId": {
      "type": "string",
      "description": "Webhook ID (delete)"
    },
    "secret": {
      "type": "string",
      "description": "Signing secret (create)"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    }
  }
}

webhook output schema

{
  "type": "object",
  "properties": {}
}

webhook annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

knowledge

Advertised by the server during the last successful anonymous check.

Advertised destructiveOpen-world

Knowledge-base operations: create (with documents), list, delete, query (smart retrieval).

knowledge input schema

{
  "type": "object",
  "required": [
    "spaceId",
    "action"
  ],
  "properties": {
    "kbId": {
      "type": "string",
      "description": "KB ID (delete/query)"
    },
    "name": {
      "type": "string",
      "description": "KB name (create)"
    },
    "slug": {
      "type": "string",
      "description": "KB slug (create/query)"
    },
    "limit": {
      "type": "number",
      "description": "Max results (query)"
    },
    "query": {
      "type": "string",
      "description": "Query text (query)"
    },
    "action": {
      "enum": [
        "create",
        "list",
        "delete",
        "query"
      ],
      "type": "string",
      "description": "Operation"
    },
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "documents": {
      "type": "array",
      "items": {
        "type": "object"
      },
      "description": "Documents to index (create)"
    },
    "description": {
      "type": "string",
      "description": "KB description (create)"
    }
  }
}

knowledge output schema

{
  "type": "object",
  "properties": {}
}

knowledge annotations

{
  "readOnlyHint": false,
  "openWorldHint": true,
  "destructiveHint": true
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not advertised

No resource definitions available.

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks: 1 of 1 (100%)
Average latency: 1998 ms
95th percentile latency: 1998 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

Nov 1, 2026, 6:36 AM UTC · probe · passed · 1998 ms · metadata changed · 46 tool(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.

Claude Code configuration

claude mcp add --transport sse agenticmemory-mcp https://mcp.agenticmemory.ai/sse

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).

Cline configuration

{
  "mcpServers": {
    "agenticmemory-mcp": {
      "type": "sse",
      "url": "https://mcp.agenticmemory.ai/sse",
      "disabled": false
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.

Gemini CLI configuration

gemini mcp add --transport sse agenticmemory-mcp https://mcp.agenticmemory.ai/sse

Let your agent find its tools

Find servers like AgenticMemory MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Connect Koskamo Explore workflows

See all 3,755

AgenticMemory MCP

Endpoint and access

What you can do with it

Source and maintenance

Protocol and capabilities

Tools

Prompts

Resources

30-day availability

Maintenance history

Connect from your client

Claude Code

Cline

Gemini CLI

Let your agent find its tools

Other ai and machine learning servers