Content
# cep-mcp
**Model Context Protocol server for Cheat Engine** — Expose CE's complete debugging and memory manipulation toolkit to AI agents via native MCP transport.
[](https://github.com)
[](https://isocpp.org)
[](https://modelcontextprotocol.io)
[](LICENSE)
[](scripts/test-all-tools.ps1)
## Overview
**cep-mcp** is a production-grade MCP (Model Context Protocol) server implementation that runs as a **Cheat Engine plugin DLL**. It bridges the gap between AI agents and low-level debugging capabilities by exposing **106 tools** across 18 families—from memory scanning and pointer chain analysis to Lua scripting and code injection.
This project enables AI agents to perform complex debugging workflows that would typically require manual CE interaction: hunting for memory addresses, analyzing pointer structures, setting hardware breakpoints, injecting code, and automating iterative scan operations—all through natural language prompts.
### Key Capabilities
- ✅ **Native MCP Protocol**: Full JSON-RPC 2.0 implementation over streamable HTTP
- ✅ **106 Tools Across 18 Families**: Memory R/W, scanning (exact/AOB/pattern), pointer chains, disassembly, debugger control (breakpoints/registers), address list management, structure dissection, Lua scripting, code/DLL injection, analysis workflows
- ✅ **Production-Ready Architecture**: Multi-threaded worker pool, job system for async operations, crash guards, rate limiting, CORS security
- ✅ **Zero Configuration**: Auto-loads as CE plugin, no setup required beyond DLL copy
- ✅ **Delegated Security Model**: All tools enabled by default; access control via CE UI checkboxes (attach/debug/write/inject)
- ✅ **Comprehensive Testing**: 104 PASS / 0 FAIL / 7 SKIP (architectural limits documented)
- ✅ **AI Agent Optimized**: Natural language → tool calls → structured results with detailed error handling
### Use Cases
**For AI Agents:**
- *"Find all pointers to player health address"* → Automated pointer scan + chain validation
- *"What code writes to 0x12345678?"* → Hardware write breakpoint + instruction analysis
- *"Inject safe shellcode to patch function return value"* → Code injection + verification
- *"Execute Lua: scan 4-byte integer 100, filter by changed value"* → Multi-step scan workflow
**For Developers:**
- Automated memory pattern hunting in game binaries
- AI-assisted reverse engineering workflows
- Batch processing of memory dumps and pointer structures
- Integration with existing MCP-compatible AI agents (Claude Desktop, etc.)
---
## Table of Contents
- [Architecture](#architecture)
- [System Architecture](#system-architecture)
- [Request Flow](#request-flow)
- [Threading Model](#threading-model)
- [Tool Dispatch Pipeline](#tool-dispatch-pipeline)
- [Quick Start](#quick-start)
- [Tool Families](#tool-families-106-tools)
- [Configuration](#configuration)
- [Security Model](#security-model)
- [Building from Source](#building-from-source)
- [Testing](#testing)
- [Troubleshooting](#troubleshooting)
- [Contributing](#contributing)
---
## Architecture
### System Architecture
The following diagram illustrates the complete system architecture from AI agent to target process:
```mermaid
graph TB
subgraph "AI Agent Layer"
Agent[AI Agent<br/>MCP Client<br/>Claude Desktop, etc.]
end
subgraph "HTTP Transport Layer"
Agent -->|JSON-RPC 2.0<br/>HTTP POST| HTTP[HTTP Server<br/>:28015/mcp<br/>SSE Support]
end
subgraph "MCP Protocol Layer"
HTTP --> Router{MCP Router}
Router -->|initialize| Init[Initialization<br/>Handler]
Router -->|tools/list| List[Tool List<br/>Handler]
Router -->|tools/call| Dispatch[Tool Dispatch<br/>Router]
Router -->|resources/*| Res[Resource<br/>Handlers]
end
subgraph "Execution Layer"
Dispatch --> Queue[Worker Pool<br/>4 Threads<br/>Concurrent Execution]
Queue --> Workers[Worker Thread 1-4]
Workers --> Limiter[Rate Limiter<br/>Token Bucket]
Limiter --> Cancel[Cancellation<br/>Registry]
end
subgraph "Tool Layer - 18 Families (106 Tools)"
Cancel --> Config[Config<br/>3 tools]
Cancel --> Proc[Process<br/>3 tools]
Cancel --> Mem[Memory<br/>13 tools]
Cancel --> Scan[Scan<br/>15 tools]
Cancel --> Ptr[Pointer<br/>8 tools]
Cancel --> Mod[Module<br/>7 tools]
Cancel --> Disasm[Disassembly<br/>9 tools]
Cancel --> Debug[Debugger<br/>11 tools]
Cancel --> Addr[AddressList<br/>13 tools]
Cancel --> Struct[Structure<br/>6 tools]
Cancel --> Region[Regions<br/>9 tools]
Cancel --> Lua[Lua<br/>7 tools]
Cancel --> Job[Jobs<br/>3 tools]
Cancel --> Adv[Advanced<br/>6 tools]
Cancel --> Inject[Injection<br/>4 tools]
Cancel --> Pattern[Pattern<br/>3 tools]
Cancel --> Analysis[Analysis<br/>8 tools]
Cancel --> Iter[Iterative<br/>3 tools]
end
subgraph "Cheat Engine Integration"
Config --> LuaExec[Lua Executor<br/>Single Mutex<br/>Thread-Safe]
Proc --> LuaExec
Mem --> LuaExec
Scan --> LuaExec
Ptr --> LuaExec
Mod --> LuaExec
Disasm --> LuaExec
Debug --> LuaExec
Addr --> LuaExec
Struct --> LuaExec
Region --> LuaExec
Lua --> LuaExec
Job --> JobRegistry[Job Registry<br/>Async Tracking]
Adv --> LuaExec
Inject --> LuaExec
Pattern --> LuaExec
Analysis --> LuaExec
Iter --> LuaExec
LuaExec --> SDK[CE SDK<br/>ce_sdk.h<br/>Thread-Safe APIs]
JobRegistry --> SDK
end
subgraph "Target Layer"
SDK --> Target[Target Process<br/>Memory Space<br/>e.g. Tutorial-x86_64.exe]
end
```
**Architecture Highlights:**
1. **HTTP Transport Layer**: Lightweight HTTP server on localhost:28015, supports both regular HTTP and Server-Sent Events (SSE) for streaming responses
2. **MCP Protocol Layer**: Full MCP specification compliance with JSON-RPC 2.0 message framing
3. **Execution Layer**: Multi-threaded worker pool with rate limiting and cancellation support
4. **Tool Layer**: 106 tools organized into 18 logical families with consistent error handling
5. **CE Integration**: Single-mutex Lua executor ensures thread-safe CE API access
6. **Job System**: Async operation tracking for long-running scans and pointer chain searches
### Request Flow
Complete lifecycle of an MCP tool call from agent to result:
```mermaid
sequenceDiagram
participant Agent as AI Agent<br/>(MCP Client)
participant HTTP as HTTP Server<br/>:28015
participant Router as MCP Router
participant Rate as Rate Limiter
participant Worker as Worker Thread
participant Tool as Tool Handler
participant Lua as Lua Executor
participant CE as CE SDK
participant Process as Target Process
Agent->>HTTP: POST /tools/call<br/>{method:"tools/call", params:{name:"scan_exactValue", arguments:{...}}}
HTTP->>Router: Parse JSON-RPC
Router->>Router: Validate Request<br/>- Check method<br/>- Validate tool name<br/>- Parse arguments
alt Invalid Request
Router-->>HTTP: Error Response<br/>{error:{code:-32600, message:"Invalid Request"}}
HTTP-->>Agent: HTTP 400
else Valid Request
Router->>Rate: Check Rate Limit
alt Rate Limit Exceeded
Rate-->>Router: Reject
Router-->>HTTP: Error Response<br/>{error:{code:429, message:"Too Many Requests"}}
HTTP-->>Agent: HTTP 429
else Within Limit
Rate->>Worker: Enqueue Task
Worker->>Tool: Execute Tool Handler
Tool->>Tool: Validate Arguments<br/>- Type checking<br/>- Range validation<br/>- Required fields
alt Invalid Arguments
Tool-->>Worker: Validation Error
Worker-->>Router: Error Result
Router-->>HTTP: Error Response
HTTP-->>Agent: HTTP 200 + Error
else Valid Arguments
Tool->>Lua: Request Lua Execution<br/>Lock mutex
Lua->>CE: Call CE SDK APIs<br/>e.g. memscan.firstScan(...)
CE->>Process: Scan Target Memory
Process-->>CE: Memory Contents
CE-->>Lua: Scan Results
Lua-->>Tool: Unlock mutex<br/>Return results
Tool->>Tool: Format Response<br/>- Convert to JSON schema<br/>- Add metadata
Tool-->>Worker: Success Result
Worker-->>Router: Response
Router-->>HTTP: JSON-RPC Result<br/>{result:{addresses:[...], count:42}}
HTTP-->>Agent: HTTP 200 + JSON
end
end
end
Note over Agent,Process: Total latency: ~10-500ms depending on operation
```
**Key Flow Details:**
- **Request Parsing**: Strict JSON-RPC 2.0 validation with detailed error codes
- **Rate Limiting**: Token bucket algorithm per-session to prevent abuse
- **Worker Pool**: 4 concurrent threads handle multiple tool calls in parallel
- **Lua Mutex**: Single lock ensures CE API thread safety (CE Lua engine is single-threaded)
- **Error Propagation**: Errors at any layer are caught, logged, and returned as structured JSON-RPC errors
### Threading Model
Detailed view of concurrent execution architecture:
```mermaid
graph LR
subgraph "Main Thread"
Main[Plugin DLL Load<br/>PluginInit]
end
Main --> Server[HTTP Server Thread<br/>Accept Loop]
Server --> Pool[Worker Pool<br/>Task Queue]
subgraph "Worker Threads (4)"
Pool --> W1[Worker 1<br/>Tool Execution]
Pool --> W2[Worker 2<br/>Tool Execution]
Pool --> W3[Worker 3<br/>Tool Execution]
Pool --> W4[Worker 4<br/>Tool Execution]
end
subgraph "Synchronization"
W1 --> Mutex{Lua Executor<br/>std::mutex}
W2 --> Mutex
W3 --> Mutex
W4 --> Mutex
Mutex --> LuaExec[CE Lua State<br/>Single-threaded]
end
subgraph "Cheat Engine SDK"
LuaExec --> SDK[CE APIs<br/>Thread-Safe:<br/>- readInteger<br/>- writeBytes<br/>- memscan<br/>- disassemble]
SDK --> Unsafe[CE APIs<br/>Non-Thread-Safe:<br/>- addresslist<br/>- form controls<br/>- GUI updates]
end
subgraph "Job System"
W1 --> Jobs[Job Registry<br/>std::shared_mutex<br/>Async Operations]
W2 --> Jobs
W3 --> Jobs
W4 --> Jobs
Jobs --> BG[Background Jobs<br/>- Pointer scans<br/>- Structure analysis<br/>- Pattern matching]
end
SDK --> Process[Target Process<br/>Memory Access]
Unsafe --> Process
BG --> Process
```
**Threading Strategy:**
1. **Main Thread**: Plugin initialization only (minimal work)
2. **HTTP Server Thread**: Accepts connections, parses JSON-RPC, returns responses
3. **Worker Pool (4 threads)**: Execute tool handlers concurrently
4. **Lua Executor Mutex**: Serializes all CE API calls to prevent race conditions
5. **Job System**: Separate thread pool for async operations (pointer scans, etc.)
**Thread Safety Guarantees:**
- ✅ **Memory R/W tools**: Thread-safe (CE SDK handles synchronization)
- ✅ **Scan tools**: Thread-safe with internal locking
- ✅ **Pointer tools**: Thread-safe (isolated scan states)
- ⚠️ **Address list tools**: Mutex-protected (CE GUI state)
- ⚠️ **Lua tools**: Single mutex (CE Lua engine is single-threaded)
- ✅ **Job system**: Shared mutex with reader-writer lock
### Tool Dispatch Pipeline
Detailed flow from tool name to execution:
```mermaid
flowchart TD
Start[Receive tools/call Request] --> Parse[Parse JSON-RPC]
Parse --> Validate{Valid Request?}
Validate -->|No| Err1[Error: Invalid Request -32600]
Validate -->|Yes| FindTool{Tool Exists?}
FindTool -->|No| Err2[Error: Method Not Found -32601]
FindTool -->|Yes| Route[Route to Tool Family Handler]
Route --> Handler[18 Tool Family Handlers:<br/>Config, Process, Memory, Scan<br/>Pointer, Module, Disassembly<br/>Debugger, AddressList, Structure<br/>Regions, Lua, Job, Advanced<br/>Injection, Pattern, Analysis, Iterative]
Handler --> ValidateArgs{Validate Arguments?}
ValidateArgs -->|Invalid| Err3[Error: Invalid Params -32602]
ValidateArgs -->|Valid| Guard[Crash Guard Wrapper]
Guard --> Exec[Execute Tool Logic<br/>via CE SDK APIs]
Exec --> CheckResult{Execution Result?}
CheckResult -->|Exception| Err4[Error: Internal Error -32603]
CheckResult -->|CE Error| Err5[Error: CE API Failed + Message]
CheckResult -->|Success| Format[Format JSON Response<br/>Add Metadata]
Format --> Return[Return Result to Agent]
Return --> End[Complete]
Err1 --> End
Err2 --> End
Err3 --> End
Err4 --> End
Err5 --> End
```
**Tool Family Routing Table:**
| Prefix | Handler | Example Tools |
|--------|---------|---------------|
| `config_*` | Config Handler | getServerStatus, getConfiguration, setConfiguration |
| `process_*` | Process Handler | getProcessList, attachToProcess, getAttachedProcess |
| `memory_*` | Memory Handler | readInteger, writeBytes, readString, getPointerSize |
| `scan_*` | Scan Handler | scanExactValue, scanAOB, searchString, getResults |
| `pointer_*` | Pointer Handler | findPointerChains, validatePointer, getPointerValue |
| `module_*` | Module Handler | getModuleList, getModuleInfo, getExportList |
| `disassemble_*` | Disassembly Handler | disassemble, assemble, getInstructionSize |
| `debugger_*` | Debugger Handler | setBreakpoint, debugContinue, getRegisters |
| `addresslist_*` | AddressList Handler | getAddressList, addAddress, setAddressFrozen |
| `structure_*` | Structure Handler | dissectStructure, getStructureInfo, saveStructure |
| `regions_*` | Regions Handler | getMemoryRegions, changeProtection, allocateMemory |
| `lua_*` | Lua Handler | executeScript, loadLuaFile, executeLuaAsync |
| `job_*` | Job Handler | getJobStatus, getJobResult, cancelJob |
| `advanced_*` | Advanced Handler | setSpeed, setPointerSize, getAddressFromSymbol |
| `injection_*` | Injection Handler | injectDll, executeCode, injectAOB, createThread |
| `pattern_*` | Pattern Handler | scanPatternCE, scanPatternIDA, scanPatternCode |
| `analysis_*` | Analysis Handler | findWhatAccesses, findWhatWrites, analyzeFunction |
| `iterative_*` | Iterative Handler | iterativeScanStart, iterativeScanNext |
**Dispatch Logic:**
1. **Request Parsing**: Extract tool name and arguments from JSON-RPC payload
2. **Tool Lookup**: Fast O(1) hash table lookup by tool name
3. **Family Routing**: Group tools by prefix (config_*, memory_*, etc.) for organized handlers
4. **Argument Validation**: Schema-based validation with type checking and required field verification
5. **Crash Guard**: Exception wrapper catches CE crashes and converts to structured errors
6. **Result Formatting**: Convert CE API results to standardized JSON schemas
7. **Error Propagation**: All errors follow JSON-RPC 2.0 error code conventions
---
### 1. Installation
**Prerequisites:**
- Windows 10/11 (x64 or x86)
- [Cheat Engine 7.5+](https://cheatengine.org)
- Target process for testing (e.g., `Tutorial-x86_64.exe` bundled with CE)
**Install Plugin:**
```powershell
# Download latest release
# https://github.com/YOUR_ORG/cep-mcp/releases
# Extract DLL (match your CE architecture: x64 or x86)
# Copy to CE autorun folder
Copy-Item cep-mcp_x64.dll "C:\Program Files\Cheat Engine 7.5\autorun\"
# Optional: Copy config (defaults work fine)
Copy-Item cep-mcp.ini "C:\Program Files\Cheat Engine 7.5\autorun\"
# Restart Cheat Engine
```
**Verify Installation:**
- Launch Cheat Engine
- Server auto-starts on **http://127.0.0.1:28015/mcp**
- Open browser: **http://127.0.0.1:28015/health** → Should return "healthy"
### 2. Connect AI Agent
**Add MCP Server to Agent Config:**
```json
{
"mcpServers": {
"cep-mcp": {
"command": "echo",
"args": ["Using existing HTTP transport"],
"transport": {
"type": "http",
"url": "http://localhost:28015/mcp"
}
}
}
}
```
**Verify Connection:**
- Attach CE to any process (e.g., `Tutorial-x86_64.exe`)
- Ask agent: *"List available MCP tools from cep-mcp"*
- Expected: **106 tools** across 18 families
### 3. Test Tools
**Automated Test Suite:**
```powershell
# Auto-detects CE path, launches Tutorial, tests all 106 tools
.\scripts\test-all-tools.ps1
# Expected output:
# ✅ Config Family: 3/3 tools PASS
# ✅ Process Family: 3/3 tools PASS
# ✅ Memory Scan Family: 15/15 tools PASS
# ... (18 families total)
# 🎉 Test Summary: 104 PASS / 0 FAIL / 7 SKIP
```
**Manual Agent Testing:**
See **[docs/agent-testing.md](docs/agent-testing.md)** for complete 7-phase test plan with 106 tool call examples.
---
## Architecture
### System Overview
```
┌─────────────┐ JSON-RPC/HTTP ┌──────────────────┐
│ AI Agent │ ──────────────────────────────▶│ HTTP Server │
│ (MCP Client)│ :28015/mcp │ (Port 28015) │
└─────────────┘ └────────┬─────────┘
│
┌────────▼─────────┐
│ MCP Router │
│ - initialize │
│ - tools/list │
│ - tools/call │
└────────┬─────────┘
│
┌────────▼─────────┐
│ Worker Pool │
│ (4 threads) │
└────────┬─────────┘
│
┌────────────────────────────────────┼────────────────────────┐
│ │ │
┌────────▼─────┐ ┌─────────▼──────┐ ┌──────────▼──────┐
│ 106 Tools │ │ Job System │ │ Lua Executor │
│ - Memory R/W │ │ - Async ops │ │ (Single mutex) │
│ - Scanning │ │ - Status poll │ │ │
│ - Pointers │ │ - Cancellation│ │ │
│ - Debugger │ └────────────────┘ └─────────────────┘
│ - Injection │
│ - Analysis │
└──────┬───────┘
│
┌────────▼──────────┐
│ Cheat Engine SDK │
│ (ce_sdk.h) │
└────────┬──────────┘
│
┌────────▼──────────┐
│ Target Process │
│ (e.g. Tutorial) │
└───────────────────┘
```
### Threading Model
- **HTTP Server Thread**: Accepts connections, parses JSON-RPC
- **Worker Pool (4 threads)**: Execute tool handlers concurrently
- **Lua Executor**: Single mutex prevents race conditions in `lua_*` tools
- **CE SDK**: Most APIs thread-safe (documented in `ce_sdk.h`)
### Security Model
cep-mcp **does not** implement tool-level security categories or governance rules. All 106 tools are enabled by default.
**Access Control Delegation:**
1. **Cheat Engine UI**: Attach/Debugger/Injection checkboxes control capabilities
2. **CORS Policy** (`cep-mcp.ini`): Validates `Origin` header (default: localhost only)
3. **User Privileges**: Agent runs as same user with same CE permissions
**Why No Guardrails?**
- CE is a *debugging tool* for *local development/game modding*
- User *already has admin privileges* to run CE and attach to processes
- Tool restrictions would add complexity without security gain
- CE UI provides intuitive, visual boundaries
---
## Tool Families (106 Tools)
| Family | Tools | Description |
|--------|-------|-------------|
| **Config** | 3 | Server status, configuration management |
| **Process** | 3 | Process list, attach, detach |
| **Memory** | 13 | Read/write integers, floats, strings, bytes, pointers |
| **MemoryRegions** | 9 | Region info, protection, allocate/free |
| **Scan** | 15 | Exact value, AOB, pattern, string search |
| **Pointer** | 8 | Pointer chain finder, validation |
| **Module** | 7 | Module list, symbols, exports |
| **Disassembly** | 9 | Disassemble, assemble, code info |
| **Debugger** | 11 | Breakpoints, step, registers, continue |
| **AddressList** | 10 | Add/remove/freeze addresses |
| **AddressListAdv** | 3 | Set value, freeze state, remove record |
| **Table** | 4 | Save/load table, clear, get name |
| **Structure** | 6 | Dissect memory structures |
| **Lua** | 4 | Execute Lua scripts, get state |
| **LuaAdv** | 3 | Load files, execute async |
| **Job** | 3 | Query job status/result, cancel |
| **Advanced** | 6 | Speed hack, pointer size, symbol resolution |
| **Injection** | 4 | DLL injection, code execution, AOB injection |
| **Pattern** | 3 | Pattern scanning (CE/IDA/Code signatures) |
| **Analysis** | 8 | Code analysis, references, function boundaries, RTTI |
| **Iterative** | 3 | Iterative scan workflows |
**Total: 106 tools** | **Test Coverage: 104 PASS / 0 FAIL / 7 SKIP** (architectural limits documented)
---
## Configuration
**Default Config** (`cep-mcp.ini`):
```ini
[server]
port = 28015
host = 127.0.0.1
max_sessions = 10
log_level = info
[security]
allow_localhost = true
allowed_origins =
[performance]
worker_threads = 4
request_timeout_ms = 30000
[job]
max_concurrent_jobs = 10
default_timeout_ms = 300000
```
**Log Levels**: `trace`, `debug`, `info`, `warn`, `error`, `critical`
**CORS Origins**: Comma-separated origins (e.g., `http://localhost:3000,http://127.0.0.1:5173`)
---
## Building from Source
See **[docs/build-guide.md](docs/build-guide.md)** for complete build instructions.
**Quick Build:**
```powershell
# Prerequisites: Visual Studio 2022, CMake 3.20+
# Configure (x64 Release)
cmake --preset x64
# Build
cmake --build --preset x64-release
# Run Tests
ctest --preset x64-release --output-on-failure
# Output: build/bin/Release/cep-mcp_x64.dll
```
---
## Testing
### Automated Test Suite
**Full Test (106 tools):**
```powershell
.\scripts\test-all-tools.ps1
# Expected: 104 PASS / 0 FAIL / 7 SKIP
# 7 SKIPs: Architectural limitations (Jobs API, RTTI, AddressList timing)
```
**Quick Test (Essential tools only):**
```powershell
.\scripts\test-all-tools.ps1 -Quick
# Tests: Config, Process, Memory, Scan (48 tools)
# Expected: ~45 PASS
```
### Manual Testing with AI Agent
See **[docs/agent-testing.md](docs/agent-testing.md)** for comprehensive test plan:
- Phase 1: Connection & Config (3 tools)
- Phase 2: Process & Memory (16 tools)
- Phase 3: Scanning & Pointers (23 tools)
- Phase 4: Disassembly & Debugger (20 tools)
- Phase 5: Address Lists & Tables (14 tools)
- Phase 6: Lua & Advanced (10 tools)
- Phase 7: Injection & Analysis (20 tools)
**Example Agent Prompts:**
```
"Attach to Tutorial-x86_64.exe and scan for integer value 100"
"Find what writes to address 0x12345678"
"Inject safe shellcode: mov rax, 42; ret"
"Execute Lua: print(readInteger('Tutorial-x86_64.exe+12345678'))"
```
---
## Troubleshooting
**Problem**: Server not starting (port 28015 in use)
```powershell
# Check if another process is using port 28015
netstat -ano | findstr :28015
# Kill process or change port in cep-mcp.ini
```
**Problem**: Agent can't connect (CORS error)
- Add agent origin to `allowed_origins` in `cep-mcp.ini`
- Or set `allow_localhost=true` for local testing
**Problem**: Tools return "Process not attached"
- Attach CE to target process first (File → Open Process)
- Verify with agent: `callTool("getAttachedProcess")`
**Problem**: Lua tools timeout
- Increase `request_timeout_ms` in `cep-mcp.ini`
- Check CE Lua engine state (open Lua script window in CE)
**Problem**: Tests fail with "CE not running"
- Ensure CE is installed at default path
- Or run `.\scripts\test-all-tools.ps1 -CePath "C:\Custom\Path\cheatengine-x86_64.exe"`
---
## Contributing
Contributions welcome! Please:
1. Follow existing code style (clang-format provided)
2. Add unit tests for new tools (`tests/`)
3. Update documentation (`docs/`)
4. Run full test suite before PR
---
## License
MIT License - See [LICENSE](LICENSE) for details.
---
## Links
- **Documentation**: [docs/](docs/)
- **MCP Specification**: [Model Context Protocol](https://modelcontextprotocol.io)
- **Cheat Engine**: [cheatengine.org](https://cheatengine.org)
---
## Credits
Built with:
- [Cheat Engine SDK](https://github.com/cheat-engine/cheat-engine) - Memory debugging framework
- [nlohmann/json](https://github.com/nlohmann/json) - JSON parsing
- [Catch2](https://github.com/catchorg/Catch2) - Unit testing framework
Special thanks to the Cheat Engine community for extensive testing and feedback.
