MCP Tools Reference

Hoard exposes tools via the Model Context Protocol (MCP) for AI agent integration.

Available Tools

Tool	Scope Required	Description
search	search	Hybrid search over entities and memory
get	get	Full entity with all chunks (or memory by id)
get_chunk	get	Single chunk with context
memory_get	memory.read or memory	Retrieve stored context
memory_put	memory.write or memory	Store context
memory_search	memory.read or memory	Search memory entries
sync	sync	Run sync with lock
sync_status	sync	Connector sync status
sync_run	sync	Run sync without lock (advanced)
embeddings_build	sync	Build embeddings
inbox_put	ingest	Write content into the agent inbox
agent.register	agent.register	Register an agent (Orchestrator)
agent.heartbeat	agent.self	Agent heartbeat (Orchestrator)
agent.capabilities	agent.self	Update agent capabilities (Orchestrator)
agent.list	agent.read	List agents (Orchestrator)
agent.deregister	agent.self	Deregister agent (Orchestrator)
task.create	task.create	Create task (Orchestrator)
task.poll	task.claim	Poll tasks (Orchestrator)
task.claim	task.claim	Claim task (Orchestrator)
task.start	task.execute	Start task (Orchestrator)
task.complete	task.execute	Complete task (Orchestrator)
task.fail	task.execute	Fail task (Orchestrator)
task.cancel	task.manage	Cancel task (Orchestrator)
task.delegate	task.create	Delegate task (Orchestrator)
task.get	task.read	Get task (Orchestrator)
task.list	task.read	List tasks (Orchestrator)
artifact.put	artifact.write	Store artifact (Orchestrator)
artifact.get	artifact.read	Retrieve artifact (Orchestrator)
artifact.list	artifact.read	List artifacts (Orchestrator)
event.publish	event.write	Publish event (Orchestrator)
event.poll	event.read	Poll events (Orchestrator)
cost.report	cost.write	Report cost (Orchestrator)
cost.summary	cost.read	Cost summary (Orchestrator)
cost.budget	cost.read	Cost budget status (Orchestrator)
workflow.create	workflow.create	Create workflow (Orchestrator)
workflow.start	workflow.manage	Start workflow (Orchestrator)
workflow.pause	workflow.manage	Pause workflow (Orchestrator)
workflow.resume	workflow.manage	Resume workflow (Orchestrator)
workflow.cancel	workflow.manage	Cancel workflow (Orchestrator)
workflow.status	workflow.read	Workflow status (Orchestrator)
workflow.get	workflow.read	Get workflow (Orchestrator)
workflow.list	workflow.read	List workflows (Orchestrator)

Note

memory is a legacy scope that grants both read and write. Use memory.read and memory.write for finer control.

search

Search indexed content with hybrid search (BM25 + vectors).

Input Schema

{
  "name": "search",
  "description": "Hybrid search (BM25 + vectors) over indexed chunks.",
  "inputSchema": {
    "type": "object",
    "required": ["query"],
    "properties": {
      "query": {
        "type": "string",
        "description": "Search query string."
      },
      "limit": {
        "type": "integer",
        "default": 20,
        "minimum": 1,
        "maximum": 100,
        "description": "Maximum number of entities to return."
      },
      "cursor": {
        "type": "string",
        "description": "Pagination cursor returned by a previous search."
      },
      "source": {
        "type": "string",
        "description": "Optional source filter (e.g., local_files, obsidian)."
      },
      "types": {
        "type": "array",
        "items": {"type": "string"},
        "description": "Result types to include (entity, memory)."
      },
      "include_memory": {
        "type": "boolean",
        "description": "Deprecated. Use types instead. True includes memory results."
      },
      "token": {
        "type": "string",
        "description": "Auth token (if HOARD_TOKEN env not set)."
      }
    }
  }
}

Response

{
  "results": [
    {
      "result_type": "entity",
      "entity_id": "a1b2c3d4e5f6789012345678",
      "entity_title": "Project Notes",
      "source": "local_files",
      "uri": "file:///path/to/notes.md",
      "chunks": [
        {
          "chunk_id": "a1b2c3d4e5f6789012345678:2",
          "content": "The meeting discussed...",
          "score": 0.87,
          "char_offset_start": 1200,
          "char_offset_end": 1850
        }
      ]
    }
  ],
  "next_cursor": "20"
}

