MCP MeasureMCP Measure

인덱스 관측됨

Moddable Games Tools

15 tools for chess variant analysis, hex map generation, and board game utilities

사용해야 할까요

품질 및 안전성

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

발견 사항 (7)

  • LOWTool 'oracle_roll' description lacks action verboracle_roll에서
  • LOWTool 'oracle_ask' description lacks action verboracle_ask에서
  • LOWTool 'rpg_browse_category' description lacks action verbrpg_browse_category에서
  • LOWTool 'oracle_interpret' description lacks action verboracle_interpret에서
  • LOWTool 'oracle_table_view' description lacks action verboracle_table_view에서
  • LOWTool 'game_deck_deal' description lacks action verbgame_deck_deal에서
  • LOWTool 'dice_roll' description lacks action verbdice_roll에서

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

컨텍스트 비용

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

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

설치

원클릭 설치

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

{
  "mcpServers": {
    "moddable-games-tools": {
      "url": "https://tools.moddable.games/mcp"
    }
  }
}

원격 엔드포인트

https://tools.moddable.games/mcpstreamable-http

할 수 있는 일

도구 목록

도구 (89)

🟢 읽기 전용🟡 쓰기🔴 삭제⚪ 알 수 없음
🟢chess_generate_puzzle(variant, difficulty, theme)

Get a random chess puzzle. Filter by variant or difficulty. Variant puzzles have no themes and max rating 1400 — theme and hard difficulty filters only apply to standard puzzles.

입력 스키마

{
  "type": "object",
  "properties": {
    "variant": {
      "type": "string",
      "description": "Chess variant slug, camelCase or kebab-case (e.g. antichess, almost-chess, atomic, chess960, standard). Returns only puzzles for this variant."
    },
    "difficulty": {
      "type": "string",
      "enum": [
        "easy",
        "medium",
        "hard"
      ],
      "description": "Puzzle difficulty (variant puzzles max at 1400, so hard returns nothing for variants)"
    },
    "theme": {
      "type": "string",
      "description": "Puzzle theme (fork, pin, skewer, mateIn2, etc). Only standard puzzles carry themes."
    }
  }
}
🟢chess_list_puzzle_types

List available puzzle variants, themes, and per-variant counts from the puzzle pool

입력 스키마

{
  "type": "object",
  "properties": {}
}
🟢chess_list_variants(group)

[DEPRECATED — use play_list_variants] List chess variants. Removal: v1.0.0.

입력 스키마

{
  "type": "object",
  "properties": {
    "group": {
      "type": "string"
    }
  }
}
🟡chess_get_legal_moves(variant)

[DEPRECATED — use play_create_game + play_get_moves] Get legal moves for a chess position. Removal: v1.0.0.

입력 스키마

{
  "type": "object",
  "properties": {
    "variant": {
      "type": "string"
    }
  }
}
🟢chess_analyze_position(variant, depth)

[DEPRECATED — use play_suggest_move] Analyse a chess position. Removal: v1.0.0.

입력 스키마

{
  "type": "object",
  "properties": {
    "variant": {
      "type": "string"
    },
    "depth": {
      "type": "number"
    }
  }
}
⚪chess_make_move(move, variant)

[DEPRECATED — use play_apply_move] Apply a move to a chess game. Removal: v1.0.0.

입력 스키마

{
  "type": "object",
  "properties": {
    "move": {
      "type": "object"
    },
    "variant": {
      "type": "string"
    }
  },
  "required": [
    "move"
  ]
}
🟢chess_validate_move(move, variant)

[DEPRECATED — use play_validate_move] Check if a chess move is legal. Removal: v1.0.0.

입력 스키마

{
  "type": "object",
  "properties": {
    "move": {
      "type": "object"
    },
    "variant": {
      "type": "string"
    }
  },
  "required": [
    "move"
  ]
}
🟢chess_get_status(variant)

[DEPRECATED — use play_check_status] Get chess game status. Removal: v1.0.0.

입력 스키마

{
  "type": "object",
  "properties": {
    "variant": {
      "type": "string"
    }
  }
}
⚪chess_render_svg(variant, fen, highlights)

[DEPRECATED — use play_render_board] Render a chess position as SVG. Removal: v1.0.0.

입력 스키마

