Skip to main content
Glama

cozyvtt-mcp

cozyvtt-mcp MCP server – quality and maintenance score on Glama

English | 中文

MCP (Model Context Protocol) bridge for CozyVTT — the self-hosted, open-source virtual tabletop. It lets an AI agent join a campaign as DM/KP: narrate over chat, roll server-authoritative dice on the server, move tokens, switch maps, manage initiative, and settle character sheets.

Built for and tested with Hermes Agent, but works with any MCP client (stdio transport).

Upgrading

This README describes how to install and use the current release; the change history lives in CHANGELOG.md. Two migration points are worth knowing before you wire up a client:

  • Three tools were renamed in 0.3.0: campaign_status → campaign_get, initiative_state → initiative_read, token_hp → token_hp_update. No aliases are registered — update client tool selections. Old-to-new mapping.

  • chat_read paginates with limit/cursor (the offset argument was removed in 0.2.0).

The default tool set is every tool; optional presets are described under Tool sets.

Related MCP server: RPG Ledger MCP Server

Tool sets

The default is every tool. Optional registration-time filtering drops excluded tools from tools/list entirely; it changes nothing about how the remaining tools behave. Choose comma-separated presets (union); duplicates are accepted and all wins. The flag overrides COZYVTT_MCP_TOOLSETS. Empty values or unknown names fail with valid preset names and counts. --list-toolsets prints all memberships and the default, then exits successfully without connecting to CozyVTT.

Preset

Tools

Selection

play

20

campaign_get, chat_read, chat_send, creature_search, dice_roll, events_poll, initiative_manage, initiative_read, map_create, map_delete, map_list, map_switch, session_list, session_manage, session_notes_update, token_add, token_delete, token_hp_update, token_move, token_place_creature

docs

9

All document_* tools plus campaign_document_list

roster

7

All character_* tools

macros

4

All saved_roll_* tools

admin

1

campaign_transfer_dm

all (default)

41

Every tool

.venv/bin/python server.py --toolsets play,macros
COZYVTT_MCP_TOOLSETS=docs,roster .venv/bin/python server.py
.venv/bin/python server.py --list-toolsets

For an MCP client, append "--toolsets", "play" to its server args, or set COZYVTT_MCP_TOOLSETS in its server env.