Note: Search results include result_type (entity or memory). Memory results include memory_key and a single chunk.

Note

The next_cursor value is used for pagination. Pass it as the cursor parameter in the next search to get more results. null indicates no more results.

Example

{
  "name": "search",
  "arguments": {
    "query": "project planning meeting",
    "limit": 5,
    "types": ["entity", "memory"]
  }
}

get

Retrieve full entity content with all chunks.

Input Schema

{
  "name": "get",
  "description": "Get an entity and all its chunks.",
  "inputSchema": {
    "type": "object",
    "required": ["entity_id"],
    "properties": {
      "entity_id": {
        "type": "string",
        "description": "Entity ID from search results."
      },
      "token": {
        "type": "string",
        "description": "Auth token (if HOARD_TOKEN env not set)."
      }
    }
  }
}

Response

{
  "entity": {
    "id": "a1b2c3d4e5f6789012345678",
    "title": "Project Notes",
    "uri": "file:///path/to/notes.md",
    "source": "local_files",
    "source_id": "notes.md",
    "entity_type": "document",
    "tags": ["project", "planning"],
    "sensitivity": "normal",
    "chunks": [
      {
        "chunk_id": "a1b2c3d4e5f6789012345678:0",
        "content": "# Project Overview

This document...",
        "chunk_index": 0,
        "char_offset_start": 0,
        "char_offset_end": 450
      },
      {
        "chunk_id": "a1b2c3d4e5f6789012345678:1",
        "content": "## Timeline

The project will...",
        "chunk_index": 1,
        "char_offset_start": 400,
        "char_offset_end": 850
      }
    ]
  }
}

Returns {"entity": null} if the entity is not found. If the token has memory scope and the entity_id matches a memory entry, the response returns that memory as a pseudo-entity.

get_chunk

Retrieve a single chunk with surrounding context.

Input Schema

{
  "name": "get_chunk",
  "description": "Get a single chunk by ID.",
  "inputSchema": {
    "type": "object",
    "required": ["chunk_id"],
    "properties": {
      "chunk_id": {
        "type": "string",
        "description": "Chunk ID from search results."
      },
      "context_chunks": {
        "type": "integer",
        "default": 0,
        "minimum": 0,
        "maximum": 10,
        "description": "Number of surrounding chunks to include before/after."
      },
      "token": {
        "type": "string",
        "description": "Auth token (if HOARD_TOKEN env not set)."
      }
    }
  }
}

Response

{
  "chunk": {
    "chunk_id": "a1b2c3d4e5f6789012345678:2",
    "content": "The meeting discussed...",
    "chunk_index": 2,
    "chunk_type": "semantic",
    "char_offset_start": 850,
    "char_offset_end": 1300,
    "entity_id": "a1b2c3d4e5f6789012345678",
    "entity_title": "Project Notes",
    "source": "local_files",
    "uri": "file:///path/to/notes.md",
    "context": {
      "before": [
        {
          "chunk_id": "a1b2c3d4e5f6789012345678:1",
          "chunk_index": 1,
          "content": "## Timeline...",
          "char_offset_start": 400,
          "char_offset_end": 850,
          "chunk_type": "semantic"
        }
      ],
      "after": [
        {
          "chunk_id": "a1b2c3d4e5f6789012345678:3",
          "chunk_index": 3,
          "content": "## Action Items...",
          "char_offset_start": 1300,
          "char_offset_end": 1750,
          "chunk_type": "semantic"
        }
      ]
    }
  }
}

The context field is only present when context_chunks > 0. Returns {"chunk": null} if the chunk is not found.

memory_get

Retrieve stored context by key or id.

Input Schema

{
  "name": "memory_get",
  "description": "Fetch a memory entry by key or id.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string",
        "description": "Memory id."
      },
      "key": {
        "type": "string",
        "description": "Memory key."
      },
      "token": {
        "type": "string",
        "description": "Auth token (if HOARD_TOKEN env not set)."
      }
    },
    "required": []
  }
}