{
  "type": "object",
  "properties": {
    "variant": {
      "type": "string"
    },
    "fen": {
      "type": "string",
      "description": "FEN position string"
    },
    "highlights": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Squares to highlight (e.g. [\"e2\",\"e4\"])"
    }
  }
}
⚪chess_make_moves(moves, variant)

[DEPRECATED — use play_make_moves] Apply a sequence of chess moves. Removal: v1.0.0.

입력 스키마

{
  "type": "object",
  "properties": {
    "moves": {
      "type": "array",
      "items": {
        "type": "object"
      }
    },
    "variant": {
      "type": "string"
    }
  },
  "required": [
    "moves"
  ]
}
🟢chess_get_opening_book(variant)

[REMOVED — engine#98] Opening book resolution is broken in Worker context. No replacement.

입력 스키마

{
  "type": "object",
  "properties": {
    "variant": {
      "type": "string"
    }
  }
}
🟢hex_list_games

List all available hex map game types with configuration options

입력 스키마

{
  "type": "object",
  "properties": {}
}
🟢hex_generate_map(game, players, size, seed)

Generate a hex map for a specific game and player count

입력 스키마

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game type (nukes, colony, catan, age-of-steam, eclipse, twilight-imperium)"
    },
    "players": {
      "type": "number",
      "description": "Number of players (default: 2)"
    },
    "size": {
      "type": "number",
      "description": "Map size (default: game default)"
    },
    "seed": {
      "type": "string",
      "description": "Random seed for reproducibility"
    }
  },
  "required": [
    "game"
  ]
}
⚪hex_export_svg(game, players, size, seed, style, ...)

Generate a hex map and export as SVG

입력 스키마

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game type"
    },
    "players": {
      "type": "number",
      "description": "Number of players"
    },
    "size": {
      "type": "number",
      "description": "Map size"
    },
    "seed": {
      "type": "string",
      "description": "Random seed"
    },
    "style": {
      "type": "string",
      "description": "Visual style"
    },
    "hexSize": {
      "type": "number",
      "description": "Hex size in pixels (default: 30)"
    }
  },
  "required": [
    "game"
  ]
}
🟢hex_get_info(q, r, game, seed)

Get info about a specific hex coordinate (terrain, neighbours, distance)

입력 스키마

{
  "type": "object",
  "properties": {
    "q": {
      "type": "number",
      "description": "Hex Q coordinate (column)"
    },
    "r": {
      "type": "number",
      "description": "Hex R coordinate (row)"
    },
    "game": {
      "type": "string",
      "description": "Game context for terrain lookup"
    },
    "seed": {
      "type": "string",
      "description": "Map seed (to look up terrain from a generated map)"
    }
  },
  "required": [
    "q",
    "r"
  ]
}
🟢hex_compute_fov(q, r, range, game, seed)

Compute field of view from a hex position

입력 스키마

{
  "type": "object",
  "properties": {
    "q": {
      "type": "number",
      "description": "Origin Q coordinate"
    },
    "r": {
      "type": "number",
      "description": "Origin R coordinate"
    },
    "range": {
      "type": "number",
      "description": "Vision range in hexes"
    },
    "game": {
      "type": "string",
      "description": "Game context for obstacle lookup"
    },
    "seed": {
      "type": "string",
      "description": "Map seed"
    }
  },
  "required": [
    "q",
    "r",
    "range"
  ]
}
🟢hex_pathfind(startQ, startR, endQ, endR, game, ...)

Find shortest path between two hex coordinates

입력 스키마

{
  "type": "object",
  "properties": {
    "startQ": {
      "type": "number",
      "description": "Start Q"
    },
    "startR": {
      "type": "number",
      "description": "Start R"
    },
    "endQ": {
      "type": "number",
      "description": "End Q"
    },
    "endR": {
      "type": "number",
      "description": "End R"
    },
    "game": {
      "type": "string",
      "description": "Game context for movement costs"
    },
    "seed": {
      "type": "string",
      "description": "Map seed"
    }
  },
  "required": [
    "startQ",
    "startR",
    "endQ",
    "endR"
  ]
}
🟢play_list_families

List all playable game families supported by the engine (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game)

입력 스키마

{
  "type": "object",
  "properties": {}
}
🟡play_list_variants(family)

List available variants for a game family. Each variant can be passed to play_create_game. Variants with flags (e.g. +random) can be requested as "slug+flag".

입력 스키마

{
  "type": "object",
  "properties": {
    "family": {
      "type": "string",
      "description": "Game family (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game)"
    }
  },
  "required": [
    "family"
  ]
}
🟢play_get_definition(family, variant)

Get the full engine definition (topology, render config, pieces, setup FEN) for a game variant. Returns the resolved frontmatter used to render and play the game.

입력 스키마