Measured with .venv/bin/python scripts/measure_tool_budget.py (offline stdio). Bytes sum UTF-8 JSON tool definitions, excluding JSON-RPC envelope/list separators; tokens are estimates (bytes // 4), not tokenizer measurements.

Preset

JSON bytes

Estimated tokens

Savings vs all

play

30,925

7,731

48%

docs

13,418

3,354

77%

roster

9,152

2,288

85%

macros

4,664

1,166

92%

admin

1,199

299

98%

all

59,358

14,839

0%

The surface also includes map_create, map_delete, token_delete, and character_delete. Create maps from existing image assets; use map_switch before deleting the current map. token_delete removes a map token; token_hp_update changes sheet HP using a character ID. character_delete permanently deletes an owned sheet. Add roster or docs when a session needs those tools.

Compatibility

cozyvtt-mcp

CozyVTT

Notes

0.6.1

v1.5.3 (1dd6bcc)

Tooling-only patch: configurable smoke pins and offline deployment-evidence validation. 503 offline tests on Python 3.12.13, including the v0.6.0 contract coverage; 41 runtime tools and parameter schemas unchanged. No new live campaign run performed for this patch.

0.6.0

v1.5.3 (1dd6bcc)

Offline review of v1.5.0→v1.5.3 (REST/WS docs + implementation): scope-aware document edits, Keeper-note filtering, newer input limits, conservative dice throttling, campaign.access.revoked. 456 offline tests on Python 3.12.13; 41 tools and parameter schemas unchanged. No live v1.5.3 campaign run; v1.5.0 remains the last live-smoked baseline.

0.5.0

v1.5.0 (b03e287)

Exact pinned baseline. 379 offline tests on Python 3.12.13 (89 adaptation + 62 helper + 228 historical); recorded 2026-10-04 15:44 CST DM read-only REST/passive WS smoke: 16/16 checks, post-cleanup teardown and observed exit 0. Deployment identity is operator-attested.

0.4.0

v1.2.2 / v1.4.0

Dual baseline. Tool-set presets plus map_create/map_delete/token_delete/character_delete. Offline contract suite 228/228; the Dockerfile was replayed inside the real python:3.12-slim rootfs (hash-checked layers) and boots with no environment set, listing 41 tools. No live campaign run, and no OCI image was built (no Docker daemon on the build host).

0.3.0

v1.2.2 / v1.4.0

Dual baseline. Parameter descriptions, MCP annotations, container image. Offline suite 176/176; image built and booted (37 tools, no environment). No live campaign run.

0.2.0

v1.2.2 / v1.4.0

Dual baseline: retain original tools; new REST routes degrade explicitly on old instances. Offline suite 176/176; live v1.4.0 smoke (read/write + Documents/Saved Rolls round-trips) passed 2026-09-17.

0.1.1

v1.2.2

Previous 20-tool release

The recorded DM run used CALL_OF_CTHULHU_7E in PREPARATION: 22 requests (1 login + 21 GETs), one passive WS connection, and only authenticate / initiative.request_state emits. No live campaign writes, conflict-write roundtrip, multi-user visibility or secret-recipient isolation were tested. Optional character/document checks were skipped (zero character sheets/readable documents); session, Saved Roll and custom creature lists were empty. This is an explicit version pin, not a v1.5.x/future-compatibility promise; older compatibility rows remain historical evidence only. See CHANGELOG for the final verification and limits.

The compatibility table describes supported contracts, not an inferred server version. New feature availability is unknown until established; an empty list or a business 404 is not evidence that the route is missing. See SPEC v2 for the complete 41-tool contract.

The current default baseline is CozyVTT v1.5.3. Its selected offline contract coverage does not certify full compatibility or live behavior; see the versioned evidence in CHANGELOG.md.

Features

41 tools returning {ok, data?, error?} for tool-body results. MCP argument validation remains handled by FastMCP:

  • Session/campaign: campaign_get (role and owner reported separately; new capability keys may be unknown), session_manage, session_list, session_notes_update, campaign_transfer_dm (owner reclaim uses the same tool), map_list, map_switch

  • Narration: chat_send (DM / PLAYER), chat_read

  • Dice: dice_roll (server-authoritative results; is_secret=true (wire field: secret) delivers to the roller and DMs on v1.4.0), events_poll (recent buffered dice events, not durable history; DICE_ROLL events are absent from chat history)

  • Tokens/maps: token_add (integer sizes 1..10), token_move, token_hp_update, token_place_creature, token_delete, map_create, map_delete, creature_search (SRD + custom library).

  • Combat: initiative_manage (add / remove / roll / set / reorder / start / next / end), initiative_read (note: CoC7e initiative is DEX-ordered, no roll — this is upstream rules behavior, and roll is gated accordingly)

  • Characters: character_list, character_get, character_create, character_delete, character_validate, character_update (rules math is done by the agent; the bridge just writes values)

  • Documents: document_upload, document_create, document_list, campaign_document_list, document_read, document_update, document_share, document_unshare, document_delete

  • Saved Rolls: saved_roll_list, saved_roll_create, saved_roll_update, saved_roll_delete (private to the current user and campaign; 50 macros per user/campaign, server-validated expressions). saved_roll_list returns complete macros — there is no saved_roll_get.

  • Hit Dice: character_hitdice_spend (DND_5E only; dispatches one spend without rolling dice or healing)

System gating

The bridge stays game-system agnostic, but a few capabilities only make sense under a specific rule system. Those are gated against the campaign's gameSystem (fetched once, cached; enum: DND_5E / PATHFINDER_2E / SHADOWRUN_6E / CALL_OF_CTHULHU_7E):

Capability

Allowed systems

Why

creature_search source=srd

DND_5E

The SRD library is seeded from Open5e — a D&D 5e data source

initiative_manage action=roll

DND_5E, PATHFINDER_2E, SHADOWRUN_6E

The server derives the initiative dice per system; CoC7e doesn't roll at all (DEX order)

character_hitdice_spend

DND_5E

Only the system gate is enforced locally. No reliable WS capability probe exists; dispatch always remains pending.

Gated calls return a clear {ok: false, error} explaining which systems are allowed, instead of emitting an event the server would ignore or misinterpret. Campaigns with no gameSystem set (flexible) fail closed. With no source specified, non-5e campaigns search only custom; 5e campaigns may search both sources. campaign_get().features reports the current campaign's available gated capabilities.

Architecture

MCP client (stdio)
  └─ server.py (FastMCP, lazy init, synchronous first-call self-check)
      ├─ auth.py        — rememberMe login, 10-min keepalive, 3-min re-login spacing, 429 backoff
      ├─ client.py      — REST wrapper: one 401→re-login→retry, 429 exponential backoff (1/2/4s, ≤3)
      ├─ ws_listener.py — socket.io listener, 500-event ring buffer, one reconnect worker
      └─ tools/         — 41 MCP tools (read/write, documents, campaign additions)

Design notes:

  • Dice discipline: rolls are generated and persisted by the server. Public results go to the table; reviewed v1.4.0 sends secret results to the roller and DMs. The bridge provides recent buffered events, not a durable roll-history query.

  • Rules live outside the bridge: skill checks, SAN loss, damage — computed by the agent/GM, the bridge only performs authoritative rolls and writes results. The bridge is game-system agnostic.

  • token_move uses REST PUT; the server checks DM/controlledBy permissions, and the bridge additionally rejects spectators. REST persistence does not imply a map.changed broadcast. map_switch saves through REST then explicitly dispatches map.change through WS; a WS failure preserves the successful REST result and never replays it. On both REST and WS token.move, PLAYER must use the current campaign map while DM may use any map of this campaign.

Result and update contracts

  • Resource IDs identify one URL segment. Empty IDs and ./.. are rejected; separators in other IDs are encoded so a malformed ID cannot select a different resource through URL normalization.

  • Transient login failures wait at least 180 seconds, including any longer server Retry-After. A login 401 stops password retries until you correct the configured credentials and restart the bridge; repeatedly invoking tools cannot bypass this block.

  • Keepalive does not extend an absolute sign-in lifetime. Session-expiry 401 gets one bounded recovery attempt; policy 403 retains its upstream code. The bridge has no MFA login/enrolment workflow.

  • For newer server validation, send whole-square token coordinates, MAP image assets and maps at most 500 squares wide/high. Use grid sizes 10..500; the server may substitute 50 outside that range. Dice labels should fit 200 characters for character_name and 300 for purpose. The bridge preserves server refusals and returned coordinates without silently coercing inputs.

  • Malformed business REST responses return INVALID_RESPONSE with the actual HTTP status. A write may already have happened: inspect state before retrying. In particular, an invalid map-switch response prevents the later WS broadcast. Raw document content, conditional reads and /health reachability retain their separate handling.

  • dice_roll, chat_send, token_hp_update, initiative_manage, and character_hitdice_spend return sent: true, confirmed: false, status: "pending". Read business broadcasts and system.error with events_poll; do not blindly replay writes. Neither baseline provides correlated business ACKs. Dice may carry purpose and character_name (wire: characterName) for Custom Roll display. Hit Dice spend, rolling, and healing are separate operations, not a transaction; an old server may silently ignore the spend event.

  • events_poll returns the oldest unread events first. Save next_seq for the next since; latest_seq is its compatibility alias. high_water_seq is the buffer high-water mark, not a pagination cursor. Check gap, cursor_reset, has_more, connected, and authenticated.

  • character_update(character_id, data={"data": {"hp": {"current": 5}}}) recursively merges sheet fields before PUT. Unspecified fields survive; arrays/scalars replace values and null is explicit. Top-level fields are name, data, and tokenImageUrl. Every accepted update reads under the process lock and sends the exact updatedAt value as a guard when present. A 409 is returned without retry; if the timestamp is absent, the legacy unguarded path remains. This protects only edits after the tool GET, not stale intent from an earlier read. The upstream parsed validator may discard undeclared fixed-system fields even when preserved in the outbound merge.

  • character_create creates the card, checks the roster, then assigns it only if not confirmed as assigned. If assignment fails, the error includes the created character ID: assign that card in the UI instead of creating another. CoC conditions/Mythos/spells/appearance/notes and DND legacy/new hit-dice fields survive character merges; The server may withhold Keeper notes; do not fill in omitted private fields.

  • session_manage uses REST. Pause/end resolve campaign.activeSession.id; start creates a session. End accepts notes (≤2000 characters, shared with the campaign) and save_state=true. Empty end notes do not clear old notes; use session_notes_update(session_id,notes="") to clear. session_list includes active sessions among the most recent 50.

  • Documents use scope USER (personal), CAMPAIGN, or GLOBAL. document_list filters the asset library; campaign_document_list discovers shared private documents too. Typed txt/md create/update is limited to 900 KiB UTF-8; file uploads use the instance limit (default 50 MiB). PDF content cannot be edited. Consult canEdit/canChange when supplied; edit rights depend on asset scope and current membership. Unsharing removes only one link and cannot revoke native/global access; shared:false indicates a native campaign document. Deleting removes the asset and all its links.

  • WS reconnects use fresh, URL-scoped Cookies and request current initiative state after campaign authentication. Use HTTPS for remote deployments.

  • chat_read paginates with limit + cursor: read the newest page first, then pass the returned pagination.nextCursor back as cursor, and stop when it is null. Instances without cursor metadata serve only the latest page and say so (This instance does not support reliable cursor pagination for history; only the latest page can be read.) instead of repeating it.

  • Raw document reads preserve MIME type and ETag. Text returns {mime_type,etag,content}; PDFs are written to the project's downloads/<document_id>.pdf and return {mime_type,etag,file_path,file_size}. Pass etag as If-None-Match; a 304 returns {not_modified:true} so the caller can reuse existing content. Downloads are Git-ignored and local copies survive upstream deletion.

  • REST 401 invalidates existing WS authentication and campaign caches; losing campaign membership cancels WS authentication and clears cached authority; the reconnect worker retains its existing bounded backoff. campaign_transfer_dm clears role and system caches, and the bridge buffers character.updated, campaign.dm.transferred, roster.updated, dice.historyCleared, campaign.role.changed, map:settings:updated, token:appeared, token:disappeared, and campaign.access.revoked for events_poll. Revocation also produces system.error; only sign-out requests a credential refresh, subject to cooldown and the login-rejection block.

  • character_validate always includes validation_reliable:false: CozyVTT v1.5.0 fixes the v1.4.0 validation defect; the bridge retains the false flag because a running server may be unverified.

  • initiative_read(refresh=true) requests fresh state and reports unknown on timeout; use the returned server token coordinates because the server may clamp positions to the map.

  • Route-missing 404 — upstream message exactly The requested resource does not exist — returns This CozyVTT instance does not provide this feature; upgrade to a supported version and retry. Other 404s return Resource not found or inaccessible to the current account (HTTP 404): <upstream message>. Error data preserves the status and upstream detail. Uploading a DOCUMENT to an old upload route may return 400; that error is preserved without retrying with a different type or scope.

Requirements

  • Python ≥ 3.11

  • A CozyVTT v1.5.3 instance (the current default baseline; see compatibility evidence and limits) and a campaign where your account has the permissions required by the tools

  • uv (recommended) or pip

Install

git clone https://github.com/yanjingzhaisun/cozyvtt-mcp.git
cd cozyvtt-mcp
uv sync   # or: python -m venv .venv && .venv/bin/pip install fastmcp requests "python-socketio[client]" websocket-client

Docker (stdio)

docker build -t cozyvtt-mcp:0.6.1 .
docker run --rm -i --env-file /path/to/cozyvtt.env cozyvtt-mcp:0.6.1

Use -i to keep stdin open; MCP uses stdin/stdout, without a network port or TTY. The image installs only compatible, hash-checked runtime wheels from uv.lock, including fastmcp, requests, python-socketio[client], and websocket-client. No editable package install or dependency re-resolution is performed. Credentials are supplied at runtime. Without any COZYVTT variables, initialize and tools/list still work; only business tool calls initialize authentication. Mount upload files inside the container and pass those container paths to document_upload. Mount /app/downloads if binary downloads must survive container removal.

Wheel URLs come from the lock as direct links with sha256 hashes, so only the host serving those blobs is configurable. The default is the canonical CDN; builders in mainland China can use a mirror, which serves byte-identical files (the hashes still verify):

docker build --build-arg WHEEL_BASE=https://mirrors.aliyun.com/pypi/packages -t cozyvtt-mcp:0.6.1 .

scripts/docker_requirements.py --wheel-base "" keeps the lock file's own URLs.

Configuration

Environment variables (no secrets in the repo):

Var

Example

Notes

COZYVTT_URL

http://localhost:8899

Your instance URL

COZYVTT_EMAIL

dm@example.local

DM account

COZYVTT_PASSWORD

—

DM password

COZYVTT_CAMPAIGN_ID

uuid

Target campaign

Hermes Agent (config.yaml)

mcp_servers:
  cozyvtt:
    command: /path/to/cozyvtt-mcp/.venv/bin/python
    args: [/path/to/cozyvtt-mcp/server.py]
    env:
      COZYVTT_URL: "http://localhost:8899"
      COZYVTT_EMAIL: "dm@example.local"
      COZYVTT_PASSWORD: "<secret>"
      COZYVTT_CAMPAIGN_ID: "<campaign-uuid>"

Restart Hermes after registering (MCP servers are not hot-reloaded).

Generic MCP client

Any stdio-capable client: command = the venv python, args = server.py, env as above.

Testing

.venv/bin/python -m pytest -q

The guarded smoke helper retains its original scripts/smoke_v150.py filename and accepts any explicit upstream pin. --deployed-version defaults to v1.5.3; --deployed-revision defaults to 1dd6bccd536afe1defc48dfc42378653e86d6343 and requires a full 40-character hexadecimal revision. The nonempty version and revision must exactly match cozyvtt_version and source_revision in the JSON file supplied with --deployment-evidence. Both values are emitted in the report. To smoke an older or different revision, supply both flags and its matching evidence.

Create an evidence file outside the repository using this structure, replacing evidence with the actual operator verification record (never credentials):

{
  "cozyvtt_version": "v1.5.3",
  "source_revision": "1dd6bccd536afe1defc48dfc42378653e86d6343",
  "evidence": "Replace with the operator's deployment verification record"
}

Check the pin offline before a live run:

COZYVTT_SMOKE=1 .venv/bin/python scripts/smoke_v150.py \
  --dry-run --allow-login \
  --deployed-version v1.5.3 \
  --deployed-revision 1dd6bccd536afe1defc48dfc42378653e86d6343 \
  --deployment-evidence /path/to/deployment-evidence.json \
  --report /path/to/smoke-dry-run.json

--dry-run checks evidence without reading credentials, initializing the bridge, or contacting the network. Its report is identified as a dry run and does not prove live compatibility. It still requires COZYVTT_SMOKE=1, an explicit --cookie-file or --allow-login choice, evidence, and a report path.

For an authorized live read-only smoke, set COZYVTT_URL, COZYVTT_CAMPAIGN_ID, COZYVTT_EMAIL and COZYVTT_PASSWORD in the environment as described under Configuration, then run:

COZYVTT_SMOKE=1 .venv/bin/python scripts/smoke_v150.py \
  --allow-login \
  --deployed-version v1.5.3 \
  --deployed-revision 1dd6bccd536afe1defc48dfc42378653e86d6343 \
  --deployment-evidence /path/to/deployment-evidence.json \
  --report /path/to/smoke-report.json

Alternatively, replace --allow-login with --cookie-file /path/to/session-cookie.txt: the file must be outside the repository with mode 0600; no default credential path exists. Add --ws only when passive WS observation is authorized. The helper retains its HTTP/WS allowlists, single-login/connection limits, read-only state comparisons and teardown checks. Deployment identity is operator-attested; /health does not discover the server version.

(scripts/smoke_write.py writes chat, a public roll, and a secret roll — run it manually and only on a throwaway campaign. It checks sender and unique purpose; proving that players do not receive secret rolls additionally requires an independent player connection.)

Offline tests block TCP connections and include real FastMCP in-memory and stdio checks; they do not require campaign credentials. Live integration against an attested v1.5.0 instance was verified 2026-10-04 with authenticated read-only REST and passive WS state reads; no campaign writes or multi-user isolation were tested. Historical v1.4.0 read/write evidence remains historical. The local venv used for verification runs Python 3.12.13; Python 3.13 remains unverified.

Troubleshooting

  • Logs: logs/cozyvtt-mcp.log (auth events, WS state, tool calls; never contains passwords)

  • Repeated 401: reviewed v1.4.0 limits failed credential attempts to 5 per 15 minutes/IP. Successful credential requests do not count there; older accounting is unverified. The bridge enforces a re-login interval of at least 3 minutes, including failed attempts; Retry-After may extend it.

  • events_poll empty: may mean no new events. Inspect connected, authenticated, last_error, and connection_error; the single WS worker retries disconnected or rejected connections. Initialization failures can be retried after a 180-second cooldown without restarting.

  • CoC7e initiative doesn't roll dice: upstream behavior — CoC7e initiative is DEX-ordered, no roll is produced

License

MIT (see LICENSE). CozyVTT itself is AGPLv3 — this project is an independent API client and contains no CozyVTT code.

Ecosystem

  • dnd5e-rules — deterministic D&D 5e rules calculations (pure functions, SRD 5.1 data under CC-BY-4.0). The rules layer we pair with this bridge: the server rolls the dice, the bridge carries them, this library does the math, the agent narrates.

Available Tools

41 tools
campaign_document_listCampaign Document ListA
Read-onlyIdempotent

List native and shared documents visible in the configured campaign. Use document_list for asset-library filters and document_read for content. Read-only for members. shared=false identifies a native document without a separate link to revoke; document_unshare cannot remove that source of access. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: no named parameters. Returns: object

campaign_getCampaign GetA
Read-onlyIdempotent

Read campaign identity, role, health, current map, and capability evidence. Use this for orientation; use map_list for all maps and session_list for sessions. Read-only for campaign members; /health reachability is not feature support, and unprobed capabilities remain unknown. Repeating reads does not change game state. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: no named parameters. Returns: object

campaign_transfer_dmCampaign Transfer DmA
Destructive

Transfer the campaign DM role to an existing member, or reclaim it as owner. Use campaign_get to inspect current role/ownership first. Upstream permits DM, owner, or admin; owner reclaim uses the owner's own ID. The old DM becomes PLAYER, ownerId stays unchanged, and local role/system caches are invalidated after success. Do not simulate this with separate role edits. Role changes and broadcasts are not guaranteed idempotent; inspect campaign_get before considering another transfer. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: user_id (required). Returns: object

character_createCharacter CreateA

Create a character sheet and ensure it appears in the current campaign roster. Use character_update for an existing sheet and token_add to place a linked token; creation does not place one. Campaign gameSystem determines the initial schema; upstream validates membership and sheet data. Do not trust character_validate as a save gate. After POST, the bridge reads the roster and assigns only if not found. This is not atomic or idempotent: assignment failure returns ok=false with the created character ID in data; missing ID means creation status is unknown. Inspect the roster/UI and recover the existing sheet instead of creating a duplicate. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: name (required), data, token_image_url. Returns: object

character_deleteCharacter DeleteA
DestructiveIdempotent

Delete a character sheet permanently (owner only). Use character_get to inspect the sheet first and character_update to edit it; use token_delete to remove only a placed map token. This deletes the sheet itself, not just its campaign assignment. DM authority alone does not grant deletion rights. It has no undo tool and does not remove map tokens. Repeating leaves the sheet absent but may return a not-found error. Returns upstream {message} in data; REST permission and resource errors retain diagnostics. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: character_id (required). Returns: object

character_getCharacter GetA
Read-onlyIdempotent

Read a full character sheet by ID, preserving unknown fields. Use character_list to discover roster IDs and character_update to patch a sheet. Upstream allows the owner or campaign members to read; keeper data.notes are not private DM fields. Interpret data using the character's own gameSystem, preserving CoC fields and DND hitDice structures. Repeated reads do not alter the sheet. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: character_id (required). Returns: object

character_hitdice_spendCharacter Hitdice SpendA
Destructive

Spend one remaining use from a DND_5E character's Hit Dice pool through WS. Use character_get to inspect pools first; dice_roll and token_hp_update perform rolling and healing separately, with no shared transaction. Upstream requires the character owner or DM and campaign assignment. index selects an array entry, not a dice count. Repeating spends again. Only the system is gated locally: there is no v1.5.0 permits the owner or DM but never a spectator. There is no reliable capability probe, and older servers may silently ignore this event. Returns sent:true,confirmed:false,status:"pending" inside data: dispatch is not a business ACK. Read events_poll for results/system.error and inspect state before further action; never blindly resend. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: index (required), character_id (required). Returns: object

character_listCharacter ListA
Read-onlyIdempotent

List the configured campaign roster to discover character IDs and assignments. Use character_get for one full sheet or character_create to add a sheet. Read-only for campaign members; no creation or roster changes occur on repeat calls. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: no named parameters. Returns: object

character_updateCharacter UpdateA
Destructive

Patch an existing sheet while preserving unspecified fields (owner or campaign DM). Use character_get first; use token_hp_update for a signed HP change and character_create for a new sheet. data is a request-field object, e.g. {"data":{"hp":{"current":5}}}. Only name/data/tokenImageUrl are allowed at the top level. Nested data dictionaries merge recursively after a GET; arrays/scalars replace whole values and null is an explicit value, not deletion. The caller calculates rules values using the sheet's own gameSystem. Updates are locked only within this process; concurrent browser saves may be lost outside this tool's GET-to-PUT window. On servers supporting updatedAt guards, changes after this tool's GET produce a visible conflict; this does not protect stale intent from an earlier character_get. Upstream parsed validation may discard undeclared fixed-system fields even though this bridge preserves them outbound. REST errors retain diagnostics. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: data (required), character_id (required). Returns: object

character_validateCharacter ValidateA
Read-onlyIdempotent

Read upstream validation diagnostics for an owned character with a fixed gameSystem. Use character_get to inspect fields; do not use this as a reliable save gate. v1.4.0 ignores validation failures, so isValid=true does not prove validity; older-version reliability is unknown. Always adds validation_reliable=false and validation_note. Owner-only upstream read; repeating it does not repair or save data. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: character_id (required). Returns: object

chat_readChat ReadA
Read-onlyIdempotent

Read persisted campaign messages with opaque cursor pagination. Use chat_read for narration history; use events_poll for dice results and live events. Read-only for campaign members. Start without a cursor, then pass nextCursor unchanged; stop at null. Older servers support only the latest page and reject cursor history. DICE_ROLL entries are excluded. Repeated reads do not consume messages. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: limit, cursor. Returns: object

chat_sendChat SendA

Post one campaign chat message as narration or player dialogue. Use chat_read to inspect history; use dice_roll for dice, not chat text pretending to be a roll. Authenticated campaign membership is required; type is a message category, not a role grant. On v1.5.0 the server selects the resulting broadcast category from the authenticated role. Upstream campaign chat cooldown may reject messages. Creates a new message on each accepted send; do not retry blindly. Returns sent:true,confirmed:false,status:"pending" inside data: dispatch is not a business ACK. Read events_poll for results/system.error and inspect state before further action; never blindly resend. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: content (required), type. Returns: object

dice_rollDice RollA

Roll server-authoritative dice and publish the result to the permitted audience. Use saved_roll_list for stored expressions; saving a macro does not execute it. Authenticated campaign users may roll. Public rolls broadcast to the campaign; v1.5.0 permits DM and PLAYER rolls, not spectators; secret routing and the shared user budget remain server-authoritative. Each send creates a new roll; never retry on missing results. Calls queue with a 2.1-second minimum between actual sends, retaining the older 30/minute policy. Newer servers allow higher rates but cap characterName at 200 and purpose at 300 characters; server errors remain visible through events_poll. The bridge performs no random generation or rules calculations. Returns sent:true,confirmed:false,status:"pending" inside data: dispatch is not a business ACK. Read events_poll for results/system.error and inspect state before further action; never blindly resend. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: expression (required), purpose, is_secret, character_name. Returns: object

document_createDocument CreateA

Create a new txt/md document from inline content through REST. Use document_upload for PDF or larger local files, and document_update to replace existing text. Name and description are trimmed; content preserves whitespace. USER is personal, CAMPAIGN requires its DM, and GLOBAL rights are enforced upstream. Each accepted call creates a separate asset. Content is capped at 900 KiB UTF-8; upstream JSON limits also apply. Upload/create share a default 30 requests/minute/user limit. Creation does not separately link a personal asset; use document_share for that. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: name (required), format (required), content (required), scope, +2 more. Returns: object

document_deleteDocument DeleteA
DestructiveIdempotent

Delete a document asset and all of its share links. Use document_unshare to remove only one campaign link and document_read to inspect content first. Upstream enforces uploader/DM/admin permissions according to scope. Deletion is destructive; local downloaded copies remain. Repeating leaves the asset absent but can return a not-found error. This tool does not offer an undo operation. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: document_id (required). Returns: object

document_listDocument ListA
Read-onlyIdempotent

List document assets with scope, search, and page filters. Use campaign_document_list to discover personal documents shared into this campaign; use document_read for content. Read-only; upstream filters by access. USER restricts to personal assets (including an explicit current-user filter for admins); null scope leaves filtering to upstream. Repeated listing does not consume or modify assets. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: page, limit, scope, search, +1 more. Returns: object

document_readDocument ReadA
Read-onlyIdempotent

Read an accessible document as text or a local binary download. Use document_list/campaign_document_list to discover IDs; use document_update to replace txt/md content. Upstream checks asset visibility, including shared access. Does not modify upstream data, but binary reads atomically replace downloads/.pdf (or .bin) locally; readOnlyHint refers to the upstream resource. Text returns mime_type/etag/content. Binary returns mime_type/etag/file_path/file_size, never inline bytes. Pass etag unchanged for a conditional read: 304 returns not_modified=true without content, so retain your cached copy. Repeated reads may refresh the local file. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: document_id (required), etag. Returns: object

document_shareDocument ShareA

Link a shareable document asset into the configured campaign (DM only). Use campaign_document_list to inspect existing links, or document_upload to create an asset first. Upstream validates asset ownership, UUID, and sharing rights. Sharing broadens access without copying the asset. Duplicate-link behavior is upstream-controlled; do not assume retries are idempotent. Use document_unshare to revoke this link, not document_delete, which removes the asset everywhere. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: document_id (required). Returns: object

document_unshareDocument UnshareA
DestructiveIdempotent

Remove one document share link from the configured campaign (DM only). Inspect campaign_document_list first: shared=false denotes a native document with no separate link to revoke. Use document_delete only to delete the asset everywhere. This leaves the asset, other links, local downloads, and GLOBAL/native read access intact. Repeating removes no additional link but may return a not-found error. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: document_id (required). Returns: object

document_updateDocument UpdateA
Destructive

Replace an entire txt/md document's content with upstream-enforced edit rights. Use document_read first to avoid losing text; use document_create for a new asset or document_upload for PDF. This is replacement, not merge-patching, and cannot edit PDF content. Consult campaign_document_list's canEdit when supplied; rights depend on asset scope and current membership, not uploader identity alone. Empty content clears the text. Repeated writes can update metadata or notifications; no full-operation idempotency is promised. Returns upstream REST data. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: content (required), document_id (required). Returns: object

document_uploadDocument UploadA

Upload an existing local PDF/txt/md file as a document asset using multipart REST. Use document_create for inline text, or document_share to link an existing asset. Reads the MCP server/container filesystem; client-local paths must be mounted. Creates an asset on each accepted call, so retries may duplicate it. Scope controls access: CAMPAIGN requires that campaign's DM; other scope rights are upstream-enforced. The server checks signatures and its size cap (default 50 MiB), with a shared upload/create limit of 30/minute/user by default. A 400 is preserved without fallback upload. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: file_path (required), name, tags, scope, +2 more. Returns: object

events_pollEvents PollA
Read-onlyIdempotent

Read buffered campaign events and asynchronous write errors without consuming them. Use after WS writes; use chat_read for persisted chat history. May connect WS lazily, but does not change game state. Returns earliest seq > since first; advance using next_seq (latest_seq is its alias), not high_water_seq. Check gap for eviction from the 500-event buffer, cursor_reset after process restart, and has_more for pagination. Inspect system.error and relevant state to assess pending writes; broadcasts are not correlated ACKs. Buffered events remain available on connection failure, marked stale; this is not durable dice history. v1.5.0 role/map/token notifications are also forwarded; drag frames remain observations, not proof of persisted state. Repeated reads can include newly arriving events. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: limit, since. Returns: object

initiative_manageInitiative ManageA
Destructive

Modify campaign combatants, initiative values, order, or combat lifecycle. Use initiative_read for current state and events_poll for results/errors. Structural actions are DM-only; v1.4.0 also permits a controlling player to roll for an already added token before combat, subject to upstream checks. Older permission behavior is unverified. Actions may remove entries, clear state, reroll, or advance turns; the combined tool is not idempotent. add needs token_id/map_id; remove needs token_id; set needs token_id/map_id/value; reorder needs ordered_token_ids; start/next/end need only action. roll needs token_id and map_id and is gated to DND_5E/PATHFINDER_2E/SHADOWRUN_6E. The server derives system rolls; expression is a DM fallback, not a guaranteed override. CoC7e uses DEX ordering: use add/start or set. The dice_roll 2.1-second queue does not wrap initiative_manage; do not assume it throttles initiative rolls. On v1.5.0 caller-supplied characterName is ignored for initiative.roll; retain it for legacy behavior. Returns sent:true,confirmed:false,status:"pending" inside data: dispatch is not a business ACK. Read events_poll for results/system.error and inspect state before further action; never blindly resend. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: action (required), value, map_id, token_id, +3 more. Returns: object

initiative_readInitiative ReadA
Read-onlyIdempotent

Read initiative state without changing turn order or advancing combat. Use initiative_manage to modify combat and events_poll for broadcast history. Campaign members may read. By default, request a new WS state and wait up to two seconds; timeout returns state=null/stale=true, not proof that combat is inactive. refresh=false reads the current connection's cache and marks it stale. Repeated requests do not change initiative; WS authentication is still required. State is recipient-filtered and only current-generation data is treated as fresh. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: refresh. Returns: object

map_createMap CreateA

Create a campaign map using existing image assets (DM only). Use map_list to inspect existing maps and map_switch to activate one; creation does not switch the current map. This creates a map with empty tokens and annotations, not an uploaded image. Upstream checks image access and normalizes asset URLs. Newer servers require MAP image assets, cap width/height at 500 squares, and default grid sizes outside 10..500 to 50. These limits are server-enforced. Each accepted call creates another map; do not blindly retry an uncertain result. CozyVTT supplies fogEnabled, globalIllumination, and explorationEnabled defaults (false); this tool intentionally has no inputs for them. Returns upstream {map} in data without a broadcast receipt. REST validation and permission errors retain upstream diagnostics. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: name (required), width (required), height (required), image_url (required), +2 more. Returns: object

map_deleteMap DeleteA
DestructiveIdempotent

Delete a campaign map and its stored tokens and map state (DM only). Use map_list to inspect maps first; use map_switch to select another current map before deletion. Upstream rejects deletion of the current map with HTTP 400. Use token_delete to remove only one token instead of the entire map. Deletion is destructive and has no undo tool. Repeating leaves the map absent but may return a not-found error. Returns upstream {message} in data without a broadcast receipt; REST permission and resource errors retain upstream diagnostics. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: map_id (required). Returns: object

map_listMap ListA
Read-onlyIdempotent

List maps accessible in the configured campaign to choose a map ID and inspect dimensions. Use map_switch to activate one; listing does not switch maps or place tokens. Read-only for campaign members; non-DMs may see only the current map. v1.5.0 map setting flags pass through unchanged. Repeated calls leave game state unchanged. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: no named parameters. Returns: object

map_switchMap SwitchA
Destructive

Set the current campaign map through REST, then notify via WS map.change (DM only). Use map_list to choose an existing map; token_move changes a token, not the active map. REST persistence and WS dispatch are separate: persisted=true does not prove clients received the change. A WS failure returns ok=false with data.persisted=true; do not replay or roll back the saved change. Broadcast receipt remains sent=true, confirmed=false,status="pending"; inspect events_poll for results/errors, not an ACK. Repeating may repeat notifications even when the current map is already correct. v1.5.0 retains the REST-first current-map rule. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: map_id (required). Returns: object

saved_roll_createSaved Roll CreateA

Save a private dice-expression macro for the current user and campaign. Use dice_roll to execute an expression; use saved_roll_update to edit an existing macro without creating another. Members manage only their own macros. The server parses expressions and limits each user to 50 per campaign. Creation is serialized only within this process; each accepted call may create another macro. No dice are rolled and no campaign-visible message is sent by this tool. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: name (required), expression (required). Returns: object

saved_roll_deleteSaved Roll DeleteA
DestructiveIdempotent

Delete your Saved Roll from the configured campaign. Use saved_roll_list to identify it or saved_roll_update to change it without deletion. Any member may delete their own macro; cross-user/cross-campaign access returns 404. Destructive to the macro only, not roll history. Repeating leaves it absent but may return a not-found error; it does not roll dice. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: macro_id (required). Returns: object

saved_roll_listSaved Roll ListA
Read-onlyIdempotent

List complete Saved Roll macros owned by the current user in this campaign. Use dice_roll with a returned expression to execute it, or saved_roll_update to edit. Read-only for campaign members; no individual get is needed and no dice are rolled. Repeating the list does not consume macros. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: no named parameters. Returns: object

saved_roll_updateSaved Roll UpdateA
Destructive

Change the name or expression of your Saved Roll in this campaign. Use saved_roll_list to find its ID; use dice_roll to execute it. Supply at least one field; null leaves that field unchanged. Upstream validates expressions and enforces per-user/per-campaign ownership. Replacing values does not roll dice; repeated writes may change update metadata, so full-operation idempotency is not guaranteed. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: macro_id (required), name, expression. Returns: object

session_listSession ListA
Read-onlyIdempotent

List this campaign's latest 50 sessions in descending sessionNumber order, including active sessions. Use session_manage for lifecycle changes and session_notes_update for recaps. Read-only for members; notes are shared with all members, and repeated reads do not end or resume sessions. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: no named parameters. Returns: object

session_manageSession ManageA
Destructive

Start, pause, or end a campaign session through REST (DM only). Use session_list to inspect history and session_notes_update to edit or clear a recap without another lifecycle transition. start creates a session; pause/end resolve campaign.activeSession.id and fail if none exists. Lifecycle changes are not guaranteed idempotent: do not repeat start/end to repair notes. notes and save_state apply only to end; other actions reject nondefault values. End notes are campaign-wide, and empty text does not clear an existing recap. save_state requests the upstream end-of-session snapshot; it is not a bridge-side backup. Returns upstream REST data; it does not wait for a WS business ACK. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: action (required), notes, save_state. Returns: object

session_notes_updateSession Notes UpdateA
Destructive

Replace a session's shared recap without another lifecycle transition (DM only). Use session_list to find the ID; use session_manage to start/pause/end instead. All campaign members can read notes. Empty text after upstream trimming clears the recap, unlike empty notes on session_manage end. Does not end the session or broadcast a recap event. Repeated writes may alter metadata, so full-operation idempotency is not guaranteed. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: notes (required), session_id (required). Returns: object

token_addToken AddA

Create a manually configured token on a campaign map (DM only). Use token_place_creature for a library template's name/image, token_move for an existing token, and character_create when a new sheet is needed. This creates only a token; character_id optionally links an existing sheet. Position uses map units; upstream checks map bounds and layer. Width/height are integer sizes in 1..10. Newer servers require whole-square coordinates and clamp the token footprint; use returned coordinates and preserve server refusals instead of rounding input. visible and controlled_by govern display/control subject to server permissions. When controlled_by is omitted, v1.5.0 may autoassign the bound character owner; null means omit the wire field, not send null. Image access and campaign assignment remain upstream checks. REST returns persisted=true,broadcast_confirmed=false; inspect events_poll or the VTT for visibility, since persistence does not confirm a broadcast. Every accepted call creates another token, so repeated calls are not idempotent. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: x (required), y (required), name (required), map_id (required), +7 more. Returns: object

token_deleteToken DeleteA
DestructiveIdempotent

Delete one token from a campaign map (DM only). Use token_move to reposition a token instead. Use token_hp_update for a signed sheet HP adjustment through WS: that tool takes a character ID, whereas this tool takes a map token ID. Deletion removes the placed token, not its linked character sheet or HP. v1.5.0 also removes its combatants and repairs initiative order; do not send a second initiative write. It is destructive and has no undo tool. Repeating leaves the token absent but may return a not-found error. Returns upstream {message} in data without a broadcast receipt; REST permission and resource errors retain upstream diagnostics. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: map_id (required), token_id (required). Returns: object

token_hp_updateToken Hp UpdateA
Destructive

Apply a signed HP delta to a character sheet through WS, not to a token ID. Use character_get to inspect HP or character_update for an absolute sheet patch. Upstream requires character ownership or DM authority and campaign assignment; its system-specific HP rules determine the result. Positive delta heals, negative delta damages. v1.5.0 permits the owner or DM, never a spectator. Repeating applies the delta again and is not idempotent. Returns sent:true,confirmed:false,status:"pending" inside data: dispatch is not a business ACK. Read events_poll for results/system.error and inspect state before further action; never blindly resend. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: delta (required), character_id (required). Returns: object

token_moveToken MoveA
Destructive

Set an existing token's absolute position through REST. Use token_add to create a token or map_switch to change the active map. The bridge rejects SPECTATOR/unknown roles; upstream requires DM or the controlling player. The same coordinates produce the same position, but repeated writes may produce notifications. Returns persisted=true,broadcast_confirmed=false; REST does not itself emit map.changed. On both REST and WS token.move, PLAYER must use the current campaign map; DM may use any map of this campaign. Upstream applies control, plane, and session-state restrictions; returned token fields may be null. Newer servers require whole-square coordinates and may clamp the footprint at map edges. Read the returned position rather than assuming the requested one. Inspect events_poll or the VTT before assuming others saw the move; this result is not a correlated broadcast ACK. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: x (required), y (required), map_id (required), token_id (required). Returns: object

token_place_creatureToken Place CreatureA

Create a visible 1x1 token from a library template's name and image (DM only). Use creature_search to obtain a template ID; use token_add for custom size, layer, controller, visibility, or a character link. This reads the template and copies only name/image into a token: it does not create a sheet or copy creature stats. Fails before creation if no usable image exists. Position must be within the map. Each accepted call creates another token. Returns upstream REST data without a broadcast receipt; the template read is DM-only and upstream validates image access. Use events_poll or the VTT to inspect subsequent visibility. Returns {ok:true,data} on success; tool-body failures return {ok:false,error} with optional diagnostic data. Argument-schema errors are MCP errors.

Inputs: x (required), y (required), map_id (required), creature_id (required). Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 41 tools

    Disambiguation4/5

    Tools target distinct resource+action pairs, and descriptions actively steer callers (e.g. token_add vs token_place_creature, token_hp_update vs character_update, document_list vs campaign_document_list). A few near-neighbors remain (map_list vs campaign_get's current-map, character_hitdice_spend vs character_update), but each is explicitly cross-referenced with 'use X for Y' guidance, so misselection risk is low.

    Naming Consistency5/5

    All 41 names follow a single snake_case resource_action pattern (map_list, token_move, character_get, saved_roll_create, session_notes_update, campaign_transfer_dm). Multi-word resources like token_hp_update and character_hitdice_spend still read predictably. No camelCase or verb-style mixing.

    Tool Count2/5

    41 tools is well beyond the 3-15 well-scoped range; even for a broad VTT domain this is heavy and increases selection cost. Many are individually justified (four saved_roll CRUD ops, full document share lifecycle), but the surface could contract via grouped operations (e.g. token modifications, session lifecycle) without losing capability.

    Completeness3/5

    Strong coverage overall: maps, characters, documents, sessions, initiative, chat, dice, saved rolls, and events all have read/write surfaces. However, notable gaps exist—no token read/list or general token update (only add, place, move, delete), no chat edit/delete, and no fog/annotation tools despite map fog defaults being referenced. These force agents to work around missing operations.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      A
      maintenance
      Connects Claude Desktop to Foundry VTT for AI-powered campaign management, enabling natural language interaction with game data including quest creation, character management, compendium searches, and dice rolling. Provides 20 MCP tools for seamless integration between Claude and your tabletop RPG sessions.
      87
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants to act as RPG Game Masters by managing campaign state including characters, inventory, quests, and logs through MCP tools. Supports campaign mutations and provides both MCP and HTTP API access to RPG session data.
      2
      -