Response

{
  "memory": {
    "key": "user_preferences",
    "content": "Prefers concise responses. Working on Project X.",
    "tags": ["preferences"],
    "metadata": {},
    "created_at": "2026-02-01T10:00:00Z",
    "updated_at": "2026-02-03T14:30:00Z",
    "expires_at": "2026-03-03T14:30:00Z"
  }
}

Returns {"memory": null} if the entry does not exist.

memory_put

Store context for later retrieval.

Input Schema

{
  "name": "memory_put",
  "description": "Store a memory entry.",
  "inputSchema": {
    "type": "object",
    "required": ["key", "content"],
    "properties": {
      "key": {
        "type": "string",
        "description": "Memory key."
      },
      "content": {
        "type": "string",
        "description": "Memory content."
      },
      "tags": {
        "type": "array",
        "items": {"type": "string"},
        "description": "Optional tags."
      },
      "metadata": {
        "type": "object",
        "description": "Optional metadata object."
      },
      "ttl_days": {
        "type": "integer",
        "description": "Optional time-to-live in days."
      },
      "expires_at": {
        "type": "string",
        "description": "Optional ISO timestamp when the memory expires."
      },
      "token": {
        "type": "string",
        "description": "Auth token (if HOARD_TOKEN env not set)."
      }
    }
  }
}

Response

{
  "memory": {
    "key": "user_preferences",
    "content": "Prefers concise responses. Working on Project X.",
    "tags": ["preferences"],
    "metadata": {},
    "created_at": "2026-02-01T10:00:00Z",
    "updated_at": "2026-02-03T14:30:00Z",
    "expires_at": "2026-03-03T14:30:00Z"
  }
}

Note

If the key already exists, the content is updated. If ttl_days or expires_at is not provided, memory.default_ttl_days applies.

memory_search

Search memory entries.

Input Schema

{
  "name": "memory_search",
  "description": "Search memory entries.",
  "inputSchema": {
    "type": "object",
    "required": ["query"],
    "properties": {
      "query": {
        "type": "string",
        "description": "Search query string."
      },
      "limit": {
        "type": "integer",
        "default": 20,
        "minimum": 1,
        "maximum": 100,
        "description": "Maximum number of entries to return."
      },
      "token": {
        "type": "string",
        "description": "Auth token (if HOARD_TOKEN env not set)."
      }
    }
  }
}

Response

{
  "results": [
    {
      "key": "project_context",
      "content": "Working on authentication feature...",
      "tags": ["project"],
      "score": 0.85
    }
  ]
}

sync

Run sync for enabled connectors with a lock to prevent concurrent runs.

Input Schema

{
  "name": "sync",
  "description": "Run sync for enabled connectors.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "source": {"type": "string"},
      "token": {"type": "string"}
    },
    "required": []
  }
}

Response

{
  "connectors": [
    {
      "source": "local_files",
      "success": true,
      "message": "Found 42 files",
      "stats": {
        "entities_seen": 42,
        "chunks_written": 156,
        "entities_tombstoned": 0,
        "errors": 0,
        "started_at": "2026-02-05T12:00:00"
      }
    }
  ],
  "memory_pruned": 2
}

If a lock is held, the response is:

{
  "skipped": true,
  "reason": "lock"
}

sync_status

Get connector sync status.

Input Schema

{
  "name": "sync_status",
  "description": "Get connector sync status.",
  "inputSchema": {
    "type": "object",
    "required": [],
    "properties": {
      "token": {
        "type": "string",
        "description": "Auth token (if HOARD_TOKEN env not set)."
      }
    }
  }
}

Response

{
  "connectors": [
    {
      "source": "local_files",
      "entities": 1200,
      "last_sync": "2026-02-03T10:15:00Z"
    },
    {
      "source": "obsidian",
      "entities": 1256,
      "last_sync": "2026-02-03T10:15:00Z"
    }
  ]
}

sync_run

Run sync without a lock (advanced).

Input Schema