{
  "type": "object",
  "properties": {
    "family": {
      "type": "string",
      "description": "Game family (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game)"
    },
    "variant": {
      "type": "string",
      "description": "Variant slug (default: standard)"
    }
  },
  "required": [
    "family"
  ]
}
🟡play_create_game(family, variant, rngSeed)

Create a new game instance for a given family. Returns initial state to pass to subsequent calls. Variant can include flags like "grand+random" or "standard+drops".

입력 스키마

{
  "type": "object",
  "properties": {
    "family": {
      "type": "string",
      "description": "Game family name (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game)"
    },
    "variant": {
      "type": "string",
      "description": "Variant slug, optionally with flags (e.g. \"grand\", \"grand+random\", \"standard+drops\")"
    },
    "rngSeed": {
      "type": "number",
      "description": "Optional RNG seed for deterministic games"
    }
  },
  "required": [
    "family"
  ]
}
🟡play_get_moves(state)

Get all legal moves for the current position. Requires state from play_create_game or play_apply_move.

입력 스키마

{
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object returned by play_create_game or play_apply_move"
    }
  },
  "required": [
    "state"
  ]
}
🟢play_apply_move(state, move)

Apply a move to the game and return the new state. Pass the move object exactly as returned by play_get_moves (format varies by family: chess uses {from,to}, go uses {coord} or {action:"pass"}).

입력 스키마

{
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or a previous play_apply_move"
    },
    "move": {
      "type": "object",
      "description": "Move object from play_get_moves (e.g. {from:\"e2\",to:\"e4\"} for chess, {coord:40} for go, {action:\"pass\"})"
    }
  },
  "required": [
    "state",
    "move"
  ]
}
🟢play_check_status(state)

Check the current game status: whose turn it is, whether the game is over, and who won.

입력 스키마

{
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    }
  },
  "required": [
    "state"
  ]
}
⚪play_suggest_move(state, difficulty)

Use AI to analyse the position and suggest the best move. Supports 5 difficulty levels across all 10 playable families.

입력 스키마

{
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    },
    "difficulty": {
      "type": "string",
      "enum": [
        "beginner",
        "easy",
        "medium",
        "hard",
        "expert"
      ],
      "description": "AI difficulty level (default: medium)"
    }
  },
  "required": [
    "state"
  ]
}
⚪play_render_board(state, highlights, size)

Render the current board position as SVG for any playable family (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game).

입력 스키마

{
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    },
    "highlights": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "key": {
            "type": "integer"
          },
          "color": {
            "type": "string"
          }
        }
      },
      "description": "Optional cells to highlight (e.g. [{key: 52, color: \"#ff0\"}])"
    },
    "size": {
      "type": "integer",
      "description": "Board width in pixels for PNG output (default: 480, max: 2048)"
    }
  },
  "required": [
    "state"
  ]
}
⚪play_export_fen(state)

Export the current board position as a FEN-style notation string. Works for all 10 families (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game).

입력 스키마

{
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    }
  },
  "required": [
    "state"
  ]
}
🟡play_load_fen(family, fen, variant)

Create a game state from a FEN-style position string. Works for all 10 families.

입력 스키마

{
  "type": "object",
  "properties": {
    "family": {
      "type": "string",
      "description": "Game family (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game)"
    },
    "fen": {
      "type": "string",
      "description": "Position string in FEN-style notation for the family"
    },
    "variant": {
      "type": "string",
      "description": "Optional variant slug"
    }
  },
  "required": [
    "family",
    "fen"
  ]
}
🟢play_validate_move(state, move)

Check whether a move is legal in the current position without applying it. Pass the move object in the same format as play_get_moves returns.

입력 스키마

{
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    },
    "move": {
      "type": "object",
      "description": "Move object to validate (same format as play_get_moves output)"
    }
  },
  "required": [
    "state",
    "move"
  ]
}
🟢play_make_moves(state, moves)

Apply a sequence of moves to a game and return the final state. Stops at the first illegal move. Move objects must match play_get_moves format.

입력 스키마

{
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    },
    "moves": {
      "type": "array",
      "items": {
        "type": "object"
      },
      "description": "Array of move objects in the format returned by play_get_moves"
    }
  },
  "required": [
    "state",
    "moves"
  ]
}
🟢rules_list_games(category, complexity, mechanic, status)

List all available game rulebooks with metadata (players, duration, complexity, mechanics). Filterable by type, complexity, and mechanics.

입력 스키마

