Skip to main content
Glama

PCSX2 MCP

ENGLISH | KOREAN

PCSX2 MCP is a Windows-focused Model Context Protocol server for controlling and debugging PCSX2 through its EE and IOP GDB Remote Serial Protocol endpoints. It exposes emulator control, memory inspection, debugger operations, tracing, savestates, cheats, screenshots, process management, and log access as MCP tools.

IMPORTANT

Basic register and memory operations require PCSX2's GDB servers. Extended tools such as emulator commands, debugger expressions, cheat control, screenshots, and savestate automation require a compatible PCSX2 build that implements theqPcsx2 commands used by this server.

Features

  • Connect to the EE or IOP GDB server and inspect connection status.

  • Pause, resume, single-step, reset, and advance frames.

  • Read and write registers, memory, strings, and files.

  • Dump memory regions, search byte patterns with wildcards, and compare snapshots.

  • Disassemble code, evaluate debugger expressions, and inspect threads, modules, and backtraces.

  • Add, remove, list, and clear breakpoints and watchpoints.

  • Save and load states, capture screenshots, and maintain a rewind ring buffer.

  • Reload patches and list, enable, or disable cheats at runtime.

  • Record periodic register and memory traces to JSONL.

  • Launch, list, and terminate PCSX2 processes.

  • Locate, tail, and filter PCSX2 logs.

  • Capture and control PCSX2 while its window remains inactive.

  • Use native qPcsx2 input, an optional virtual XInput controller, or targeted keyboard messages.

Requirements

  • Windows

  • Python 3.10 or newer

  • PCSX2 with the EE/IOP GDB servers enabled

  • An MCP client that supports local stdio servers

The default endpoints are:

Target

Host

Port

EE

127.0.0.1

10501

IOP

127.0.0.1

10502

Installation

Open PowerShell in the repository directory:

python -m pip install -e .

Keyboard input has no extra dependency. Optional XInput support uses vgamepad and an installed ViGEmBus driver:

python -m pip install -e ".[xinput]"

Run the server directly:

python -m pcsx2_mcp

The server communicates over stdio, so it normally runs under an MCP client rather than in a standalone interactive terminal.

Codex MCP configuration

To register PCSX2 MCP as a local stdio server in Codex, add the following blocks to %USERPROFILE%\.codex\config.toml. Replace C:\path\to\PCSX2_MCP with the path where you cloned this repository.

[mcp_servers.pcsx2]
command = "python"
args = ["-m", "pcsx2_mcp"]
cwd = 'C:\path\to\PCSX2_MCP'

[mcp_servers.pcsx2.env]
PYTHONPATH = 'C:\path\to\PCSX2_MCP\src'

The python command must resolve to the interpreter where the project dependencies were installed. Restart Codex after changing config.toml.

PCSX2 setup

  1. Start the MCP server in your client.

  2. Run the configure_gdb_settings tool once, or enable the EE and IOP GDB servers manually in the compatible PCSX2 configuration.

  3. Restart PCSX2 after changing the GDB settings.

  4. Start a game, then call connect with target="ee" or target="iop".

  5. Call status or pcsx2_status before using debugging and automation tools.

Background capture and input

take_screenshot uses the custom qPcsx2 screenshot_file command when the GDB client is connected, so it captures the emulator render buffer without touching the desktop focus. When disconnected, PNG requests fall back to capture_pcsx2_window, which uses PrintWindow without restoring or activating the window.

configure_background_input preserves existing Pad 1 bindings and adds keyboard plus XInput mappings. Input tools accept backend="auto", "native", "keyboard", or "xinput". auto uses an already-connected EE or IOP qPcsx2 client first, then tries optional XInput, and finally falls back to targeted PostMessageW keyboard events when vgamepad or its driver is unavailable.

PCSX2's top-level Qt key filter may request activation. The MCP keyboard backend therefore sends only to a verified native render child. If that child cannot be identified, it returns an error instead of sending to the top-level window.

Typical workflow

  1. Use launch_pcsx2 or start PCSX2 yourself.

  2. Use connect for the required target.

  3. Inspect state with get_registers, read_memory, disassemble, or evaluate.

  4. Control execution with pause, step, resume, breakpoints, or watchpoints.

  5. Call disconnect before shutting down PCSX2.

Safety

This server can modify emulated memory, overwrite memory from a file, change registers, load savestates, control cheats, and terminate PCSX2 processes. Keep it bound to local MCP clients and review tool arguments before approving destructive operations.

Generated logs, screenshots, traces, rewind captures, virtual environments, bytecode, and build outputs are excluded from version control.

License

This project is distributed under the terms in LICENSE.

Available Tools

40 tools
clear_debug_breakpointsC

Clear all PCSX2 debugger breakpoints and watchpoints.

Inputs: target.

connectB

Connect to PCSX2's EE or IOP GDB server. PCSX2 pauses the VM on connect.

Inputs: host, port, target, auto_resume.

disassembleC

Disassemble guest instructions using PCSX2's native debugger disassembler.

Inputs: address (required), count, target.

disconnectC

Disconnect one GDB target.

Inputs: target.

dump_memoryC

Dump guest memory to a local file.

Inputs: length (required), address (required), file_path (required), target.

dump_regionB

Dump a named memory region. Use list_memory_regions for names.

Inputs: region (required), file_path (required).

evaluateC

Evaluate a PCSX2 debugger expression.

Inputs: expression (required), target.

find_patternC