{
  "name": "sync_run",
  "description": "Run sync without lock (advanced).",
  "inputSchema": {
    "type": "object",
    "properties": {
      "source": {"type": "string"},
      "token": {"type": "string"}
    },
    "required": []
  }
}

embeddings_build

Build embeddings for indexed chunks.

Input Schema

{
  "name": "embeddings_build",
  "description": "Build embeddings for indexed chunks.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "source": {"type": "string"},
      "token": {"type": "string"}
    },
    "required": []
  }
}

Response

{
  "total": 12345
}

inbox_put

Write content into the agent inbox.

Input Schema

{
  "name": "inbox_put",
  "description": "Write content into the agent inbox.",
  "inputSchema": {
    "type": "object",
    "required": ["content"],
    "properties": {
      "content": {"type": "string"},
      "title": {"type": "string"},
      "tags": {"type": "array", "items": {"type": "string"}},
      "metadata": {"type": "object"},
      "filename": {"type": "string"},
      "extension": {"type": "string"},
      "sync_immediately": {"type": "boolean"},
      "token": {"type": "string"}
    }
  }
}

Response

{
  "path": "/Users/you/.hoard/inbox/20260205_120000_decision-log.md"
}

Orchestrator (Beta)

Orchestrator tools provide multi-agent coordination. They are grouped by domain below.

Agent registration requires HOARD_REGISTRATION_TOKEN.

Agent Tools

agent.register

{
  "name": "agent.register",
  "description": "Register a new agent.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "name": {"type": "string"},
      "agent_type": {"type": "string"},
      "capabilities": {"type": "array", "items": {"type": "string"}},
      "scopes": {"type": "array", "items": {"type": "string"}},
      "metadata": {"type": "object"},
      "max_concurrent_tasks": {"type": "integer"},
      "default_model": {"type": "string"},
      "model_provider": {"type": "string"},
      "overwrite": {"type": "boolean"}
    },
    "required": ["name", "agent_type"]
  }
}

agent.heartbeat

{
  "name": "agent.heartbeat",
  "description": "Send heartbeat for an agent.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "agent_id": {"type": "string"},
      "status": {"type": "string"}
    },
    "required": ["agent_id"]
  }
}

agent.capabilities

{
  "name": "agent.capabilities",
  "description": "Update agent capabilities.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "agent_id": {"type": "string"},
      "capabilities": {"type": "array", "items": {"type": "string"}}
    },
    "required": ["agent_id", "capabilities"]
  }
}

agent.list

{
  "name": "agent.list",
  "description": "List agents.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "required": []
  }
}

agent.deregister

{
  "name": "agent.deregister",
  "description": "Deregister agent.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "agent_id": {"type": "string"}
    },
    "required": ["agent_id"]
  }
}

Response notes:

• agent.register returns { "agent_id", "name", "token", "scopes", "capabilities" }.
• agent.list returns { "agents": [...] }.
• Other agent tools return { "success": true }.

Task Tools

task.create

{
  "name": "task.create",
  "description": "Create a standalone task.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "name": {"type": "string"},
      "description": {"type": "string"},
      "requires_capability": {"type": "string"},
      "priority": {"type": "integer"},
      "input_data": {"type": "object"},
      "input_artifact_ids": {"type": "array", "items": {"type": "string"}},
      "workflow_id": {"type": "string"},
      "workflow_step_id": {"type": "string"},
      "depends_on": {"type": "array", "items": {"type": "object"}}
    },
    "required": ["name"]
  }
}

task.poll

{
  "name": "task.poll",
  "description": "Poll for available tasks.",
  "inputSchema": {
    "type": "object",
    "properties": {"limit": {"type": "integer"}},
    "required": []
  }
}

task.claim

{
  "name": "task.claim",
  "description": "Claim a task.",
  "inputSchema": {
    "type": "object",
    "properties": {"task_id": {"type": "string"}},
    "required": ["task_id"]
  }
}

task.start

{
  "name": "task.start",
  "description": "Start a claimed task.",
  "inputSchema": {
    "type": "object",
    "properties": {"task_id": {"type": "string"}},
    "required": ["task_id"]
  }
}

task.complete