{
  "type": "object",
  "properties": {
    "category": {
      "type": "string",
      "description": "Filter by type (standalone, hub, classic, rpg, component, platform, mod, game)"
    },
    "complexity": {
      "type": "string",
      "enum": [
        "simple",
        "moderate",
        "complex"
      ],
      "description": "Filter by complexity level"
    },
    "mechanic": {
      "type": "string",
      "description": "Filter by mechanic (e.g. dice, capture, hex, oracle, narrative)"
    },
    "status": {
      "type": "string",
      "enum": [
        "live",
        "alpha",
        "playtest"
      ],
      "description": "Filter by status (default: all)"
    }
  }
}
🟢rules_get_game(game)

Get full rulebook content for a specific game (markdown). For metadata only, use rules_get_game_meta instead.

입력 스키마

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game slug (e.g. chess, dnd-5e, catan)"
    }
  },
  "required": [
    "game"
  ]
}
🟢rules_get_game_meta(game)

Get structured metadata for a game: players, duration, complexity, mechanics, how_to_play, variant list, page list, related games. Lightweight alternative to fetching the full rulebook.

입력 스키마

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game slug (e.g. chess, backgammon, cairn)"
    }
  },
  "required": [
    "game"
  ]
}
🟢rules_get_page(game, section, page)

Get a specific page/section from a game rulebook (e.g. character creation, combat rules, marketplace). Use rules_get_game_meta to see available pages.

입력 스키마

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game slug (e.g. cairn, dnd-5e)"
    },
    "section": {
      "type": "string",
      "description": "Section name (e.g. rules, classes, spells). Default: rules"
    },
    "page": {
      "type": "string",
      "description": "Page slug (e.g. character-creation, combat-and-difficulty)"
    }
  },
  "required": [
    "game",
    "page"
  ]
}
🟢rules_get_variant_list(game, playable, topology)

List all variants for a game with structured metadata (players, board, playable status, topology, engine config). Much richer than parsing the rulebook.

입력 스키마

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game slug (e.g. chess, backgammon, draughts)"
    },
    "playable": {
      "type": "boolean",
      "description": "Filter to only engine-playable variants"
    },
    "topology": {
      "type": "string",
      "description": "Filter by board topology (grid, hex, track, graph, tableau)"
    }
  },
  "required": [
    "game"
  ]
}
🟢rules_get_diagram(game, variant)

Get board diagram SVG URL for a game variant. Returns the diagram path, topology, and rendering metadata.

입력 스키마

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game family slug (e.g. chess, go, agon)"
    },
    "variant": {
      "type": "string",
      "description": "Variant slug (default: standard)"
    }
  },
  "required": [
    "game"
  ]
}
🟢rules_get_variant(game, variant)

Get rules for a specific game variant

입력 스키마

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game slug"
    },
    "variant": {
      "type": "string",
      "description": "Variant slug"
    }
  },
  "required": [
    "game",
    "variant"
  ]
}
🟢rules_search(query, game, sectionType, limit)

Full-text search across all published rulebooks. Returns section-typed results with deep-link anchors.

입력 스키마

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Search query"
    },
    "game": {
      "type": "string",
      "description": "Limit to specific game slug"
    },
    "sectionType": {
      "type": "string",
      "description": "Filter by section type (general, board, pieces, setup, movement, capture, winning, special, variants)"
    },
    "limit": {
      "type": "number",
      "description": "Max results (default 10)"
    }
  },
  "required": [
    "query"
  ]
}
🟢rules_random(players, maxDuration)

Get a random game suggestion from the library

입력 스키마

{
  "type": "object",
  "properties": {
    "players": {
      "type": "number",
      "description": "Number of players available"
    },
    "maxDuration": {
      "type": "number",
      "description": "Maximum game duration in minutes"
    }
  }
}
🟢board_gallery_search(query, limit)

Search the board gallery (334 rendered board layouts across 33 game families)

입력 스키마

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Search term (e.g. \"8x8\", \"hex\", \"shogi\")"
    },
    "limit": {
      "type": "number",
      "description": "Max results (default 10)"
    }
  }
}
🟢board_gallery_get(board)

Get details of a specific board layout by ID

입력 스키마

{
  "type": "object",
  "properties": {
    "board": {
      "type": "string",
      "description": "Board ID or name"
    }
  },
  "required": [
    "board"
  ]
}
🟢tile_gallery_search(query)

Search hex tile sets by name, game, or terrain type

입력 스키마

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Search term (omit to list all)"
    }
  }
}
🟡tile_gallery_get(set)

Get details of a specific tile set with all tile types

입력 스키마

{
  "type": "object",
  "properties": {
    "set": {
      "type": "string",
      "description": "Tile set ID or name"
    }
  },
  "required": [
    "set"
  ]
}
🟢tile_gallery_stats

Get statistics about available tile sets

입력 스키마

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

