Skip to main content
Glama

lcu-mcp

M8ven Score npm version License: MIT Node CI

An MCP server that exposes a running League of Legends client to any MCP host — the LCU REST API, live WAMP events & recording, client DOM and CDP console, and OpenAPI schema introspection over stdio.

Ask your assistant what queue you are in, watch champ select unfold event by event, inspect the client's DOM, or drive the client itself — without writing a line of glue code.

Contents

Related MCP server: Liquipedia MCP

How it works

Two independent subsystems run inside one Node process:

  • LcuClient reads the client's lockfile to discover the port and password, then talks REST over HTTPS with Riot's root CA pinned, and holds a WebSocket tap on OnJsonApiEvent that feeds an in-process ring buffer.

  • CdpClient attaches to the client's Chrome DevTools Protocol endpoint (exposed by Pengu Loader) for DOM queries and JavaScript evaluation.

Both connect lazily and survive client restarts — the lockfile port changes on every launch, so the directory is watched rather than the file. Events are polled rather than pushed, because MCP has no server-to-client push.

Requirements

Node.js

>= 24 (ESM, no build step)

League of Legends

Running. The lockfile at C:\Riot Games\League of Legends\lockfile supplies the port and password.

Pengu Loader

Optional — required only for lol_dom_query and lol_eval. Everything else works without it.

Windows only in practice: the default lockfile path and the Pengu integration are Windows-specific.

Installation

Via npx (Recommended, zero install)

Run directly with npx:

npx -y lcu-mcp

From source

git clone https://github.com/Triggered0/lcu-mcp.git
cd lcu-mcp
npm install

Runtime dependencies are exactly three: @modelcontextprotocol/sdk, zod, and ws.

Registering with an MCP host

Claude Code

# Recommended: via npx
claude mcp add lcu --scope user -- npx -y lcu-mcp

# Or from a local clone:
claude mcp add lcu --scope user -- node C:\path\to\lcu-mcp\src\index.js

Any host that reads .mcp.json

{
  "mcpServers": {
    "lcu": {
      "command": "npx",
      "args": ["-y", "lcu-mcp"]
    }
  }
}

Or from a local repository clone:

{
  "mcpServers": {
    "lcu": {
      "command": "node",
      "args": ["C:\\path\\to\\lcu-mcp\\src\\index.js"],
      "env": { "LCU_MCP_CONFIG": "C:\\path\\to\\lcu-mcp\\config\\allowlist.json" }
    }
  }
}

LCU_MCP_CONFIG is optional; without it the server looks for config/allowlist.json relative to its working directory, and falls back to built-in defaults if that file does not exist.

Quick start

Start the League client, then ask your assistant in plain language. A few things that work with no further setup:

Ask

What runs

"Is the LCU connection healthy?"

lol_status

"Who am I logged in as?"

lol_get("/lol-summoner/v1/current-summoner")

"What am I doing in the client right now?"

lol_get("/lol-gameflow/v1/gameflow-phase")

"Which champion is id 157?"

lol_static(kind="champions", ids=[157])

"Watch champ select and tell me what happens."

lol_events_start(["/lol-champ-select/"]), then lol_events_poll

"What does the lobby endpoint accept?"

lol_schema("/lol-lobby/v2/lobby")

"Accept the ready check."

lol_request("POST", "/lol-matchmaking/v1/ready-check/accept") — needs a write allowlist entry

"Screenshot the client."

lol_cdp_screenshot — needs Pengu Loader

"What is my ranked winrate and recent roles?"

lol_analytics_player

"Summarize my last 5 matches concisely."

lol_analytics_match_history(count=5)

"Analyze damage and objectives in my last game."

lol_analytics_match_detail

"What is our team damage mix in champ select?"

lol_analytics_champ_select_scout

"Set my summoner spells to Flash and Ignite."

lol_workflow_spells_set(spell1="flash", spell2="ignite")

"Swap champion with ARAM bench."

lol_workflow_champ_select_bench(champion="AramBenchChamp")

"How much essence do my loot shards yield?"

lol_analytics_loot_summary

Nothing here needs a Riot API key or an internet connection: every call goes to 127.0.0.1.

Tools

Tool

Purpose

lol_status

Per-subsystem health, resolved LCU port, configured CDP port, whether allowEval is on

lol_get(path)

GET any LCU path

lol_request(method, path, body?)

Any verb, subject to the write allowlist

lol_endpoints(filter?)

List the curated endpoint table

lol_static(kind, ids?, query?, fields?, limit?, offset?, refresh?)

Resolve champion/item/perk/spell/map/queue ids to names from the client's local game data

lol_events_start(filters?)

Open the WebSocket tap and begin buffering

lol_events_poll(since?, limit?, filter?)

Drain the ring buffer

lol_events_stop()

Close the tap

lol_dom_query(selector, all?, props?)

Query the client DOM

lol_eval(expression, awaitPromise?)

Evaluate JavaScript in the page

lol_wamp_record_start(uris?, restart?)

Record LCU WAMP traffic on an independent socket

lol_wamp_record_dump(uri?, since?, until?, kinds?, limit?, cursor?)

Dump the recorded timeline and per-URI stats

lol_wamp_record_stop()

Close the recorder socket

lol_cdp_console_start()

Begin buffering client console output

lol_cdp_console_tail(since?, until?, cursor?, limit?, level?, targetId?, text?)

Read buffered console entries

lol_cdp_console_stop()

Stop and discard the console buffer

lol_cdp_network_start()

Begin buffering the HTTP requests the client UI makes

lol_cdp_network_tail(since?, until?, cursor?, limit?, urlContains?, method?, status?, minStatus?, type?, failedOnly?, targetId?)

Read buffered requests

lol_cdp_network_body(requestId)

Fetch one response body from the live renderer

lol_cdp_network_summary(since?, until?, urlContains?, method?)

Aggregate requests by method and url

lol_cdp_network_stop()

Stop and discard the request buffer

lol_logs_tail(target?, lines?, session?, level?, search?)

Tail the most recent lines of a client, UX, or game log

lol_logs_watch_start(target?)

Begin streaming newly appended log lines into a ring buffer

lol_logs_watch_poll(cursor?, limit?, level?, search?)

Poll newly streamed log entries

lol_logs_watch_stop()

Stop and discard the log watcher buffer

lol_logs_sessions(target?, limit?)

List active and historical log files on disk

lol_game_all(format?)

Fetch full real-time live game state from in-match game engine (summary or raw)

lol_game_stats()

Check match status, game clock, mode, and map terrain from the live game engine

lol_game_player(name?)

Fetch real-time stats, abilities, items, and runes for the active or named player

lol_game_events(afterId?)

Retrieve in-game events (kills, objectives, aces) with incremental cursor support

lol_restart_ux(waitForReady?, timeoutSeconds?)

Safely restart client CEF renderers with readiness polling

lol_launch_client(executablePath?, pollIntervalMs?, timeoutSeconds?)

Launch Riot Client / League of Legends client and wait for LCU readiness

lol_cdp_targets()

List all active CDP debugging targets (pages, popups, workers)

lol_cdp_screenshot(targetId?, format?, quality?, savePath?)

Capture client screenshot via CDP (returns MCP image + disk save)

lol_cdp_performance()

CEF performance metrics, JS heap memory usage, DOM node counts, and leak warnings

lol_cdp_dom_tree(includeOverlaysOnly?, maxDepth?)

Inspect UI modal hierarchy, viewport routes, and click-blocking transparent overlays

lol_cdp_storage(storageType?, filter?, limit?, parseJson?)

Inspect localStorage/sessionStorage keys and feature flags with credential redaction

lol_cdp_network_bottlenecks(thresholdMs?, limit?, includeInitiators?)

Identify slow requests, P50/P90/P99 endpoint latencies, and failed assets

lol_forensics_anomaly_detect(windowSeconds?, severityFilter?)

Scan across all streams for crash signatures, HTTP error clusters, and console bursts

lol_forensics_export_har(limit?, savePath?)

Export captured HTTP network traffic to standard HAR 1.2 archive with redaction

lol_schema(path?, method?, model?, refresh?)

Query internal LCU OpenAPI/Swagger v2 schemas and models

lol_forensics_correlate(since?, until?, limit?, sources?, uriPrefix?, levels?, networkFailedOnly?, logLevel?, format?)

Correlate telemetry across all 5 streams (WAMP, CDP console, CDP network, disk logs, live game) on a shared time axis

