lcu-mcp
Summary: lcu-mcp is a local MCP server that lets an MCP host inspect, monitor, diagnose, and automate a running League of Legends client via LCU REST, live WAMP events, CDP/DOM, logs, and in-game telemetry.
LCU REST API: check health, GET any path, send allowlisted mutating verbs, list curated endpoints, and query OpenAPI schemas.
Static data: resolve champion/item/perk/spell/map/queue IDs to local game-data names.
Live events: start/poll/stop LCU WAMP event buffering with filters, cursors, truncation, and drop tracking.
CDP/DOM: query the client DOM, evaluate JavaScript if enabled, list targets, take screenshots, and restart the UX.
Forensics/diagnostics: record WAMP traffic, tail CDP console/network, inspect logs, performance, storage, and correlate WAMP/CDP/network/logs/game streams.
Workflows: accept ready checks, pick/ban/bench champions, set spells/runes, manage lobbies/invites, honor, play again, disenchant loot, and send chat/status.
Analytics: player ranked summaries, match history/detail, champ-select scout, live combat telemetry, and loot essence yield.
Safety: local 127.0.0.1 only, pinned TLS, write allowlist, eval gating, and credential redaction.
Provides tools for interacting with the League of Legends client, including querying the LCU REST API, streaming live game events, inspecting the client UI via CDP, and optionally executing JavaScript in the client.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@lcu-mcp What's my current queue and champ select status?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
lcu-mcp
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:
LcuClientreads 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 onOnJsonApiEventthat feeds an in-process ring buffer.CdpClientattaches 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 |
Pengu Loader | Optional — required only for |
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-mcpFrom source
git clone https://github.com/Triggered0/lcu-mcp.git
cd lcu-mcp
npm installRuntime 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.jsAny 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?" |
|
"Who am I logged in as?" |
|
"What am I doing in the client right now?" |
|
"Which champion is id 157?" |
|
"Watch champ select and tell me what happens." |
|
"What does the lobby endpoint accept?" |
|
"Accept the ready check." |
|
"Screenshot the client." |
|
"What is my ranked winrate and recent roles?" |
|
"Summarize my last 5 matches concisely." |
|
"Analyze damage and objectives in my last game." |
|
"What is our team damage mix in champ select?" |
|
"Set my summoner spells to Flash and Ignite." |
|
"Swap champion with ARAM bench." |
|
"How much essence do my loot shards yield?" |
|
Nothing here needs a Riot API key or an internet connection: every call goes to 127.0.0.1.
Tools
Tool | Purpose |
| Per-subsystem health, resolved LCU port, configured CDP port, whether |
| GET any LCU path |
| Any verb, subject to the write allowlist |
| List the curated endpoint table |
| Resolve champion/item/perk/spell/map/queue ids to names from the client's local game data |
| Open the WebSocket tap and begin buffering |
| Drain the ring buffer |
| Close the tap |
| Query the client DOM |
| Evaluate JavaScript in the page |
| Record LCU WAMP traffic on an independent socket |
| Dump the recorded timeline and per-URI stats |
| Close the recorder socket |
| Begin buffering client console output |
| Read buffered console entries |
| Stop and discard the console buffer |
| Begin buffering the HTTP requests the client UI makes |
| Read buffered requests |
| Fetch one response body from the live renderer |
| Aggregate requests by method and url |
| Stop and discard the request buffer |
| Tail the most recent lines of a client, UX, or game log |
| Begin streaming newly appended log lines into a ring buffer |
| Poll newly streamed log entries |
| Stop and discard the log watcher buffer |
| List active and historical log files on disk |
| Fetch full real-time live game state from in-match game engine (summary or raw) |
| Check match status, game clock, mode, and map terrain from the live game engine |
| Fetch real-time stats, abilities, items, and runes for the active or named player |
| Retrieve in-game events (kills, objectives, aces) with incremental cursor support |
| Safely restart client CEF renderers with readiness polling |
| Launch Riot Client / League of Legends client and wait for LCU readiness |
| List all active CDP debugging targets (pages, popups, workers) |
| Capture client screenshot via CDP (returns MCP image + disk save) |
| CEF performance metrics, JS heap memory usage, DOM node counts, and leak warnings |
| Inspect UI modal hierarchy, viewport routes, and click-blocking transparent overlays |
| Inspect localStorage/sessionStorage keys and feature flags with credential redaction |
| Identify slow requests, P50/P90/P99 endpoint latencies, and failed assets |
| Scan across all streams for crash signatures, HTTP error clusters, and console bursts |
| Export captured HTTP network traffic to standard HAR 1.2 archive with redaction |
| Query internal LCU OpenAPI/Swagger v2 schemas and models |
| Correlate telemetry across all 5 streams (WAMP, CDP console, CDP network, disk logs, live game) on a shared time axis |
| Generate an end-to-end diagnostic snapshot combining system status, active timeline streams, and disk log fallbacks |
| Accept matchmaking ready check if active and unaccepted |
| Pick, hover, or ban champion by name or numeric ID in active champion select |
| Swap champion with available ARAM bench champion by name or ID |
| Set summoner spells (Flash, Ignite, Smite, Teleport, etc.) by name or ID in champion select |
| Configure, update, and activate a rune/perk page |
| Create game lobby for a queue (e.g. 420 Ranked Solo, 450 ARAM) and optionally start matchmaking |
| Invite players to current lobby party by summoner PUUIDs |
| Recreate game lobby from post-game End of Game screen |
| Vote for teammate on post-game honor ballot ("COOL", "SHOTCALLER", "HEART") |
| Aggregate player identity, ranked tiers, recent winrates, and role breakdown |
| Token-efficient compact match history rows |
| Deep post-game breakdown (objectives, damage share, gold, KDA, team stats) |
| Champ select composition scout (ally/enemy roles, champions, AP/AD damage mix) |
| Real-time live in-game combat telemetry, lane differentials, objective clock |
| Calculate total Blue and Orange Essence yields from champion and skin shards |
| Disenchant champion or skin shards for essence |
| Send chat message into active champion select, lobby, or chat |
| 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_correlatemerges 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 fromLeagueClient.logorLeagueClientUx.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_bundleis 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.logfrom 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, defaulttrue), andformat('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. SupportswindowSecondsandseverityFilter(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 viasavePath.
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: 0with active pointer events) that frequently cause "frozen UI" states or unclickable buttons.lol_cdp_storage: Inspects clientlocalStorageandsessionStoragein 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. Updatesspell1and optionallyspell2simultaneously.lol_workflow_runes_set: Set, replace, and activate rune pages. Withreplace: true(default) it reuses an editable page whose name matchesnameand 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.420for Ranked Solo/Duo,440for Ranked Flex,450for 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 |
|
| Whether |
|
| Pengu Loader's remote debugging port |
|
| Ring buffer capacity; oldest entries are evicted first |
|
| Which mutating requests |
|
| Recorder timeline entry count |
|
| Recorder byte budget; evicts on whichever fills first |
|
| Per-payload truncation for the recorder |
|
| URI prefixes exempt from the payload cap |
|
| Optional NDJSON path the timeline is appended to |
|
| Console tailer entry count |
|
| Network tailer entry count; about 50 minutes at the client's measured request rate |
|
| Disk log watcher ring buffer capacity |
|
| Optional custom logs directory override (defaults to auto-detected |
|
| 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.GETandHEADare 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/*/cmatches/a/b/c(e.g.POST /lol-loot/v1/recipes/*/craftandPOST /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=8888Then restart the client UX so CEF picks the port up:
POST /riotclient/kill-and-restart-uxThis 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 setsrejectUnauthorized: false.The password never leaves the process. It is held only to build the
Authorizationheader — 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_evalbypasses the write allowlist by construction. The client page canfetchany LCU endpoint from its own origin, so evaluated JavaScript can do anything the client can. This is accepted, not fixed: it is gated by theallowEvalflag, whose statelol_statusreports.
Treat the write allowlist as a guardrail against mistakes, not as a security boundary — while
allowEvalistrueit can be bypassed. SetallowEvaltofalsefor a real boundary.lol_dom_querykeeps 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 stdionpm 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 moduleContributing
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 |
| 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 |
| CDP is reachable but the UX is still starting. Retry once the client is visible. |
| Usually an idle client, not a fault. Navigate the UI and poll again; check |
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 toolslol_analytics_champ_select_scoutScout champion select composition and damage mixARead-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 differentialsARead-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 valuesARead-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 analyticsARead-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 listARead-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 performanceARead-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 consoleAIdempotent
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 consoleADestructiveIdempotent
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 outputARead-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 hierarchyARead-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 bodyARead-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 loadsARead-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 requestsAIdempotent
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 requestsADestructiveIdempotent
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 requestsARead-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 requestsARead-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 metricsARead-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 ClientADestructive
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 flagsARead-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 targetsARead-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 chatADestructive
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 messageADestructiveIdempotent
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 DOMARead-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 endpointsARead-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 pageADestructive
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 eventsARead-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 eventsAIdempotent
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 eventsAIdempotent
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 signaturesARead-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 streamsARead-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 timelinesARead-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) formatBRead-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 dataARead-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 eventsARead-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 dataARead-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 statsARead-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 endpointARead-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 clientAIdempotent
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 diskARead-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 diskARead-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 entriesARead-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 watcherAIdempotent
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 watcherADestructiveIdempotent
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 verbADestructive
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 UXADestructive
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 schemaARead-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 namesARead-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 statusARead-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 timelineARead-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 trafficADestructive
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 trafficAIdempotent
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 selectADestructive
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 benchADestructive
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 voteADestructive
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 matchmakingADestructive
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 lobbyADestructive
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 essenceADestructive
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 checkAIdempotent
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 screenADestructive
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 pageADestructiveIdempotent
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 selectADestructiveIdempotent
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
Scored across 61 tools
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.
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.
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.
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
Related MCP Connectors
MCP server to assist with JxBrowser development.
Market data tools for the MCP ecosystem: server stats, events, search, leaderboards, package trends.
Unofficial Browserless MCP — wraps the Browserless headless-Chromium REST API (browserless.io)
Related MCP Servers
- AlicenseCqualityDmaintenanceAn 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.1212Apache 2.0
- AlicenseAqualityDmaintenanceProvides MCP tools to query Liquipedia esports data (matches, teams, players, tournaments, placements, standings) via the Liquipedia v3 API and MediaWiki action API.856 npmMIT
- FlicenseNot gradedqualityDmaintenanceProvides Roblox game inspection and manipulation capabilities through MCP, including exploring the instance hierarchy, editing properties, decompiling scripts, and interacting with remote events.1-
- AlicenseNot gradedqualityCmaintenanceEnables 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 npmMIT