Get statistics about the board gallery (total boards, families, topologies)

입력 스키마

{
  "type": "object",
  "properties": {}
}
🟡piece_gallery_search(query, family, limit)

Search the piece set gallery by name, style, or game type

입력 스키마

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Search term (e.g. \"staunton\", \"pixel\", \"shogi\")"
    },
    "family": {
      "type": "string",
      "description": "Filter by game family (chess, shogi, xiangqi, draughts, go, etc)"
    },
    "limit": {
      "type": "number",
      "description": "Max results (default 10)"
    }
  },
  "required": [
    "query"
  ]
}
🟡piece_gallery_get_set(set)

Get full details and piece list for a specific set

입력 스키마

{
  "type": "object",
  "properties": {
    "set": {
      "type": "string",
      "description": "Set name or ID"
    }
  },
  "required": [
    "set"
  ]
}
🟢piece_gallery_stats

Get statistics about the piece gallery (total sets, styles, authors, game families)

입력 스키마

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

List all supported RPG systems with oracle tables and entity data availability

입력 스키마

{
  "type": "object",
  "properties": {}
}
⚪rpg_chargen(system, level, class)

Generate a random character for an RPG system (D&D 5e, Pathfinder, Ironsworn, Cairn, Knave, etc)

입력 스키마

{
  "type": "object",
  "properties": {
    "system": {
      "type": "string",
      "description": "RPG system (dnd-5e, pathfinder-1e, ironsworn, starforged, cairn, knave, maze-rats, dungeon-world)"
    },
    "level": {
      "type": "number",
      "description": "Character level (default: 1)"
    },
    "class": {
      "type": "string",
      "description": "Class preference (omit for random)"
    }
  },
  "required": [
    "system"
  ]
}
⚪oracle_roll(system, table)

Roll on a random oracle table (Ironsworn, Starforged, Maze Rats, etc)

입력 스키마

{
  "type": "object",
  "properties": {
    "system": {
      "type": "string",
      "description": "RPG system slug (ironsworn, starforged, maze-rats, cairn, knave, fate-core)"
    },
    "table": {
      "type": "string",
      "description": "Specific table name (omit for random)"
    }
  },
  "required": [
    "system"
  ]
}
🟢oracle_list_tables(system)

List available oracle tables for a system

입력 스키마

{
  "type": "object",
  "properties": {
    "system": {
      "type": "string",
      "description": "RPG system slug"
    }
  },
  "required": [
    "system"
  ]
}
⚪oracle_ask(question, likelihood)

Ask the oracle a yes/no question with likelihood modifier

입력 스키마

{
  "type": "object",
  "properties": {
    "question": {
      "type": "string",
      "description": "Yes/no question"
    },
    "likelihood": {
      "type": "string",
      "enum": [
        "certain",
        "likely",
        "even",
        "unlikely",
        "impossible"
      ],
      "description": "How likely is yes? (default: even)"
    }
  },
  "required": [
    "question"
  ]
}
⚪oracle_scene(system, recipe, region, type)

Generate a scene using oracle tables. With a recipe, rolls each table in the recipe, resolves cross-references, and composes a narrative sentence. Without, picks random tables.

입력 스키마

{
  "type": "object",
  "properties": {
    "system": {
      "type": "string",
      "description": "RPG system slug (default: ironsworn)"
    },
    "recipe": {
      "type": "string",
      "description": "Recipe ID (from oracle_list_recipes) — rolls each table in the recipe"
    },
    "region": {
      "type": "string",
      "enum": [
        "terminus",
        "outlands",
        "expanse"
      ],
      "description": "Region for Starforged region-aware recipes"
    },
    "type": {
      "type": "string",
      "enum": [
        "location",
        "npc",
        "event",
        "combat"
      ],
      "description": "Scene type for random mode (default: event)"
    }
  }
}
🟢rpg_search_entities(query, system, game, category, limit)

Search RPG entities (spells, monsters, classes, items) across all systems

입력 스키마

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Search term"
    },
    "system": {
      "type": "string",
      "description": "Limit to system (dnd-5e, pathfinder-1e, etc)"
    },
    "game": {
      "type": "string",
      "description": "Alias for system"
    },
    "category": {
      "type": "string",
      "description": "Entity category (spell, monster, class, item)"
    },
    "limit": {
      "type": "number",
      "description": "Max results (default 10)"
    }
  },
  "required": [
    "query"
  ]
}
🟢rpg_get_entity(name, system, game, category)

Get full details of a specific RPG entity by name