lol_forensics_bundle(since?, until?, limit?, sources?, includeLogTail?, format?)

Generate an end-to-end diagnostic snapshot combining system status, active timeline streams, and disk log fallbacks

lol_workflow_matchmaking_accept()

Accept matchmaking ready check if active and unaccepted

lol_workflow_champ_select(champion, type?, completed?)

Pick, hover, or ban champion by name or numeric ID in active champion select

lol_workflow_champ_select_bench(champion)

Swap champion with available ARAM bench champion by name or ID

lol_workflow_spells_set(spell1, spell2?)

Set summoner spells (Flash, Ignite, Smite, Teleport, etc.) by name or ID in champion select

lol_workflow_runes_set(primaryStyleId, subStyleId, selectedPerkIds, name?, replace?)

Configure, update, and activate a rune/perk page

lol_workflow_lobby(queueId, startMatchmaking?)

Create game lobby for a queue (e.g. 420 Ranked Solo, 450 ARAM) and optionally start matchmaking

lol_workflow_lobby_invite(toSummonerPuuids)

Invite players to current lobby party by summoner PUUIDs

lol_workflow_play_again()

Recreate game lobby from post-game End of Game screen

lol_workflow_honor(target, honorCategory?)

Vote for teammate on post-game honor ballot ("COOL", "SHOTCALLER", "HEART")

lol_analytics_player(summonerName?, puuid?)

Aggregate player identity, ranked tiers, recent winrates, and role breakdown

lol_analytics_match_history(summonerName?, puuid?, count?)

Token-efficient compact match history rows

lol_analytics_match_detail(gameId?)

Deep post-game breakdown (objectives, damage share, gold, KDA, team stats)

lol_analytics_champ_select_scout()

Champ select composition scout (ally/enemy roles, champions, AP/AD damage mix)

lol_analytics_live_combat()

Real-time live in-game combat telemetry, lane differentials, objective clock

lol_analytics_loot_summary()

Calculate total Blue and Orange Essence yields from champion and skin shards

lol_workflow_loot_disenchant(lootId, count?)

Disenchant champion or skin shards for essence

lol_chat_send(message, conversationId?)

Send chat message into active champion select, lobby, or chat

lol_chat_status(availability?, statusMessage?)

Update summoner presence status message and availability

lol_status first. When anything else fails it tells you which half is down — a closed client looks nothing like a missing Pengu install.

Ids come back raw. Champ select, the gameflow, and match history all speak in numbers — championId: 157, perk: 8008, queueId: 420. lol_static resolves them to Yasuo, Lethal Tempo, and Ranked Solo/Duo from documents the client already serves locally, so no Data Dragon, no API key, and no call leaves 127.0.0.1. It projects to {id, name} and pages at 50 entries by default — items alone is 868 entries and 667 KB raw — so widen it deliberately with fields, limit, and offset.

Events are polled. lol_events_poll returns a cursor; pass it back as since next time. A non-zero dropped means the ring buffer wrapped and that many events were lost after your cursor. Entries with truncated: true had their data clipped at 4 KB — re-fetch the full body with lol_get on the entry's uri.

The client only emits when state changes. Sitting idle on the home screen it can stay silent indefinitely; navigating the UI or entering a lobby produces bursts. An empty poll usually means nothing happened, not that the tap is broken — check running and lol_status to tell the two apart.

Diagnosing a missing event. lol_wamp_record_* runs on its own WAMP socket outside the client renderer, so it proves what the LCU actually emitted and when. Read it together with lol_cdp_console_tail and a lol_eval probe to separate three cases: the LCU never emitted, it emitted but the page never received, or the page received and mishandled. Start both recorders before the thing you want to observe — they only hold what arrived after they started.

Three views, one story. lol_wamp_record_* shows what the LCU pushed, lol_cdp_console_* shows what the page said, and lol_cdp_network_* shows what the page asked for. Each entry names the code that issued the request, so "why did the client call this" has an answer rather than a guess. A 404 arrives as an ordinary response, not a transport failure — reach for minStatus: 400 when you want everything that went wrong, and failedOnly only for connections that never completed. Response bodies are fetched on demand with lol_cdp_network_body, not buffered.

Disk logs for historical and game-engine forensics. lol_logs_tail and lol_logs_sessions inspect LeagueClient.log, LeagueClientUx.log, and GameLogs (r3dlog.txt) directly on disk without requiring an active WebSocket or Pengu debugger. For live monitoring across client actions, lol_logs_watch_start streams newly appended lines from EOF into a dedicated ring buffer. All lines undergo ingest-time credential scrubbing and Riot auth token redaction.