{
  "name": "task.complete",
  "description": "Complete a task.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "task_id": {"type": "string"},
      "output_summary": {"type": "string"},
      "output_artifact_id": {"type": "string"},
      "tokens_input": {"type": "integer"},
      "tokens_output": {"type": "integer"},
      "estimated_cost_usd": {"type": "number"},
      "model_used": {"type": "string"}
    },
    "required": ["task_id"]
  }
}

task.fail

{
  "name": "task.fail",
  "description": "Fail a task.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "task_id": {"type": "string"},
      "error_message": {"type": "string"}
    },
    "required": ["task_id"]
  }
}

task.cancel

{
  "name": "task.cancel",
  "description": "Cancel a task.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "task_id": {"type": "string"},
      "reason": {"type": "string"}
    },
    "required": ["task_id"]
  }
}

task.delegate

{
  "name": "task.delegate",
  "description": "Delegate a task.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "parent_task_id": {"type": "string"},
      "name": {"type": "string"},
      "description": {"type": "string"}
    },
    "required": ["parent_task_id", "name"]
  }
}

task.get

{
  "name": "task.get",
  "description": "Get task details.",
  "inputSchema": {
    "type": "object",
    "properties": {"task_id": {"type": "string"}},
    "required": ["task_id"]
  }
}

task.list

{
  "name": "task.list",
  "description": "List tasks.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "status": {"type": "string"},
      "workflow_id": {"type": "string"},
      "agent_id": {"type": "string"},
      "limit": {"type": "integer"}
    },
    "required": []
  }
}

Response notes:

• task.poll returns { "tasks": [...] }.
• task.claim returns { "task": {...} }.
• task.create returns a task object.
• task.complete, task.fail, task.cancel, task.start return { "success": true }.

Artifact Tools

artifact.put

{
  "name": "artifact.put",
  "description": "Store an artifact for a task.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "task_id": {"type": "string"},
      "name": {"type": "string"},
      "artifact_type": {"type": "string"},
      "content": {"type": "string"},
      "content_base64": {"type": "string"},
      "content_url": {"type": "string"},
      "mime_type": {"type": "string"},
      "metadata": {"type": "object"},
      "role": {"type": "string"}
    },
    "required": ["task_id", "name", "artifact_type"]
  }
}

artifact.get

{
  "name": "artifact.get",
  "description": "Retrieve an artifact.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "artifact_id": {"type": "string"},
      "include_content": {"type": "boolean"}
    },
    "required": ["artifact_id"]
  }
}

artifact.list

{
  "name": "artifact.list",
  "description": "List artifacts for task or workflow.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "task_id": {"type": "string"},
      "workflow_id": {"type": "string"}
    },
    "required": []
  }
}

Response notes:

• artifact.put returns { "artifact": {...} }.
• artifact.get returns { "artifact": {...} }.
• artifact.list returns { "artifacts": [...] }.

Event Tools

event.publish

{
  "name": "event.publish",
  "description": "Publish an event.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "event_type": {"type": "string"},
      "payload": {"type": "object"}
    },
    "required": ["event_type", "payload"]
  }
}

event.poll

{
  "name": "event.poll",
  "description": "Poll events since timestamp.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "since": {"type": "string"},
      "limit": {"type": "integer"}
    },
    "required": []
  }
}

Response notes:

• event.publish returns { "event_id": "evt-..." }.
• event.poll returns { "events": [...] }.

Cost Tools

cost.report

{
  "name": "cost.report",
  "description": "Report cost usage.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "agent_id": {"type": "string"},
      "task_id": {"type": "string"},
      "workflow_id": {"type": "string"},
      "model": {"type": "string"},
      "provider": {"type": "string"},
      "tokens_input": {"type": "integer"},
      "tokens_output": {"type": "integer"},
      "tokens_cache_read": {"type": "integer"},
      "tokens_cache_write": {"type": "integer"},
      "estimated_cost_usd": {"type": "number"},
      "input_price_per_mtok": {"type": "number"},
      "output_price_per_mtok": {"type": "number"}
    },
    "required": ["agent_id", "model", "provider"]
  }
}

cost.summary