입력 스키마

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "Entity name"
    },
    "system": {
      "type": "string",
      "description": "System slug"
    },
    "game": {
      "type": "string",
      "description": "Alias for system"
    },
    "category": {
      "type": "string",
      "description": "Category filter (spells, monsters, classes, etc)"
    }
  },
  "required": [
    "name"
  ]
}
⚪rpg_random_encounter(system, difficulty, type)

Generate a random encounter for a system and difficulty level

입력 스키마

{
  "type": "object",
  "properties": {
    "system": {
      "type": "string",
      "description": "System slug (default: dnd-5e)"
    },
    "difficulty": {
      "type": "string",
      "enum": [
        "easy",
        "medium",
        "hard",
        "deadly"
      ],
      "description": "Encounter difficulty"
    },
    "type": {
      "type": "string",
      "description": "Monster type filter (beast, undead, fiend, dragon, etc)"
    }
  }
}
⚪rpg_browse_category(system, game, category, page, pageSize)

Browse entities by category with pagination

입력 스키마

{
  "type": "object",
  "properties": {
    "system": {
      "type": "string",
      "description": "System slug"
    },
    "game": {
      "type": "string",
      "description": "Alias for system"
    },
    "category": {
      "type": "string",
      "description": "Category (spell, monster, class, item, feat, etc)"
    },
    "page": {
      "type": "number",
      "description": "Page number (default 1)"
    },
    "pageSize": {
      "type": "number",
      "description": "Items per page (default 20)"
    }
  },
  "required": [
    "system",
    "category"
  ]
}
⚪rpg_loot(system, tier, count)

Generate random loot/treasure for a system and tier

입력 스키마

{
  "type": "object",
  "properties": {
    "system": {
      "type": "string",
      "description": "System slug (default: dnd-5e)"
    },
    "tier": {
      "type": "string",
      "enum": [
        "minor",
        "major",
        "legendary"
      ],
      "description": "Loot tier (default: minor)"
    },
    "count": {
      "type": "number",
      "description": "Number of items (default 3)"
    }
  }
}
🟢oracle_list_recipes(game)

List all predefined scene recipes — curated multi-table compositions that produce coherent narrative prompts

입력 스키마

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Filter by game system (omit for all)"
    }
  }
}
⚪oracle_interpret(result, source_table, game)

Resolve oracle cross-references. Given a result like "Action + Theme", follows references and returns expanded results

입력 스키마

{
  "type": "object",
  "properties": {
    "result": {
      "type": "string",
      "description": "Oracle result text to interpret"
    },
    "source_table": {
      "type": "string",
      "description": "Table ID the result came from"
    },
    "game": {
      "type": "string",
      "description": "Game system (default: starforged)"
    }
  },
  "required": [
    "result"
  ]
}
🟢oracle_table_view(table, game)

View the complete contents of an oracle table — all entries with roll ranges

입력 스키마

{
  "type": "object",
  "properties": {
    "table": {
      "type": "string",
      "description": "Table ID to view"
    },
    "game": {
      "type": "string",
      "description": "Game system (default: starforged)"
    }
  },
  "required": [
    "table"
  ]
}
⚪oracle_encounter(system, party_level, party_size, difficulty, monster_type, ...)

Generate a tabletop RPG encounter with CR-appropriate monsters, terrain, and loot (D&D 5e or Pathfinder 1e)

입력 스키마

{
  "type": "object",
  "properties": {
    "system": {
      "type": "string",
      "enum": [
        "dnd-5e",
        "pathfinder-1e"
      ],
      "description": "Game system (default: dnd-5e)"
    },
    "party_level": {
      "type": "number",
      "description": "Average party level 1-20 (default: 5)"
    },
    "party_size": {
      "type": "number",
      "description": "Number of players 1-10 (default: 4)"
    },
    "difficulty": {
      "type": "string",
      "enum": [
        "easy",
        "medium",
        "hard",
        "deadly"
      ],
      "description": "Encounter difficulty (default: medium)"
    },
    "monster_type": {
      "type": "string",
      "description": "Filter by type (undead, dragon, beast, etc)"
    },
    "terrain": {
      "type": "string",
      "description": "Terrain type (omit for random)"
    }
  }
}
🟢rpg_list_categories(game, system)

List entity categories for an RPG system (spells, monsters, classes, equipment, etc)

입력 스키마

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game system slug (omit for all systems)"
    },
    "system": {
      "type": "string",
      "description": "Alias for game"
    }
  }
}
🟢rpg_random(game, system, category, count)

Get random entities from an RPG system for inspiration or encounter prep