Search guest memory for a hex pattern. Use ?? as a wildcard byte.

Inputs: pattern (required), end, start, target, +2 more.

frame_advanceC

Advance the VM by one or more frames and pause.

Inputs: frames, target.

get_debug_registersC

Return full-width PCSX2 debug registers through qPcsx2.

Inputs: target, category.

get_registersC

Return guest registers for EE or IOP.

Inputs: target.

list_breakpoint_kindsA

Return accepted breakpoint kind names and RSP types.

Inputs: no named parameters.

list_debug_breakpointsC

List PCSX2 debugger breakpoints and conditions.

Inputs: target.

list_memory_regionsA

List predefined dump regions.

Inputs: no named parameters.

list_tracesB

List active background traces.

Inputs: no named parameters.

list_watchpointsC

List PCSX2 debugger memory watchpoints.

Inputs: target.

load_state_fileB

Load a savestate from an explicit file path.

Inputs: file_path (required), target.

load_state_slotC

Load a PCSX2 savestate slot.

Inputs: slot (required), backup, target.

memory_diffA

Snapshot and diff a guest memory range. First call saves, second call compares and clears.

Inputs: length (required), address (required), name, reset, +1 more.

overwrite_memory_from_fileB

Overwrite guest memory with bytes read from a local file.

Inputs: address (required), file_path (required), target, max_bytes.

read_memoryC

Read guest memory as hex, base64, ascii, hexdump, or u32_array.

Inputs: length (required), address (required), target, as_format.

read_stringC

Read a null-terminated guest string.

Inputs: address (required), target, encoding, max_length.

remove_breakpointC

Remove a breakpoint or watchpoint.

Inputs: address (required), kind, size, target.

remove_debug_breakpointD

Remove a PCSX2 debugger breakpoint.

Inputs: address (required), target.

remove_watchpointC

Remove a PCSX2 debugger memory watchpoint.

Inputs: address (required), size, target.

resetC

Request a VM reset.

Inputs: target.

resumeC

Resume the VM.

Inputs: target.

sample_traceC

Take one timestamped register/memory sample.

Inputs: target, registers, memory_ranges.

save_state_slotC

Save a PCSX2 savestate slot synchronously.

Inputs: slot (required), target.

set_breakpointC

Set an exec/read/write/rw breakpoint or watchpoint.

Inputs: address (required), kind, size, target.

set_watchpointC

Set a PCSX2 debugger memory watchpoint.

Inputs: address (required), kind, size, action, +2 more.

start_rewind_captureB

Start periodic savestate capture into a ring buffer for rewind.

Inputs: slots, target, directory, rewind_id, +1 more.

start_traceC

Start background register/memory tracing, optionally writing JSONL records.

Inputs: trace_id (required), target, registers, interval_ms, +3 more.

statusA

Return MCP-side connection status for both EE and IOP.

Inputs: no named parameters.

stepC

Single-step one guest instruction and stop again.

Inputs: target.

take_screenshotB

Save the current PCSX2 render frame to an image file, even if the emulator window is inactive or minimized.

Inputs: target, file_path.

wait_savestate_flushC

Wait until async savestate compression has flushed.

Inputs: target.

write_debug_registerC

Write a full-width PCSX2 debug register by category and index.

Inputs: index (required), value (required), category (required), target.

write_memoryC

Overwrite guest memory with hex bytes.

Inputs: address (required), data_hex (required), target.

write_registerC

Overwrite one register by name or numeric index.

Inputs: value (required), register (required), target.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    C2.7/5.0

    Scored across 40 tools

    Disambiguation3/5

    There is noticeable overlap between breakpoint and watchpoint tools, with two sets (regular and debug) that could confuse. Tools like set_breakpoint and set_watchpoint have similar purposes, and distinctions are not always clear. Most other tools are well-separated.

    Naming Consistency4/5

    Most tools follow a verb_noun pattern with underscores (e.g., read_memory, set_breakpoint). However, a few tools use standalone nouns (status) or noun_verb (memory_diff), and verbs vary (get vs read, set vs write). Overall consistent but with minor deviations.

    Tool Count3/5

    With 40 tools, the surface is quite large. While the PCSX2 domain is complex, several groups (e.g., 9 breakpoint tools, 9 memory tools) could potentially be consolidated. The count is on the high side but still manageable for a full-featured debugger server.

    Completeness4/5

    The tools cover connection, control, savestates, registers, disassembly, memory, breakpoints, tracing, and rewind, which is comprehensive. However, a tool to list active non-debug breakpoints is missing, and there is no way to query emulation state (paused/running). Minor gaps but overall solid.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      An MCP server for debugging Windows processes using WinDbg and CDB. It enables users to attach to processes, manage breakpoints, inspect memory, and control execution flow through natural language.
      2
      -
    • A
      license
      B
      quality
      D
      maintenance
      An MCP server providing direct access to gdb-multiarch for debugging Nintendo Switch executables on Yuzu or hardware via a GDB stub. It features specialized tools for offset-based breakpoints, instruction patching, and frame-pointer backtraces relative to the game's base address.
      33
      3
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      MCP server for PCSX2 and other emulators that speak the PINE protocol. Read and write 8/16/32/64-bit emulator memory and control save states for PlayStation-family emulation.
      14
      31 npm
      3
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server for remote debugging with gdbserver, offering full debugging capabilities including breakpoint control, stepping, memory inspection, and process management.
      30 PyPI
      MIT