agenticmemory

Persistent memory for AI agents — history, context, semantic search, queues. 46 tools, stdio/SSE.

사용해야 할까요

품질 및 안전성

A
설명 품질
92%
스키마 완전성
96%
이름 품질
82%
오염 위험
100%
권한 일치
100%
프로토콜 준수
100%

발견 사항 (5)

  • LOWTool 'memory_store' description lacks action verbmemory_store에서
  • LOWTool 'memory_store_batch' description lacks action verbmemory_store_batch에서
  • LOWTool 'memory_clear' description lacks action verbmemory_clear에서
  • LOWTool 'state_set' description lacks action verbstate_set에서
  • LOWTool 'queue_nack' description lacks action verbqueue_nack에서

도구 정의와 프로토콜 준수에 대한 자동 분석을 기반으로 합니다.

컨텍스트 비용

~8,026토큰 (도구 정의)
~1.6 KB일반적인 응답 크기
상당한 주의 영향 (128k 컨텍스트의 6.27%)

이는 서버의 도구가 모델의 컨텍스트에 로드될 때마다 소비되는 대략적인 토큰 수입니다. 수치가 높을수록 다른 작업에 사용할 수 있는 주의가 줄어듭니다.

설치

원클릭 설치

`claude_desktop_config.json` 파일에 다음을 추가하세요:

{
  "mcpServers": {
    "agenticmemory": {
      "url": "https://mcp.agenticmemory.ai/sse"
    }
  }
}

원격 엔드포인트

https://mcp.agenticmemory.ai/ssesse

할 수 있는 일

도구 목록

도구 (46)

🟢 읽기 전용🟡 쓰기🔴 삭제⚪ 알 수 없음
🔴memory_store(spaceId, content, role)

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

입력 스키마

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

출력 스키마

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

Store multiple messages at once.

입력 스키마

{
  "type": "object",
  "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"
    }
  },
  "required": [
    "spaceId",
    "messages"
  ]
}

출력 스키마

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

Recall recent messages from conversation history. Returns newest first.

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {
    "messages": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "_id": {
            "type": "string",
            "description": "Message ID"
          },
          "spaceId": {
            "type": "string",
            "description": "Owning memory space ID"
          },
          "role": {
            "type": "string",
            "description": "Message role: user, assistant, system, or tool"
          },
          "content": {
            "type": "string",
            "description": "Message text"
          },
          "seq": {
            "type": "number",
            "description": "Monotonic sequence number within the space"
          },
          "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)"
    }
  },
  "required": [
    "messages"
  ]
}
🔴memory_clear(spaceId)

Clear all messages in a memory space.

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {
    "cleared": {
      "type": "boolean",
      "description": "True when messages were cleared"
    }
  },
  "required": [
    "cleared"
  ]
}
🟢memory_search(spaceId, query, limit, tags, scope, ...)

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

입력 스키마

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

출력 스키마

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

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

입력 스키마

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

출력 스키마

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

Get a context value by key.

입력 스키마

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

출력 스키마

{
  "type": "object",
  "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)"
    }
  },
  "required": [
    "key"
  ]
}
🟢context_list(spaceId)

List all context keys and values in a space.

입력 스키마

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

출력 스키마

{
  "type": "object",
  "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)"
    }
  },
  "required": [
    "context"
  ]
}
🔴context_delete(spaceId, key)

Delete a context key.

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {
    "deleted": {
      "type": "boolean",
      "description": "True when the key was deleted"
    }
  },
  "required": [
    "deleted"
  ]
}
🟢entries_list(spaceId, limit, tags)

List long-term memory entries. Filter by tags.

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {
    "entries": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "_id": {
            "type": "string",
            "description": "Entry ID"
          },
          "title": {
            "type": "string",
            "description": "Entry title"
          },
          "content": {
            "type": "string",
            "description": "Entry body"
          },
          "type": {
            "type": "string",
            "description": "Entry type: extraction, summary, decision, or artifact"
          },
          "tags": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Tags for filtering"
          },
          "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)"
    }
  },
  "required": [
    "entries"
  ]
}
🟢spaces_list

List all memory spaces owned by this API key.

입력 스키마

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

출력 스키마

{
  "type": "object",
  "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"
          },
          "config": {
            "type": "object",
            "description": "Space configuration (TTLs, limits, encoding)"
          },
          "usage": {
            "type": "object",
            "description": "Usage counters (message count, etc.)"
          },
          "createdAt": {
            "type": "string",
            "description": "ISO 8601 creation timestamp"
          }
        }
      },
      "description": "Every memory space owned by the caller"
    }
  },
  "required": [
    "spaces"
  ]
}
🔴spaces_create(name, slug)

Create a new memory space.

입력 스키마

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

출력 스키마