입력 스키마

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game system slug"
    },
    "system": {
      "type": "string",
      "description": "Alias for game"
    },
    "category": {
      "type": "string",
      "description": "Category to draw from (omit for any)"
    },
    "count": {
      "type": "number",
      "description": "Number of random picks 1-10 (default: 1)"
    }
  },
  "required": [
    "game"
  ]
}
⚪ti4_random_factions(players, expansions)

Generate random faction assignments for Twilight Imperium 4th Edition

입력 스키마

{
  "type": "object",
  "properties": {
    "players": {
      "type": "number",
      "description": "Number of players (3-8)"
    },
    "expansions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Expansion filter (e.g. [\"base\",\"pok\"]). Default: all"
    }
  },
  "required": [
    "players"
  ]
}
⚪ti4_draft_factions(players, choices, expansions)

Milty-style TI4 draft with pick pools per player

입력 스키마

{
  "type": "object",
  "properties": {
    "players": {
      "type": "number",
      "description": "Number of players (3-8, default: 6)"
    },
    "choices": {
      "type": "number",
      "description": "Factions per player to choose from (default: 3)"
    },
    "expansions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Expansion filter (e.g. [\"base\",\"pok\"]). Default: all"
    }
  }
}
🟢ti4_list_factions(expansions)

List all TI4 factions with colors, flags, and expansion info

입력 스키마

{
  "type": "object",
  "properties": {
    "expansions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Filter by expansion (e.g. [\"base\",\"pok\"]). Default: all"
    }
  }
}
⚪ti4_draw_objectives(stage, count, expansions)

Draw random public objectives for TI4

입력 스키마

{
  "type": "object",
  "properties": {
    "stage": {
      "type": "number",
      "enum": [
        1,
        2
      ],
      "description": "Stage 1 or 2 (default: both)"
    },
    "count": {
      "type": "number",
      "description": "Number to draw (default: 5)"
    },
    "expansions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Expansion filter"
    }
  }
}
⚪ti4_draw_agendas(count, type, expansions)

Draw random agenda cards for TI4 political phase

입력 스키마

{
  "type": "object",
  "properties": {
    "count": {
      "type": "number",
      "description": "Number to draw (default: 2)"
    },
    "type": {
      "type": "string",
      "enum": [
        "law",
        "directive"
      ],
      "description": "Filter by type"
    },
    "expansions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Expansion filter"
    }
  }
}
⚪nukes_setup_generator(players)

Generate random territory/resource setup for a Nukes game

입력 스키마

{
  "type": "object",
  "properties": {
    "players": {
      "type": "number",
      "description": "Number of players (2-6, default: 2)"
    }
  }
}
⚪game_nukes_combat(attacker, defender, terrain)

Resolve a Nukes combat encounter between units

입력 스키마

{
  "type": "object",
  "properties": {
    "attacker": {
      "type": "string",
      "description": "Attacking unit type"
    },
    "defender": {
      "type": "string",
      "description": "Defending unit type"
    },
    "terrain": {
      "type": "string",
      "description": "Terrain type (plains, forest, mountain, urban)"
    }
  },
  "required": [
    "attacker",
    "defender"
  ]
}
🟢colony_dice_odds(numbers)

Calculate settlement dice probability for Colony/Catan-style resource numbers

입력 스키마

{
  "type": "object",
  "properties": {
    "numbers": {
      "type": "string",
      "description": "Settlement numbers, comma-separated (e.g. \"5,6,8,9\")"
    }
  },
  "required": [
    "numbers"
  ]
}
🟡game_deck_create(type, draw, hands, per_hand)

Create, shuffle, and optionally draw/deal from a card deck

입력 스키마

{
  "type": "object",
  "properties": {
    "type": {
      "type": "string",
      "enum": [
        "standard-52",
        "bavarian-32",
        "hanafuda-48",
        "mahjong-136",
        "dominoes-28",
        "standard-dice"
      ],
      "description": "Deck type (default: standard-52)"
    },
    "draw": {
      "type": "number",
      "description": "Number of cards to draw"
    },
    "hands": {
      "type": "number",
      "description": "Deal into N hands"
    },
    "per_hand": {
      "type": "number",
      "description": "Cards per hand (default: 5)"
    }
  }
}
🟢game_deck_list_types

List all available deck types with metadata

입력 스키마

{
  "type": "object",
  "properties": {}
}
⚪game_deck_deal(cards, hands, per_hand, draw)

Shuffle and deal a custom deck of arbitrary named cards

입력 스키마