{
  "name": "cost.summary",
  "description": "Summarize costs.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "period": {"type": "string"},
      "group_by": {"type": "string"}
    },
    "required": []
  }
}

cost.budget

{
  "name": "cost.budget",
  "description": "Get budget status.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "agent_id": {"type": "string"},
      "workflow_id": {"type": "string"},
      "period": {"type": "string"}
    },
    "required": []
  }
}

Response notes:

• cost.report returns { "success": true }.
• cost.summary returns { "total_usd": ..., "by_agent": [...], "by_model": [...] }.
• cost.budget returns { "global": {...}, "agent": {...}, "workflow": {...} }.

Workflow Tools

workflow.create

{
  "name": "workflow.create",
  "description": "Create a workflow.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "name": {"type": "string"},
      "description": {"type": "string"},
      "definition": {"type": "object"},
      "trigger_type": {"type": "string"},
      "trigger_config": {"type": "object"},
      "tags": {"type": "array", "items": {"type": "string"}}
    },
    "required": ["name", "definition"]
  }
}

workflow.start

{
  "name": "workflow.start",
  "description": "Start a workflow.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "workflow_id": {"type": "string"},
      "inputs": {"type": "object"}
    },
    "required": ["workflow_id"]
  }
}

workflow.pause

{
  "name": "workflow.pause",
  "description": "Pause a workflow.",
  "inputSchema": {
    "type": "object",
    "properties": {"workflow_id": {"type": "string"}},
    "required": ["workflow_id"]
  }
}

workflow.resume

{
  "name": "workflow.resume",
  "description": "Resume a workflow.",
  "inputSchema": {
    "type": "object",
    "properties": {"workflow_id": {"type": "string"}},
    "required": ["workflow_id"]
  }
}

workflow.cancel

{
  "name": "workflow.cancel",
  "description": "Cancel a workflow.",
  "inputSchema": {
    "type": "object",
    "properties": {"workflow_id": {"type": "string"}},
    "required": ["workflow_id"]
  }
}

workflow.status

{
  "name": "workflow.status",
  "description": "Get workflow status.",
  "inputSchema": {
    "type": "object",
    "properties": {"workflow_id": {"type": "string"}},
    "required": ["workflow_id"]
  }
}

workflow.get

{
  "name": "workflow.get",
  "description": "Get workflow definition.",
  "inputSchema": {
    "type": "object",
    "properties": {"workflow_id": {"type": "string"}},
    "required": ["workflow_id"]
  }
}

workflow.list

{
  "name": "workflow.list",
  "description": "List workflows.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "status": {"type": "string"},
      "limit": {"type": "integer"}
    },
    "required": []
  }
}

Response notes:

• workflow.create returns { "workflow": {...} }.
• workflow.status and workflow.get return { "workflow": {...} }.
• workflow.list returns { "workflows": [...] }.

Advanced Memory Tools

These tools support structured memory workflows:

Tool	Description
memory_write	Create a structured memory record
memory_query	Query structured memories
memory_retract	Retract a memory
memory_supersede	Supersede a memory
memory_propose	Propose memory for review
memory_review	Approve or reject proposals
conflicts_list	List memory conflicts
conflict_resolve	Resolve a memory conflict
duplicates_list	List memory duplicates
duplicate_resolve	Resolve duplicate clusters

Tools NOT Exposed

For security, these operations are not available via MCP:

Operation	Reason
export_all	Bulk exfiltration risk
list_all	Enumeration risk
query(sql)	Bypasses security

Error Responses

Invalid Token

{
  "error": {
    "code": -32001,
    "message": "Invalid or missing authentication token"
  }
}

Insufficient Scope

{
  "error": {
    "code": -32002,
    "message": "Token missing required scope: sensitive"
  }
}

Rate Limited

{
  "error": {
    "code": -32003,
    "message": "Rate limit exceeded. Try again in 60 seconds."
  }
}

Not Found

For get and get_chunk tools, missing items return null rather than an error:

{
  "entity": null
}

or

{
  "chunk": null
}

See Also

• MCP Interface — Protocol details
• Security — Authentication and rate limiting
• Configuration — Token configuration