In-match game engine telemetry (lol_game_*). When League enters a live match (loading screen, Summoner's Rift, ARAM, Practice Tool, or TFT), the game engine hosts an internal HTTPS server on 127.0.0.1:2999/liveclientdata. lol_game_all provides a complete, token-efficient projection of match clock, team comparisons, scores, items, and vital stats (or full raw JSON via format: 'raw'). lol_game_events tracks combat and objective kills incrementally using afterId. If no match is currently running, tools report a clear indication rather than connection failures.

Unified multi-stream forensics & diagnostic snapshot (lol_forensics_*). Complex client bugs often span multiple architectural layers — for example, a champion select lock-in failure might involve an LCU REST 400 error, a frontend exception in CEF, an unfulfilled WAMP gameflow state change, and a diagnostic log entry in LeagueClient.log.

  • lol_forensics_correlate merges events chronologically onto a unified time axis from all 5 telemetry streams:

    • wamp: LCU WebSocket events emitted by backend microservices.

    • cdp: Frontend console logs, warnings, errors, and unhandled page exceptions.

    • network: CEF HTTP requests and responses, status codes, round-trip durations, and network dropouts.

    • logs: Live disk log lines streamed from LeagueClient.log or LeagueClientUx.log.

    • game: In-match combat, objective, and gameflow events from the live game engine.

    Supported parameters:

    • sources: Restrict correlation to specific streams (wamp, cdp, network, logs, game).

    • since & until: Timestamp filtering bounds in epoch ms or relative clock ts.

    • limit: Maximum total events returned across streams (default 100, max 1000).

    • uriPrefix: Filter WAMP events by URI prefix (e.g. /lol-champ-select/).

    • levels: Filter CDP console entries by level (['error', 'warning', 'info', 'log', 'debug']).

    • networkFailedOnly: Filter CDP network requests to only failed or aborted connections.

    • logLevel: Filter live disk log entries by log level (e.g. ERROR, WARN, INFO).

    • format: Output format: 'narrative' (default chronological human/LLM-readable log), 'events' (interleaved JSON array), or 'summary' (aggregated event and error metrics).

  • lol_forensics_bundle is a one-stop diagnostic snapshot tool for triaging client issues, generating bug reports, or feeding a comprehensive post-mortem to an LLM:

    • Inspects real-time system status across LCU REST, CEF remote debugging, live game engine, and all 4 background stream watchers.

    • Compiles telemetry metrics and error tallies.

    • Generates the chronological multi-stream timeline narrative.

    • Automatically falls back to reading the last 50 lines of LeagueClient.log from disk when the live log watcher is unstarted or empty (includeLogTail: true), guaranteeing diagnostic context even when recorders were not pre-armed.

    • Sanitizes all lockfile passwords, Riot authentication tokens, and session credentials using deep secret redaction.

    • Supported parameters: since, until, limit (default 200, max 2000), sources (stream filtering), includeLogTail (fallback to disk log tail, default true), and format ('markdown' for a ready-to-paste triage report or 'json' for structured tooling).

  • lol_forensics_anomaly_detect: Scans across all active background streams (wamp, cdp, network, logs) for crash signatures, HTTP 5xx error bursts, and frontend exception spikes, returning an overall health verdict (HEALTHY, DEGRADED, CRITICAL), root-cause hypotheses, and anomaly timestamps. Supports windowSeconds and severityFilter (CRITICAL, DEGRADED, ALL).

  • lol_forensics_export_har: Exports captured HTTP/HTTPS network traffic from the active network tailer into a standard HAR 1.2 archive. Automatically redacts sensitive authorization headers, bearer tokens, and session cookies. Can return the HAR JSON structure directly or save it to disk via savePath.

Deep CEF diagnostics & UI inspection. When diagnosing client frontend lag, memory leaks, unclickable buttons, or client UI state:

  • lol_cdp_performance: Queries CEF DevTools performance metrics. Normalizes JS heap memory (jsHeapUsedMb, jsHeapTotalMb), utilization ratios, DOM node counts, and style recalculation counts, raising warnings when memory pressure thresholds are breached (>250MB heap or >15,000 DOM nodes).

  • lol_cdp_network_bottlenecks: Analyzes buffered network traffic to rank slowest HTTP calls, calculate P50, P90, and P99 latencies per normalized endpoint pattern (e.g. /lol-champ-select/v1/session), group failed asset loads (image 404s, failed script plugins), and correlate initiator script stack traces.

  • lol_cdp_dom_tree: Analyzes the client's live DOM modal stack, visible viewports/plugins (rcp-fe-lol-*), and identifies invisible/transparent full-screen backdrop overlays (opacity: 0 with active pointer events) that frequently cause "frozen UI" states or unclickable buttons.

  • lol_cdp_storage: Inspects client localStorage and sessionStorage in the CEF context. Features case-insensitive substring key/value filtering, structured JSON parsing, and automatic multi-tier redaction of Riot auth tokens, session passwords, and sensitive cookies.

Workflow macro automation (lol_workflow_*). High-level client automation needs multi-step orchestration across REST endpoints, active session discovery, and static data catalogs. Instead of 4–8 separate round-trip tool calls with manual state inspection, each macro inspects its preconditions and then issues the one mutation that follows from them. Rollback is limited to what a call created itself — lol_workflow_lobby closes a lobby it opened if the matchmaking search then fails — and otherwise a macro that fails part-way leaves the client where it got to. Either way the error names the failing call and the state the client is left in.

Macros mutate the client, so every write they send goes through the write allowlist, exactly like lol_request. The shipped config/allowlist.json permits all of them; delete a line to disable the corresponding macro, and the refusal will name the line that would re-enable it.

  • lol_workflow_matchmaking_accept: One-call match acceptance. Verifies that a matchmaking ready check is actively in progress ('InProgress') before posting acceptance. Idempotent if already accepted (playerResponse: 'Accepted'); returns state without throwing when no check is in progress. A closed client is reported as an error, not as "no ready check".

  • lol_workflow_champ_select: Pick, hover, or ban champions in active champion select. Resolves champions by human-friendly name (e.g. "Aatrox", "Yasuo") or numeric ID via local static game data, identifies the local player's active action cell, and executes a hover (completed: false) or lock-in (completed: true, default). An exact name wins; a partial name that matches more than one champion is refused with the candidates listed, because a lock-in cannot be undone. Safely detects if champion select is inactive or if no eligible action is currently pending for the player.

  • lol_workflow_champ_select_bench: Swap active champion with an available champion on the ARAM bench by name or ID. Safely resolves bench champions, checks session state, and swaps without obsolete reroll mechanics.

  • lol_workflow_spells_set: Set summoner spells in active champion select by name (e.g. "flash", "ignite", "smite", "teleport") or numeric ID. Updates spell1 and optionally spell2 simultaneously.

  • lol_workflow_runes_set: Set, replace, and activate rune pages. With replace: true (default) it reuses an editable page whose name matches name and overwrites it; otherwise it creates a new editable page. It never overwrites a page the user named something else. Accepts primary and secondary style IDs along with an array of perk IDs, ensuring the resulting page is immediately activated.

  • lol_workflow_lobby: Create game lobbies and optionally trigger queue search. Sets up custom or matchmade lobbies by queue ID (e.g. 420 for Ranked Solo/Duo, 440 for Ranked Flex, 450 for ARAM). A no-op if the client is already in the requested queue; if it is in a lobby on a different queue, that lobby is replaced. Optionally dispatches matchmaking search (startMatchmaking: true) within the same operation. If that search fails and the call had created the lobby from nothing, the lobby is closed again; if it had replaced an existing lobby, the new one is kept, because the old party cannot be restored and no lobby at all is the worse outcome.

  • lol_workflow_lobby_invite: Dispatch invitations to summoner PUUIDs to join the current party lobby.

  • lol_workflow_play_again: Recreate previous game lobby from the End of Game or post-match screen with party settings preserved.

  • lol_workflow_honor: Submit an honor vote for an eligible teammate on the post-game honor ballot by name or summonerId with badge category ("COOL", "SHOTCALLER", "HEART").

Player & Match Analytics (lol_analytics_*). Read-only, token-efficient performance scouting and post-match telemetry:

  • lol_analytics_player: Aggregates summoner identity, ranked tiers and LP (Solo/Duo, Flex, Arena), win rates, and recent match role tendencies in a single compact JSON summary.

  • lol_analytics_match_history: Returns compact, token-efficient match rows (champion name, outcome, KDA, CS, duration, queue, timestamp) without bloating host LLM context windows.

  • lol_analytics_match_detail: Deep post-game breakdown analyzing baron/dragon/herald/tower objectives, individual damage shares, gold earned, and combat metrics for any historical match.

  • lol_analytics_champ_select_scout: Evaluates active champion select draft composition, assessing allied and enemy champion picks, assigned roles, bans, and team magic vs. physical (AP vs. AD) damage distribution.

  • lol_analytics_live_combat: Connects to the in-match game engine (127.0.0.1:2999) to calculate real-time combat telemetry: current gold and CS differentials vs lane opponents, team gold leads, KDA pacing, and live match clock.

Loot Economy & Crafting (lol_analytics_loot_summary, lol_workflow_loot_disenchant).

  • lol_analytics_loot_summary: Scans player inventory and tallies Blue Essence yield from champion shards and Orange Essence yield from skin, ward, and emote shards.

  • lol_workflow_loot_disenchant: Disenchants a specified number of shards for a given loot ID via the client crafting recipe endpoint. Subject to write allowlist.

In-Client Chat & Status (lol_chat_*).

  • lol_chat_send: Dispatches chat messages directly into active champion select, lobby, or custom conversation channels without requiring manual conversation discovery.

  • lol_chat_status: Updates player chat availability (chat, away, dnd, mobile) and custom status message strings visible to friends.

Filters are URI prefixes applied at ingest. The unfiltered firehose fills the buffer quickly, so pass something like ["/lol-champ-select/", "/lol-gameflow/"] unless you genuinely want everything.

Configuration

config/allowlist.json:

{
  "allowEval": true,
  "cdpPort": 8888,
  "eventBufferSize": 1000,
  "writeAllowlist": [
    "POST /lol-matchmaking/v1/ready-check/accept",
    "PATCH /lol-champ-select/v1/session/actions/*"
  ]
}

The shipped file also carries the remaining lines the lol_workflow_* macros need — POST /lol-lobby/v2/lobby, POST /lol-lobby/v2/lobby/matchmaking/search, POST /lol-perks/v1/pages and PUT /lol-perks/v1/pages/* — plus DELETE /lol-lobby/v2/lobby, which lol_workflow_lobby uses only to close a lobby it just opened. Drop that line and the macro still works; it simply reports the lobby it could not clean up.

Key

Default

Meaning

allowEval

true

Whether lol_eval may run JavaScript in the page

cdpPort

8888

Pengu Loader's remote debugging port

eventBufferSize

1000

Ring buffer capacity; oldest entries are evicted first

writeAllowlist

[]

Which mutating requests lol_request and the lol_workflow_* macros may send

wampRecordBufferSize

20000

Recorder timeline entry count

wampRecordMaxBytes

67108864

Recorder byte budget; evicts on whichever fills first

wampRecordPayloadCap

512

Per-payload truncation for the recorder

wampRecordFullPayloadUris

["/lol-gameflow/v1/gameflow-phase"]

URI prefixes exempt from the payload cap

wampRecordFile

null

Optional NDJSON path the timeline is appended to

cdpConsoleBufferSize

5000

Console tailer entry count

cdpNetworkBufferSize

5000

Network tailer entry count; about 50 minutes at the client's measured request rate

logWatchBufferSize

5000

Disk log watcher ring buffer capacity

logsDir

null

Optional custom logs directory override (defaults to auto-detected Logs/)

liveGamePort

2999

Live Client Data API port hosted by the League of Legends game engine

Allowlist matching rules:

  • An entry is METHOD path. The method is compared case-insensitively, the path case-sensitively.

  • GET and HEAD are always allowed and need no entry.

  • * matches a single path segment without crossing /: /a/b/* matches /a/b/c (e.g. PATCH /lol-champ-select/v1/session/actions/*), and infix /a/*/c matches /a/b/c (e.g. POST /lol-loot/v1/recipes/*/craft and POST /lol-chat/v1/conversations/*/messages), but does not match across multiple / delimiters.

  • A refused call returns the exact config line that would permit it, and the request is never sent.

Enabling DOM access

lol_dom_query and lol_eval need the client's CEF remote debugging port, which Riot's build only opens through Pengu Loader — an externally added --remote-debugging-port flag is ignored.

Pengu's config is plain key=value text, one pair per line — not JSON, not INI. In C:\Program Files\Pengu Loader\config, set:

RemoteDebuggingPort=8888

Then restart the client UX so CEF picks the port up:

POST /riotclient/kill-and-restart-ux

This leaves a live game untouched. Until it happens, both tools fail with these exact instructions rather than a bare ECONNREFUSED.

Security

  • TLS verification stays on. The LCU's self-signed certificate is validated against Riot's root CA, vendored at certs/riotgames.pem. The server never sets rejectUnauthorized: false.

  • The password never leaves the process. It is held only to build the Authorization header — no tool returns it, nothing logs it, and error text is scrubbed of it before it reaches the host. CDP target URLs embed it too, so they are redacted before any tool returns them.

  • lol_eval bypasses the write allowlist by construction. The client page can fetch any LCU endpoint from its own origin, so evaluated JavaScript can do anything the client can. This is accepted, not fixed: it is gated by the allowEval flag, whose state lol_status reports.

Treat the write allowlist as a guardrail against mistakes, not as a security boundary — while allowEval is true it can be bypassed. Set allowEval to false for a real boundary. lol_dom_query keeps working, because it injects the selector as data rather than as code.

Development

npm test        # unit tests via node:test — no League client needed
npm run smoke   # live end-to-end check against a running client
npm start       # run the server on stdio

npm run smoke prints one line per stage and exits 1 if any stage fails. It is never run in CI. The event stage waits for real delivery and reports three outcomes: PASS when events arrived, SKIP when the tap connected but an idle client sent nothing, and FAIL when the tap could not connect.

bin/lcu-mcp.js      # npx entry point
certs/              # Riot's root CA, pinned for TLS verification
config/             # default allowlist.json
scripts/            # lint.mjs (syntax gate) and smoke.mjs (live check)
src/
  index.js          # stdio transport, context wiring, tool registration
  config.js         # config loading and validation
  allowlist.js      # pure write-allowlist matching
  redact.js         # strip passwords from URLs and strings
  backoff.js        # shared reconnect schedule
  clock.js          # injectable time source, so tests never sleep
  lcu/
    lockfile.js     # parse, read, and watch the lockfile
    client.js       # REST with the pinned CA
    buffer.js       # ring buffer with cursor and drop accounting
    ingest.js       # pure ingest policy: prefix filters, truncation
    events.js       # WebSocket tap with backoff reconnect
    recorder.js     # independent WAMP socket for forensic recording
    ndjson.js       # append recorded frames to disk
    timeline.js     # query, filter, and page a recorded timeline
    schema.js       # fetch and dereference the OpenAPI document
    static.js       # lazy per-kind cache over the local game data documents
  cdp/
    discover.js     # probe the debugging port, pick and redact the target
    client.js       # attach, evaluate, DOM query
    console.js      # buffered console tailer on its own socket
    network.js      # buffered HTTP request tailer on its own socket
  logs/
    parser.js       # parse log lines and redact credentials/tokens
    sessions.js     # locate League log folders and active/past sessions
    reader.js       # backward chunk reader from EOF
    watcher.js      # live tailing and timeline buffering
  game/
    client.js       # HTTPS client to in-match engine on port 2999
    summary.js      # token-efficient projection of allgamedata
  forensics/
    correlate.js    # merge all 5 telemetry streams onto a unified time axis
    bundle.js       # one-stop diagnostic snapshot across all subsystems
  workflow/
    matchmaking.js  # ready check accept and status inspection
    champ_select.js # champion resolution, action detection, lock-in/hover
    runes.js        # rune page mutation, creation, and activation
    lobby.js        # lobby creation and queue search dispatch
  tools/            # one module per tool group
tests/              # one test file per source module

Contributing

Pull requests are welcome. The house rules are short: write the test first, keep the runtime dependency list at three, and never let a password reach a buffer, a log, or a tool return. npm run lint && npm test must be clean before you open the PR — see CONTRIBUTING.md for the full workflow.

Found a security issue? Please do not open a public issue — use private vulnerability reporting instead, as described in SECURITY.md.

Troubleshooting

Symptom

Cause

League client is not running: no lockfile at ...

The client is closed, or installed somewhere other than the default path.

Every CDP tool fails with a Pengu hint

Pengu Loader is not active, or RemoteDebuggingPort is unset. Follow Enabling DOM access.

no "page" target

CDP is reachable but the UX is still starting. Retry once the client is visible.

lol_events_poll returns nothing

Usually an idle client, not a fault. Navigate the UI and poll again; check running in the response.

A write is refused

The verb and path are not on the allowlist. The error message contains the exact line to add.

TLS errors on every REST call

The vendored CA is wrong or stale. Fix the PEM — never disable verification.

Privacy

lcu-mcp runs locally, talks only to 127.0.0.1, and collects nothing. What it reads from the client flows to the MCP host you connected — see PRIVACY.md.

Disclaimer

lcu-mcp is not endorsed by Riot Games and does not reflect the views or opinions of Riot Games or anyone officially involved in producing or managing Riot Games properties. Riot Games and all associated properties are trademarks or registered trademarks of Riot Games, Inc.

This project uses the client's own local API. You are responsible for how you use it; automating gameplay may violate Riot's Terms of Service.

License

MIT © Triggered

Available Tools

61 tools
lol_analytics_champ_select_scoutScout champion select composition and damage mixA
Read-onlyIdempotent

Scouts active allied team draft in champion select, evaluating physical vs magic damage distribution and detecting composition gaps (e.g. missing frontline, full AD/AP vulnerability). Use this tool during champion select draft to advise on optimal pick choices or role balance before locking in. For locking in, hovering, or banning champions, use lol_workflow_champ_select instead. For setting runes or summoner spells, use lol_workflow_runes_set or lol_workflow_spells_set. Behavior: Safe and read-only; returns cleanly with inChampSelect: false if champion select is inactive. Returns allied draft breakdown and composition warnings.

Inputs: no named parameters.

lol_analytics_live_combatAnalyze live combat state and lane differentialsA
Read-onlyIdempotent

Extracts real-time combat status, lane gold/level comparisons, match clock, and team score differentials from the in-match Live Game Engine on port 2999. Use this tool during active live games to assess map state, score leads, or lane advantages. For raw live game data or item builds, use lol_game_all or lol_game_player instead. For post-game analysis, use lol_analytics_match_detail. Behavior: Safe and read-only; connects directly to local game client without external network calls. Returns inGame: false if no match is currently running.

Inputs: no named parameters.

lol_analytics_loot_summaryAnalyze loot inventory and essence valuesA
Read-onlyIdempotent

Calculates total potential Blue Essence (from champion shards) and Orange Essence (from skin shards) along with shard breakdown in player inventory. Use this tool when evaluating available crafting materials, essence totals, or preparing to disenchant duplicate shards. For executing disenchant recipes, use lol_workflow_loot_disenchant. For general store and catalog purchases, use lol_request. Behavior: Safe and read-only; queries local player loot inventory without modifying items. Returns essence summaries and shard lists.

Inputs: no named parameters.

lol_analytics_match_detailDeep post-match breakdown and objective analyticsA
Read-onlyIdempotent

Calculates advanced post-game metrics including player damage share %, gold efficiency, kill participation (KP %), vision score, and team objective counts (dragons, barons, towers). Use this tool when analyzing the decisive factors, individual carrying performance, or throws of a specific completed match. For viewing multiple recent matches in brief, use lol_analytics_match_history instead. For live in-progress matches, use lol_analytics_live_combat. Behavior: Safe and read-only; automatically defaults to the most recent match if gameId is omitted. Returns structured objective and player breakdowns.

Inputs: gameId.

lol_analytics_match_historyFetch compact recent match history listA
Read-onlyIdempotent

Retrieves a token-efficient, compact list of recent match history games for a summoner with resolved champion names, KDA, win/loss, duration, and queue IDs. Use this tool when you need an overview of recent games without filling the context window with raw JSON data. For high-level ranked stats and winrates, use lol_analytics_player instead. For a deep analytical dive into a single game's damage and objectives, use lol_analytics_match_detail. Behavior: Safe and read-only; queries local client match history and static champion data. Returns an array of concise match objects.

Inputs: limit, puuid, queueId.

lol_analytics_playerAnalyze summoner ranked and match history performanceA
Read-onlyIdempotent

Evaluates comprehensive summoner profile analytics including ranked tiers, LP, winrate %, average KDA, CS per minute, and primary champion pool. Use this tool when assessing a player's skill level, ranked progression, or preferred champions before or after matches. For viewing individual recent matches in a compact list, use lol_analytics_match_history instead. For in-depth post-match breakdown, use lol_analytics_match_detail. Behavior: Safe and read-only; queries local client cache and REST endpoints without modifying game state. Returns structured performance metrics.

Inputs: puuid, matchCount.

lol_cdp_console_startStart tailing the client consoleA
Idempotent

Attach to the League Client renderer via Chrome DevTools Protocol (CDP) and begin streaming console logs, warnings, and uncaught exceptions into an in-memory buffer. Use this tool before executing UI actions or testing plugins to capture runtime frontend diagnostics. To retrieve buffered entries, call lol_cdp_console_tail. To stop capturing and release memory, call lol_cdp_console_stop. For client log files on disk, use lol_logs_tail instead. Behavior: Non-destructive; automatically survives renderer page reloads with continuity. Prerequisite: Active CDP connection.

Inputs: no named parameters.

lol_cdp_console_stopStop tailing the client consoleA
DestructiveIdempotent

Detach from the League Client renderer and terminate the console log buffering session. Use this tool when console log capture is complete to release memory and close the CDP socket. For stopping network request capture, use lol_cdp_network_stop instead. Behavior: Discards any remaining unread entries from the in-memory buffer. Idempotent; safe to call when already stopped.

Inputs: no named parameters.

lol_cdp_console_tailRead buffered client console outputA
Read-onlyIdempotent

Retrieve buffered console logs, warnings, and runtime JavaScript exceptions recorded since the tailer was started or past a given cursor. Use this tool to inspect frontend errors, check component mounting logs, or debug UI scripts. Prerequisite: Must call lol_cdp_console_start first; fails if tailer is not running. For HTTP request traffic, use lol_cdp_network_tail instead. Behavior: Sequential integer cursors ensure gap-free incremental reading without skipping entries.

Inputs: text, level, limit, since, +3 more.

lol_cdp_dom_treeAnalyze UI modal stack, invisible backdrops, and viewport hierarchyA
Read-onlyIdempotent

Inspects the League client Chromium Embedded Framework (CEF) DOM hierarchy, active modal stack, invisible blocking backdrops, and current viewport plugin route. Identifies open dialogs (.modal-container, lol-uikit-dialog-frame, [class*="modal"]), unclosed transparent overlays blocking user clicks (frozen UI bug), active rcp-fe-lol-* plugins, and the focused element. Use this tool to diagnose unclickable UI buttons, stuck modals, or verify client screen state. Prerequisite: Requires Chrome DevTools Protocol (CDP) enabled via Pengu Loader; check lol_status if connection fails.

Inputs: maxDepth, includeOverlaysOnly.

lol_cdp_network_bodyRead one response bodyA
Read-onlyIdempotent

Fetch the raw response body payload for a specific captured network request ID from the live renderer. Use this tool after lol_cdp_network_tail to examine the raw payload or JSON response of an interesting request. For high-level request metadata or status codes without bodies, lol_cdp_network_tail suffices. Behavior: Reaches live renderer cache. Prerequisite: Request must have been captured in the current renderer session; fails if evicted or client reloaded.

Inputs: requestId (required).

lol_cdp_network_bottlenecksAnalyze network latency bottlenecks and failed asset loadsA
Read-onlyIdempotent

Analyzes captured HTTP network requests to identify latency bottlenecks, slow endpoint patterns, and failed asset loads. Calculates P50, P90, and P99 latencies per normalized endpoint, extracts slowest requests exceeding a threshold duration with initiator stack traces, and groups HTTP 4xx/5xx or transport errors. Use this tool to diagnose frontend lag, sluggish LCU REST endpoints, or broken plugin scripts and missing icons. Prerequisite: Network recording must be active; call lol_cdp_network_start first.

Inputs: limit, thresholdMs, includeInitiators.

lol_cdp_network_startStart recording client HTTP requestsA
Idempotent

Attach to the League Client renderer via Chrome DevTools Protocol (CDP) and begin capturing outgoing and incoming HTTP/HTTPS network requests into an in-memory buffer. Use this tool to monitor REST traffic, measure endpoint latency, or debug failed API calls made by the client UI. To inspect captured requests, call lol_cdp_network_tail or lol_cdp_network_summary. To read response payload bodies, use lol_cdp_network_body with a request ID. For WebSocket events, use lol_events_* or lol_wamp_record_* instead. Behavior: Captures request metadata, headers, status codes, and timing. Prerequisite: Active CDP connection.

Inputs: no named parameters.

lol_cdp_network_stopStop recording client HTTP requestsA
DestructiveIdempotent

Detach from the League Client renderer and terminate the network traffic recording session. Use this tool when network analysis is complete to release memory and close the CDP monitoring session. Behavior: Discards in-memory network buffers. Idempotent; safe to call when already stopped.

Inputs: no named parameters.

lol_cdp_network_summarySummarise buffered client HTTP requestsA
Read-onlyIdempotent

Aggregate and summarize captured HTTP requests by method and endpoint URL pattern with status breakdown, total byte volume, and median duration. Use this tool to analyze high-volume client polling traffic, discover top endpoints, or spot systemic failure rates over time without reading raw request logs. For individual request inspection with timestamps, use lol_cdp_network_tail instead. Behavior: Safe and read-only; summarizes in-memory buffer without consuming or altering stream cursors.

Inputs: since, until, method, urlContains.

lol_cdp_network_tailRead buffered client HTTP requestsA
Read-onlyIdempotent

Retrieve captured HTTP network requests from the in-memory buffer, filtered by status, URL pattern, or HTTP method. Use this tool to inspect recent client network calls and identify 4xx/5xx errors or hung requests. Prerequisite: Must call lol_cdp_network_start first; fails if network recording is not running. To fetch full response bodies, pass returned request IDs to lol_cdp_network_body. For aggregated traffic statistics, use lol_cdp_network_summary instead. Behavior: Returns completed requests and active in-flight requests.

Inputs: type, limit, since, until, +7 more.

lol_cdp_performanceProfile CEF performance and memory metricsA
Read-onlyIdempotent

Inspect Chromium Embedded Framework (CEF) performance and memory metrics for the League client frontend. Gathers JS heap size, DOM node count, layout count, recalc style count, task and script duration, and flags memory pressure warnings. Use this tool to detect memory leaks, detached DOM nodes, or renderer lag in frontend plugins. Prerequisite: Requires Chrome DevTools Protocol (CDP) enabled via Pengu Loader; check lol_status if connection fails. (Note: Pengu Loader is required for CDP tools; standard LCU REST, events, and workflows work without it).

Inputs: no named parameters.

lol_cdp_screenshotCapture screenshot of the League ClientA
Destructive

Capture a visual screenshot image of the active League Client window or a specific renderer target using Chrome DevTools Protocol (CDP). When to use: When visual rendering, modal layout, or graphic verification is needed. When NOT to use: Do not use for automated state checks or element queries (use lol_dom_query) or API data inspection (use lol_get). Behavior: Safe read of visual pixels from the renderer; writes to local filesystem only when savePath is explicitly supplied. Prerequisite: League client must be running with remote debugging enabled via Pengu Loader; check lol_status if disconnected. (Note: Required for CDP tools only). Returns dual-payload MCP content with a base64 image data block plus structured JSON metadata (format, dimensions, byte length, savedTo path).

Inputs: format, quality, savePath, targetId.

lol_cdp_storageInspect client localStorage, sessionStorage, and feature flagsA
Read-onlyIdempotent

Inspects the League client Chromium Embedded Framework (CEF) localStorage and sessionStorage entries. Extracts active client-side settings, feature flags, cached configurations, and theme preferences. Supports case-insensitive substring filtering on keys and values, JSON auto-parsing, and automatic redaction of auth tokens, passwords, and sensitive cookies. Prerequisite: Requires Chrome DevTools Protocol (CDP) enabled via Pengu Loader; check lol_status if connection fails.

Inputs: limit, filter, parseJson, storageType.

lol_cdp_targetsList CDP debugging targetsA
Read-onlyIdempotent

Discover and list all active Chrome DevTools Protocol (CDP) debugging targets (pages, modals, worker contexts) exposed by the League Client. Use this tool to inspect available renderer contexts and discover target IDs before capturing targeted screenshots with lol_cdp_screenshot or tailing console and network. Behavior: Safe and read-only. Prerequisite: League client must be running with remote debugging enabled via Pengu Loader. (Note: Pengu Loader is required for CDP tools; standard LCU REST, events, and workflows work without it).

Inputs: no named parameters.

lol_chat_sendSend message into in-game or lobby chatA
Destructive

Sends a text chat message into the active champion select, lobby, or custom game conversation, or into a specific conversation ID. Use this tool to communicate team plans, role preferences, or greetings during lobby or draft phases. For updating your summoner availability status or custom status message, use lol_chat_status instead. Behavior: Sends a chat message to client conversations; automatically resolves active team/lobby chat if conversationId is omitted. Needs "POST /lol-chat/v1/conversations/*/messages" on the write allowlist.

Inputs: message (required), conversationId.

lol_chat_statusUpdate summoner presence and status messageA
DestructiveIdempotent

Updates the local player's chat availability ("chat", "away", "dnd", "mobile") and custom status headline text visible to friends. Use this tool when setting do-not-disturb, stepping away from the client, or broadcasting a custom status message. For sending chat messages to conversations, use lol_chat_send instead. Behavior: Mutates friend presence state; idempotent when setting the same presence status. Needs "PUT /lol-chat/v1/me" on the write allowlist.

Inputs: availability, statusMessage.

lol_dom_queryQuery the League client DOMA
Read-onlyIdempotent

Query HTML elements in the active League client Chromium Embedded Framework (CEF) UI DOM using CSS selectors. Use this tool as the primary safe method to inspect live UI elements, verify modal state, or find element identifiers. Do not use lol_eval when a CSS selector query suffices. For arbitrary JavaScript execution or state mutation in the UI page, use lol_eval instead. For capturing visual UI state as an image, use lol_cdp_screenshot instead. Prerequisite: Requires Chrome DevTools Protocol (CDP) enabled via Pengu Loader; check lol_status if connection fails. Note: Pengu Loader is required for CDP tools, but standard LCU REST, WAMP, and game tools work without it.

Inputs: selector (required), all, props.

lol_endpointsList curated LCU endpointsA
Read-onlyIdempotent

Search the curated catalog of League Client Update (LCU) REST API endpoints commonly used for automation and monitoring. Returns matching endpoint paths, HTTP verbs, functional groups, and summary descriptions. Use this tool to quickly discover available endpoints by keyword (e.g. "champ-select", "lobby", "summoner"). For full OpenAPI/Swagger schema definitions, parameter types, or data models, use lol_schema instead. Prerequisite: Works offline without requiring an active League client connection.

Inputs: filter.

lol_evalEvaluate JavaScript in the client pageA
Destructive

Execute an arbitrary JavaScript expression within the League client Chromium Embedded Framework (CEF) renderer context and return the evaluated result. CRITICAL: Do NOT use lol_eval for LCU REST API calls (e.g. fetch('/lol-...')) or client state queries. For safe LCU REST queries, ALWAYS use lol_get or lol_request. For automated game actions (lobby, matchmaking, champ-select, runes), ALWAYS use lol_workflow_* tools. For safe DOM structure inspection, prefer lol_dom_query. Use lol_eval ONLY for advanced CEF runtime debugging, custom in-page UI automation, or reading internal renderer properties not exposed via REST. Behavior: Destructive and unsandboxed; bypasses the write allowlist by construction. Security: Gated by allowEval config flag (check lol_status); calls are refused if allowEval is false. Prerequisite: Requires active CDP connection enabled via Pengu Loader (required for CDP tools; not needed for REST/workflow tools).

Inputs: expression (required), awaitPromise.

lol_events_pollDrain buffered LCU eventsA
Read-onlyIdempotent

Drain buffered League Client WebSocket events recorded since a given sequence cursor, returning events and the new cursor. Use this tool to incrementally consume live client events after calling lol_events_start. For recording full WAMP traffic frames, use lol_wamp_record_dump instead. If an event payload indicates truncated: true, use lol_get on the entry URI to fetch the full resource. Behavior: Safe and read-only. A non-zero dropped count indicates buffer overflow between polls.

Inputs: limit, since, filter.

lol_events_startStart buffering LCU eventsA
Idempotent

Open the League Client WebSocket event tap and buffer live OnJsonApiEvent Create/Update/Delete notifications in memory. Use this tool to monitor real-time client state changes (such as champ select progress, gameflow phase, or lobby party updates). To poll buffered events, call lol_events_poll. To record raw WAMP frames with socket lifecycle diagnostics, use lol_wamp_record_start instead. For static game assets, use lol_static instead. Behavior: Ring buffer evicts oldest events after buffer limit is reached. Calling while running updates URI filters and preserves already buffered events. Prerequisite: League client must be running.

Inputs: filters.

lol_events_stopStop buffering LCU eventsA
Idempotent

Close the League Client WebSocket event tap and stop buffering live events. Use this tool to pause or end event collection and conserve memory. Buffered events remain readable via lol_events_poll after stopping. For stopping WAMP recording, use lol_wamp_record_stop instead. Behavior: Idempotent; safe to call when already stopped.

Inputs: no named parameters.

lol_forensics_anomaly_detectDetect cross-stream telemetry anomalies and client crash signaturesA
Read-onlyIdempotent

Scans across active LCU WAMP event recordings, CDP console logs, network requests, and client disk logs to detect anomalies and crash patterns. Identifies frontend exception bursts, LCU HTTP server error clusters (500/503), WebSocket disconnects, and fatal crashes with root-cause hypotheses. Behavior: Safe and read-only. Does not interrupt background loggers or active streams.

Inputs: windowSeconds, severityFilter.

lol_forensics_bundleGenerate comprehensive diagnostics bundle across all LCU telemetry streamsA
Read-onlyIdempotent

Generate an all-in-one diagnostic bundle combining system connectivity status, correlated telemetry timelines, and recent disk log tails. Use this tool as a single-call comprehensive health check or bug report export when diagnosing complex client issues. For interactive querying of specific streams, use lol_forensics_correlate or subsystem-specific tools. Behavior: Safe and read-only. Returns Markdown report by default, or structured JSON when specified.

Inputs: limit, since, until, format, +2 more.

lol_forensics_correlateCorrelate LCU WAMP and CDP console timelinesA
Read-onlyIdempotent

Correlate events across LCU WAMP, Chrome DevTools Protocol console logs, network requests, disk logs, and live game telemetry into a unified chronological timeline. Use this tool during incident triage to identify whether client state changes triggered frontend UI errors or network failures. For a complete system report with status snapshots, use lol_forensics_bundle instead. For raw console logs alone, use lol_cdp_console_tail. Behavior: Safe and read-only. Gracefully combines active in-memory streams without interrupting background loggers.

Inputs: limit, since, until, format, +5 more.

lol_forensics_export_harExport client HTTP network traffic to standard HAR (HTTP Archive) formatB
Read-onlyIdempotent

Exports captured HTTP/HTTPS network traffic from the active network tailer into a standard HAR 1.2 archive. Automatically redacts sensitive authorization headers (Basic/Bearer auth, Riot auth tokens), session cookies, and credentials. If savePath is specified, writes the formatted HAR file directly to disk; otherwise returns the full HAR JSON structure. Prerequisite: Network recording must be active; call lol_cdp_network_start first to begin capturing requests.

Inputs: limit, savePath.

lol_game_allLive game all dataA
Read-onlyIdempotent

Fetch complete real-time in-match game state (scores, player inventories, game time, objectives, events) from the live League game engine. Use this tool during an active match to get full game telemetry. For specific player details, use lol_game_player. For game clock and map only, use lol_game_stats. For in-game kill/objective events, use lol_game_events. For client/lobby data outside matches, use lol_get. Behavior: Prerequisite: Match must be currently running (Live Client Data API on port 2999). Safe and read-only. Returns compact summary by default to conserve tokens; pass "raw" for full ~100KB payload.

Inputs: format.

lol_game_eventsLive game eventsA
Read-onlyIdempotent

Retrieve in-game events (champion kills, dragon/baron objectives, turret destructions, aces) from the live game engine. Use this tool to track recent in-match actions or feed an event timeline. For full match state including player inventories, use lol_game_all instead. Behavior: Safe and read-only. Supports incremental cursor via afterId. Prerequisite: Active match running on port 2999.

Inputs: afterId.

lol_game_playerLive game player dataA
Read-onlyIdempotent

Fetch real-time live match statistics, item inventory, abilities, and runes for the active local player or a named summoner. Use this tool to inspect a specific player's current gold, level, KDA, items, or rune setup during an active match. For all players in the match at once, use lol_game_all instead. Behavior: Safe and read-only. Prerequisite: Match must be currently in progress (port 2999).

Inputs: name.

lol_game_statsLive game statsA
Read-onlyIdempotent

Fetch basic match status, game clock time, game mode, and map ID from the live League game engine. Use this tool to quickly verify whether a match is currently in progress, check elapsed game time, or identify the game mode. For full match telemetry including players and scores, use lol_game_all instead. Behavior: Safe and read-only. Prerequisite: Match must be currently running (port 2999).

Inputs: no named parameters.

lol_getGET an LCU endpointA
Read-onlyIdempotent

Send a read-only HTTP GET request to any internal League Client Update (LCU) REST API endpoint and return { status, body }. This is the primary and recommended tool to inspect live client state (such as summoner profile, lobby members, or gameflow phase) instead of using lol_eval. For mutating actions (POST, PUT, PATCH, DELETE), use lol_request instead. To discover supported endpoint paths, use lol_endpoints or lol_schema. Prerequisite: League client must be running. Safe and idempotent; requires no write allowlist entries.

Inputs: path (required).

lol_launch_clientLaunch the League of Legends clientA
Idempotent

Launch the League of Legends client via Riot Client Services or LeagueClient.exe and optionally wait until the LCU REST API becomes responsive. If the client is already running and responsive, returns immediately without spawning a duplicate process. Behavior: Safe and idempotent. Prerequisite: League of Legends must be installed on the system.

Inputs: path, waitForReady, timeoutSeconds.

lol_logs_sessionsList log sessions on diskA
Read-onlyIdempotent

List historical and active League Client, UX, or Game log files on disk sorted by modification time, newest first. Use this tool to discover session identifiers or log filenames to pass into lol_logs_tail session parameter. For reading log content directly, use lol_logs_tail. Behavior: Safe and read-only. Scans standard Riot Games log directories on disk.

Inputs: limit, target.

lol_logs_tailRead recent log lines from diskA
Read-onlyIdempotent

Read the most recent log lines from the active or selected League Client, CEF UX, or Game engine disk log file. Use this tool to inspect historical or startup errors recorded on disk. For live streaming log monitoring, use lol_logs_watch_start and lol_logs_watch_poll instead. For in-memory renderer console messages, use lol_cdp_console_tail. Behavior: Safe and read-only. Automatically redacts passwords, auth tokens, and sensitive keys from log output.

Inputs: level, lines, search, target, +1 more.

lol_logs_watch_pollPoll buffered disk log entriesA
Read-onlyIdempotent

Poll newly buffered disk log entries captured by the active disk log watcher since a given cursor. Use this tool to consume real-time log lines while watching is active. Prerequisite: Requires lol_logs_watch_start to be running; returns empty if stopped. For reading historical lines from file EOF, use lol_logs_tail instead. Behavior: Safe and read-only. Supports cursor-based incremental polling without duplicates.

Inputs: level, limit, cursor, search.

lol_logs_watch_startStart live disk log watcherA
Idempotent

Start watching a League Client disk log file for newly appended lines, streaming entries into an in-memory ring buffer. Use this tool before reproducing an issue to capture new disk log entries as they are written. To poll new entries, call lol_logs_watch_poll. When finished, call lol_logs_watch_stop. For one-off historical reads from disk, use lol_logs_tail instead. Behavior: Non-destructive. Ring buffer evicts oldest lines on overflow.

Inputs: target.

lol_logs_watch_stopStop live disk log watcherA
DestructiveIdempotent

Stop the active disk log watcher and release file handles and in-memory log buffer. Use this tool to end log watching and free memory when debugging is complete. Behavior: Idempotent; safe to call when already stopped.

Inputs: no named parameters.

lol_requestCall an LCU endpoint with any verbA
Destructive

Send an HTTP request with any verb (GET, HEAD, POST, PUT, PATCH, DELETE) to an internal League Client Update (LCU) REST endpoint. Use this tool to perform client mutations or call endpoints not covered by dedicated workflow tools. Always prefer this tool over lol_eval for REST API interactions. For safe read-only queries, prefer lol_get. For common automated actions like champion selection or lobby creation, prefer lol_workflow_* tools. Behavior: GET and HEAD are always allowed. Mutating verbs require matching entries in the write allowlist; unauthorized requests are rejected before execution.

Inputs: path (required), method (required), body.

lol_restart_uxRestart the League Client UXA
Destructive

Terminate and relaunch the League Client user interface frontend (Chromium Embedded Framework renderers) via Riot Client API. Use this tool to recover from a frozen client UI, apply Pengu Loader plugin changes, or reload corrupted UI states without closing the League game process. For gameflow or lobby navigation, use lol_workflow_* tools instead. Behavior: Destructive to current UI state (severs active CDP and WebSocket connections). When waitForReady is true, cleanly polls until LCU HTTP API and CDP page target are restored. Prerequisite: Riot Client and LCU process must be running.

Inputs: waitForReady, timeoutSeconds.

lol_schemaQuery LCU OpenAPI/Swagger schemaA
Read-onlyIdempotent

Inspect internal LCU API endpoint signatures, parameters, request bodies, and data models using the League client's live OpenAPI/Swagger v2 specification. Use this tool to find the exact request schema, parameter types, or response models before invoking lol_request. For a lightweight list of common endpoints, use lol_endpoints instead. For static game assets (champions, items, runes), use lol_static instead. Prerequisite: League client must be running to fetch swagger doc; cached in memory after first load.

Inputs: path, model, method, refresh.

lol_staticResolve static game data ids to namesA
Read-onlyIdempotent

Resolve numeric League of Legends game data IDs to human-readable names and metadata using locally served static client documents. Use this tool to translate raw championId, itemId, perkId, summonerSpellId, mapId, or queueId received from other tools or telemetry events into readable entities. For live client state, use lol_get instead. For OpenAPI endpoint models, use lol_schema instead. Prerequisite: League client must be running to fetch static bundles; results are cached.

Inputs: kind (required), ids, limit, query, +3 more.

lol_statusLeague client statusA
Read-onlyIdempotent

Inspect overall connectivity, health, and configuration status across all server subsystems (LCU REST/WebSocket, Chrome DevTools Protocol, event buffers, live game engine). Use this tool first when diagnosing connection failures, verifying lockfile detection, or checking effective allowlist rules and allowEval permissions. Behavior: Safe and read-only; requires no client write permissions.

Inputs: no named parameters.

lol_wamp_record_dumpDump the recorded WAMP timelineA
Read-onlyIdempotent

Retrieve recorded WAMP timeline entries, socket lifecycle events, and cumulative per-URI statistics from the recorder buffer. Use this tool to inspect recorded WebSocket frames and diagnose whether a quiet URI received no traffic or the socket disconnected. Prerequisite: lol_wamp_record_start must have been called. For general timeline correlation across multiple subsystems, use lol_forensics_correlate. Behavior: Returns timestamped entries, dropped frame count, and cumulative per-URI stats surviving eviction.

Inputs: uri, kinds, limit, since, +2 more.

lol_wamp_record_startStart recording LCU WAMP trafficA
Destructive

Open a dedicated secondary WAMP WebSocket connection to the League Client and record raw frames alongside socket lifecycle events into a chronological timeline. Use this tool for deep protocol diagnostics, debugging connection drops, or analyzing WAMP message flows. For lightweight high-level event polling, prefer lol_events_start instead. To dump recorded frames, call lol_wamp_record_dump. Behavior: Captures open, close (with exit codes), errors, reconnect gaps, and message frames. Starting while already recording throws an error unless restart is true.

Inputs: uris, restart.

lol_wamp_record_stopStop recording LCU WAMP trafficA
Idempotent

Terminate the dedicated WAMP recorder WebSocket connection and halt traffic capture. Use this tool when WAMP diagnostic recording is finished. Recorded entries remain accessible via lol_wamp_record_dump. Behavior: Idempotent; safe to call when already stopped.

Inputs: no named parameters.

lol_workflow_champ_selectPick, hover, or ban champion in champion selectA
Destructive

Resolves local player action in active champion select, chooses champion by name or ID, and hovers or locks in. Use this tool during draft or blind pick phases to hover or confirm champion selection or ban. Always prefer this dedicated workflow tool over manual REST calls or lol_eval. For adjusting rune/perk pages during champ select, use lol_workflow_runes_set instead. For general lobby management, use lol_workflow_lobby. A lock-in cannot be undone. Needs "PATCH /lol-champ-select/v1/session/actions/*" on the write allowlist.

Inputs: champion (required), type, completed.

lol_workflow_champ_select_benchSwap champion with ARAM benchA
Destructive

Swaps your active champion with an available champion on the ARAM bench by name or numeric champion ID. Use this tool during ARAM champion select when a preferred champion becomes available on the shared team bench. For regular draft pick, hover, or ban actions, use lol_workflow_champ_select instead. For setting summoner spells, use lol_workflow_spells_set. Behavior: Mutates active player champion assignment; fails cleanly if target champion is not on the bench or champ select is inactive. Needs "POST /lol-champ-select/v1/session/bench/swap/*" on the write allowlist.

Inputs: champion (required).

lol_workflow_honorSubmit teammate honor voteA
Destructive

Submits a post-game honor vote for an eligible allied teammate by summoner name, gameName, or summonerId with a selected honor category ("COOL", "SHOTCALLER", or "HEART"). Use this tool when voting on the post-match honor ballot before returning to the lobby. For recreating the previous game lobby, use lol_workflow_play_again. For inspecting post-game match statistics, use lol_analytics_match_detail. Behavior: Submits an irreversible honor vote; fails cleanly if no honor ballot is active or target is not found on ballot. Needs "POST /lol-honor/v1/honor" on the write allowlist.

Inputs: target (required), honorCategory.

lol_workflow_lobbyCreate game lobby and optionally start matchmakingA
Destructive

Creates a custom or matchmade lobby for a queue (e.g. 420 for Ranked Solo, 450 for ARAM) and optionally starts matchmaking queue search. Replaces the current lobby if it is on another queue. If the search fails after a lobby was created from nothing, that lobby is closed again. Use this tool to set up queues or queue up with a party. Always prefer this dedicated workflow tool over manual REST calls or lol_eval. For accepting the ready check when queue pops, use lol_workflow_matchmaking_accept instead. To look up queue IDs, query lol_static with kind "queues". Needs "POST /lol-lobby/v2/lobby" (and, for startMatchmaking, "POST /lol-lobby/v2/lobby/matchmaking/search" plus "DELETE /lol-lobby/v2/lobby" to undo) on the write allowlist.

Inputs: queueId (required), startMatchmaking.

lol_workflow_lobby_inviteInvite summoners to active party lobbyA
Destructive

Dispatches invitations to one or more summoner PUUIDs to join the current game lobby party. Use this tool after creating a lobby when inviting friends or premade party members. For creating a lobby or starting matchmaking search, use lol_workflow_lobby instead. For accepting match ready checks, use lol_workflow_matchmaking_accept. Behavior: Mutates lobby invitation state; fails with diagnostic error if not currently in a lobby. Needs "POST /lol-lobby/v2/lobby/invitations" on the write allowlist.

Inputs: toSummonerPuuids (required).

lol_workflow_loot_disenchantDisenchant loot shards for essenceA
Destructive

Disenchants specified champion or skin shards by lootId to yield Blue or Orange Essence. Use this tool to convert unwanted or duplicate shards into crafting essence. For viewing total potential essence yields before disenchanting, use lol_analytics_loot_summary first. Behavior: Consumes inventory items; cannot be undone once crafted. Needs "POST /lol-loot/v1/recipes/*/craft" on the write allowlist.

Inputs: lootId (required), count.

lol_workflow_matchmaking_acceptAccept matchmaking ready checkA
Idempotent

Checks matchmaking ready check status and accepts if match is found. Use this tool when automated match acceptance is needed during queue pop. Always prefer this dedicated workflow tool over manual REST calls or lol_eval. For creating a lobby or initiating matchmaking queue search, use lol_workflow_lobby instead. For champion selection, use lol_workflow_champ_select. Behavior: Safe and idempotent; no-op if no ready check is active. Needs "POST /lol-matchmaking/v1/ready-check/accept" on the write allowlist.

Inputs: no named parameters.

lol_workflow_play_againRecreate game lobby from post-game screenA
Destructive

Triggers lobby recreation with the previous game queue and party settings from the End of Game or post-match screen. Use this tool after a match completes to quickly return to a queue lobby without manually reselecting game modes. For creating a brand-new lobby with a specific queue ID, use lol_workflow_lobby instead. For honoring teammates, use lol_workflow_honor. Behavior: Mutates client gameflow state; requires client to be in EndOfGame or PreEndOfGame phase. Needs "POST /lol-lobby/v2/play-again" on the write allowlist.

Inputs: no named parameters.

lol_workflow_runes_setSet or update active rune/perk pageA
DestructiveIdempotent

Creates or updates an editable rune page with specified primary/sub styles and perk IDs and sets it active. Reuses an existing page only when its name matches, so pages the user built by hand are left alone. Use this tool before or during champ select to configure runes for a specific champion build. Always prefer this dedicated workflow tool over manual REST calls or lol_eval. To look up numeric rune IDs from names or styles, query lol_static with kind "perks". Needs "POST /lol-perks/v1/pages" and "PUT /lol-perks/v1/pages/*" on the write allowlist.

Inputs: subStyleId (required), primaryStyleId (required), selectedPerkIds (required), name, +1 more.

lol_workflow_spells_setConfigure summoner spells in champion selectA
DestructiveIdempotent

Resolves summoner spell names (case-insensitive, e.g. "flash", "ignite", "smite", "teleport") or integer IDs and updates the player's spell selection in active champion select. Use this tool during champion select to equip appropriate summoner spells for your role. For configuring rune pages, use lol_workflow_runes_set instead. For picking or hovering champions, use lol_workflow_champ_select. Behavior: Mutates player spell slots; idempotent when setting the same spells. Requires champion select session to be active. Needs "PATCH /lol-champ-select/v1/session/my-selection" on the write allowlist.

Inputs: spell1 (required), spell2.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 61 tools

    Disambiguation3/5

    Many tools have overlapping diagnostic or monitoring purposes (e.g., lol_events_start vs lol_wamp_record_start, lol_cdp_network_summary vs lol_cdp_network_bottlenecks, multiple game/analytics tools). Descriptions explicitly guide selection with cross-references, so boundaries are mostly clear, but the sheer number of similar alternatives creates realistic misselection risk.

    Naming Consistency4/5

    All tool names use a consistent lol_ prefix and snake_case, with predictable category markers (cdp, logs, wamp, workflow, analytics, forensics, game). The pattern is not strictly verb_noun throughout (e.g., lol_get, lol_status, lol_schema), but it remains highly readable and mostly uniform.

    Tool Count1/5

    61 tools is an extreme mismatch for a single MCP server, far exceeding the 25+ threshold that already indicates excessive breadth. While each tool may have a niche, the count forces agents to navigate an unwieldy surface with many related start/stop/poll variants.

    Completeness4/5

    The tool surface is very comprehensive, covering LCU REST, CDP, WAMP, disk logs, live game telemetry, forensics, and automation workflows. Only minor gaps exist (e.g., some CRUD operations rely on the generic lol_request), but agents have workarounds and no major domain area is unaddressed.

    Maintenance

    ActivitySlowing
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      C
      quality
      D
      maintenance
      An MCP (Model-Controller-Processor) server for accessing League of Legends client data. This server provides a collection of tools that communicate with the League of Legends Live Client Data API to retrieve in-game data.
      12
      12
      Apache 2.0
    • A
      license
      A
      quality
      D
      maintenance
      Provides MCP tools to query Liquipedia esports data (matches, teams, players, tournaments, placements, standings) via the Liquipedia v3 API and MediaWiki action API.
      8
      56 npm
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      Provides Roblox game inspection and manipulation capabilities through MCP, including exploring the instance hierarchy, editing properties, decompiling scripts, and interacting with remote events.
      1
      -
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables MCP clients to control a logged-in Discord account through 70+ tools: browsing guilds and channels, sending and reacting to messages, moderating members, managing channels, roles, emojis, and webhooks, plus searching and analyzing captured message history stored in SQLite. Authenticates using tokens already cached by the local Discord client, requiring no bot account or manual token setup.
      141 npm
      MIT