{
  "type": "object",
  "properties": {
    "cards": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string"
          },
          "quantity": {
            "type": "number",
            "default": 1
          }
        },
        "required": [
          "name"
        ]
      },
      "description": "Cards in the deck (name + optional quantity)"
    },
    "hands": {
      "type": "number",
      "description": "Deal into N hands (default: 1 = draw pile only)"
    },
    "per_hand": {
      "type": "number",
      "description": "Cards per hand (default: 5)"
    },
    "draw": {
      "type": "number",
      "description": "Draw N cards from the top instead of dealing hands"
    }
  },
  "required": [
    "cards"
  ]
}
⚪game_score_tracker(players, scores, game)

Track scores for players in any game

입력 스키마

{
  "type": "object",
  "properties": {
    "players": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Player names"
    },
    "scores": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "description": "Scores (default: all 0)"
    },
    "game": {
      "type": "string",
      "description": "Game name"
    }
  },
  "required": [
    "players"
  ]
}
🟡talisman_draw_characters(count)

Draw random characters from the Talisman 4e (revised) base set for a character lottery

입력 스키마

{
  "type": "object",
  "properties": {
    "count": {
      "type": "number",
      "description": "Number of characters to draw (2-6, default: 4)"
    }
  }
}
⚪talisman_draw_encounter(ring)

Draw a random encounter for a Talisman ring (outer, middle, inner, crown)

입력 스키마

{
  "type": "object",
  "properties": {
    "ring": {
      "type": "string",
      "enum": [
        "outer",
        "middle",
        "inner",
        "crown"
      ],
      "description": "Ring to draw from (default: outer)"
    }
  }
}
🟢jam_status

Get the current Mod Jam status (active jam, deadline, submissions)

입력 스키마

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

Get time remaining in the current Mod Jam

입력 스키마

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

Get voting status for the current Mod Jam

입력 스키마

{
  "type": "object",
  "properties": {}
}
⚪dice_roll(notation, expression, count)

Roll dice using standard notation (e.g. 2d6+3, 4d8, d20). Supports comma-separated pools and keep-high/low (4d6kh3).

입력 스키마

{
  "type": "object",
  "properties": {
    "notation": {
      "type": "string",
      "description": "Dice notation (e.g. 2d6+3, 4d6kh3, 3d8,1d12+2)"
    },
    "expression": {
      "type": "string",
      "description": "Alias for notation"
    },
    "count": {
      "type": "number",
      "description": "Number of times to roll (default 1)"
    }
  }
}
🟢coin_flip(count, choices)

Flip one or more coins, or pick from a list of choices

입력 스키마

{
  "type": "object",
  "properties": {
    "count": {
      "type": "number",
      "description": "Number of coins (default 1)"
    },
    "choices": {
      "type": "string",
      "description": "Comma-separated options to pick from (overrides coin flip)"
    }
  }
}
⚪team_split(players, members, count, teams)

Randomly divide players into teams

입력 스키마

{
  "type": "object",
  "properties": {
    "players": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Player names"
    },
    "members": {
      "type": "string",
      "description": "Comma-separated names (alternative to array)"
    },
    "count": {
      "type": "number",
      "description": "Number of teams (default 2)"
    },
    "teams": {
      "type": "number",
      "description": "Alias for count"
    }
  },
  "required": [
    "players"
  ]
}
🟢random_player_order(players)

Randomise turn order for a list of players

입력 스키마

{
  "type": "object",
  "properties": {
    "players": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Player names"
    }
  },
  "required": [
    "players"
  ]
}
🟢timer_suggest(game, players)

Suggest time controls for a game based on player count and complexity

입력 스키마

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game name"
    },
    "players": {
      "type": "number",
      "description": "Number of players"
    }
  },
  "required": [
    "game"
  ]
}
⚪game_jam_theme(count)

Generate a random game jam theme combining mechanics and themes

입력 스키마

{
  "type": "object",
  "properties": {
    "count": {
      "type": "number",
      "description": "Number of themes to generate (default 3)"
    }
  }
}
🟢dice_odds(expression, target, comparison)

Calculate probability of meeting a target with a dice expression. Supports keep-high/low (4d6kh3).

입력 스키마

{
  "type": "object",
  "properties": {
    "expression": {
      "type": "string",
      "description": "Dice expression (e.g. 2d6, 4d6kh3)"
    },
    "target": {
      "type": "number",
      "description": "Target number to meet or exceed"
    },
    "comparison": {
      "type": "string",
      "enum": [
        ">=",
        ">",
        "<=",
        "<",
        "="
      ],
      "description": "Comparison (default >=)"
    }
  },
  "required": [
    "expression",
    "target"
  ]
}

커뮤니티

이 서버 평가하기

증거

최근 관측

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