{
  "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"
        },
        "config": {
          "type": "object",
          "description": "Space configuration (TTLs, limits, encoding)"
        },
        "usage": {
          "type": "object",
          "description": "Usage counters (message count, etc.)"
        },
        "createdAt": {
          "type": "string",
          "description": "ISO 8601 creation timestamp"
        }
      }
    }
  },
  "required": [
    "space"
  ]
}
🔴queue_push(spaceId, queue, envelope)

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

입력 스키마

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

출력 스키마

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

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {
    "queue": {
      "type": "string",
      "description": "Queue name"
    },
    "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"
    },
    "encrypted": {
      "type": "boolean",
      "description": "True if the space is end-to-end encrypted (item is ciphertext)"
    }
  },
  "required": [
    "queue"
  ]
}
🟢queue_peek(spaceId, queue)

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {
    "queue": {
      "type": "string",
      "description": "Queue name"
    },
    "length": {
      "type": "number",
      "description": "Current queue length"
    },
    "head": {
      "type": [
        "object",
        "null"
      ],
      "description": "The head envelope without consuming it, or null if empty"
    }
  },
  "required": [
    "queue"
  ]
}
🟢memory_bootstrap(spaceId, entries, messages, query)

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

입력 스키마

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

출력 스키마

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

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴scratchpad_set(spaceId, data)

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🟢scratchpad_get(spaceId)

Get the scratchpad content from a memory space.

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🟢spaces_get(spaceId)

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

입력 스키마

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

출력 스키마

{
  "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"
        },
        "config": {
          "type": "object",
          "description": "Space configuration (TTLs, limits, encoding)"
        },
        "usage": {
          "type": "object",
          "description": "Usage counters (message count, etc.)"
        },
        "createdAt": {
          "type": "string",
          "description": "ISO 8601 creation timestamp"
        }
      }
    }
  }
}
🟢space_export(spaceId)

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴space_import(spaceId, payload, mode)

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴entry(spaceId, action, entryId, title, content, ...)

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴entries_add_batch(spaceId, entries)

Append multiple journal entries in one call.

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴entity(spaceId, action, name, role, knows, ...)

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

입력 스키마

{
  "type": "object",
  "properties": {
    "spaceId": {
      "type": "string",
      "description": "Memory space ID"
    },
    "action": {
      "type": "string",
      "enum": [
        "upsert",
        "get",
        "update",
        "delete"
      ],
      "description": "Operation"
    },
    "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)"
    },
    "doesNotKnow": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Facts this entity does NOT know (upsert/update)"
    }
  },
  "required": [
    "spaceId",
    "action",
    "name"
  ]
}

출력 스키마

{
  "type": "object",
  "properties": {}
}
🟢entities_list(spaceId, namePrefix, knowsContains)

List entities in a memory space, optionally filtered.

입력 스키마

{
  "type": "object",
  "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"
    }
  },
  "required": [
    "spaceId"
  ]
}

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴thread(spaceId, action, threadId, name, status, ...)

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🟢threads_list(spaceId, status)

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🟢state_get(spaceId)

Get a space's single JSON state snapshot.

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴state_set(spaceId, state)

Replace a space's single JSON state snapshot.

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴shared_memory(spaceId, action, key, value, ttl)

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴queue_lease(spaceId, queue, visibilitySeconds, wait)

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.

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴queue_ack(spaceId, queue, leaseToken)

Acknowledge a leased envelope (deletes it permanently).

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴queue_nack(spaceId, queue, leaseToken)

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴queue_dlq(spaceId, queue, action, envelope, reason, ...)

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴stream_append(spaceId, stream, data, maxlen)

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🟢stream_read(spaceId, stream, start, end, count, ...)

Ranged read from a stream (XRANGE/XREVRANGE).

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🟢stream_info(spaceId, stream)

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴stream_delete(spaceId, stream)

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴stream_group(spaceId, stream, action, group, from, ...)

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴kv_hash(spaceId, name, action, fields, field, ...)

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).

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴kv_string(spaceId, name, action, value, ttlSeconds)

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴kv_set(spaceId, name, action, members, member)

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

입력 스키마

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

출력 스키마

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

Get current usage vs plan limits for the authenticated tenant.

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴webhook(spaceId, action, url, events, filter, ...)

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

입력 스키마

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

출력 스키마

{
  "type": "object",
  "properties": {}
}
🔴knowledge(spaceId, action, name, slug, description, ...)

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

입력 스키마

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

출력 스키마

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

커뮤니티

이 서버 평가하기

증거

최근 관측

검증됨버전이 기록되지 않음도구 46개
검증됨버전이 기록되지 않음도구 46개
검증됨버전이 기록되지 않음도구 46개
검증됨버전이 기록되지 않음도구 46개
검증됨버전이 기록되지 않음도구 46개
검증됨버전이 기록되지 않음도구 46개
검증됨버전이 기록되지 않음도구 17개