de en es ja ko ru zh

renderdoc-mcp

Name: renderdoc-mcp
Author: fjxyyzg3

by fjxyyzg3

Overview Schema Related Servers Score Discussions

Python

Local

renderdoc-mcp

$\Large\color{#ff69b4}{\textsf{Este es un proyecto personal }}$ $\Large\color{#ff69b4}{\mathtt{✨ vibe\text{-}coding ✨}}$ $\Large\color{#ff69b4}{\textsf{—}}$ $\Large\color{#ff69b4}{\textsf{hecho por diversión, no para uso en producción.}}$

$\small\color{gray}{\textsf{No tengo idea de por qué este repo tiene tantas estrellas...}}$

Servidor MCP para RenderDoc: permite que los asistentes de IA analicen capturas de frames de GPU (archivos .rdc) para depuración gráfica y análisis de rendimiento.

Construido sobre el Model Context Protocol, funciona con Claude Desktop, Claude Code y cualquier cliente compatible con MCP.

Características

42 herramientas que cubren el flujo de trabajo completo de análisis de RenderDoc
10 herramientas de alto nivel para análisis con una sola llamada (estado de draw call, resumen de frame, diff, exportación por lotes, muestreo de regiones de píxeles, etc.)
3 prompts integrados para depuración guiada
Salida legible para humanos: modos de blend, funciones de profundidad, topología mostradas como nombres, no como números
Detección de peculiaridades de GPU: identifica automáticamente problemas específicos de Adreno/Mali/PowerVR/Apple a partir del nombre del driver
Headless: no se necesita GUI, se ejecuta completamente mediante la API de replay de Python de RenderDoc
Python puro: un solo pip install, sin paso de compilación
Compatible con capturas D3D11, D3D12, OpenGL, Vulkan, OpenGL ES

Inicio rápido

1. Requisitos previos

Python 3.10+
RenderDoc instalado (descarga)
- Necesitas el módulo de Python renderdoc.pyd (Windows) o renderdoc.so (Linux)
- Se incluye con cada instalación de RenderDoc

2. Instalación

git clone https://github.com/Linkingooo/renderdoc-mcp.git
cd renderdoc-mcp
pip install -e .

3. Encuentra la ruta de tu `renderdoc.pyd`

El módulo de Python está en tu directorio de instalación de RenderDoc:

Plataforma	Ruta típica
Windows	`C:\Program Files\RenderDoc\renderdoc.pyd`
Linux	`/usr/lib/renderdoc/librenderdoc.so` o donde lo compilaste

Necesitas el directorio que contiene este archivo.

4. Configura tu cliente MCP

Edita claude_desktop_config.json (Configuración → Desarrollador → Editar configuración):

{
  "mcpServers": {
    "renderdoc": {
      "command": "python",
      "args": ["-m", "renderdoc_mcp"],
      "env": {
        "RENDERDOC_MODULE_PATH": "C:\\Program Files\\RenderDoc"
      }
    }
  }
}

Añade a .claude/settings.json:

{
  "mcpServers": {
    "renderdoc": {
      "command": "python",
      "args": ["-m", "renderdoc_mcp"],
      "env": {
        "RENDERDOC_MODULE_PATH": "C:\\Program Files\\RenderDoc"
      }
    }
  }
}

# Set the module path
export RENDERDOC_MODULE_PATH="/path/to/renderdoc"   # Linux/macOS
set RENDERDOC_MODULE_PATH=C:\Program Files\RenderDoc  # Windows

# Run
python -m renderdoc_mcp

Ejemplos de uso

Una vez configurado, solo habla con tu asistente de IA:

"Abre frame.rdc y muéstrame qué está pasando en el frame"

"Encuentra el draw call que renderiza el modelo del personaje y comprueba su estado de pipeline"

"¿Por qué mi shadow map se renderiza en negro? Comprueba el pase de profundidad"

"Analiza el rendimiento: ¿hay draw calls redundantes?"

Flujo de herramientas típico

open_capture("frame.rdc")                     # Load the capture
├── get_capture_info()                         # API, GPU, known_gpu_quirks
├── get_frame_overview()                       # Frame-level stats and render passes
├── get_draw_call_state(142)                   # Complete draw call state in one call
├── diff_draw_calls(140, 142)                  # Compare two draw calls (with implications)
├── export_draw_textures(142, "./tex/")        # Batch export all bound textures
├── save_render_target(142, "./rt.png")        # Save render target snapshot
├── analyze_render_passes()                    # Auto-detect render pass boundaries
├── find_draws(blend=True, min_vertices=1000)  # Search by rendering state
├── sample_pixel_region(rt_id, 0,0,512,512)   # Scan RT region for NaN/Inf/negatives
├── pixel_history(id, 512, 384)               # Debug a specific pixel
├── export_mesh(142, "./mesh.obj")             # Export mesh as OBJ
└── close_capture()                            # Clean up

Para análisis de rendimiento y diagnóstico:

get_pass_timing(granularity="pass")      # Find most expensive render passes
analyze_overdraw()                        # Fill-rate pressure estimate
analyze_bandwidth()                       # Memory bandwidth estimate
analyze_state_changes()                   # Batching opportunities
diagnose_negative_values()               # Find NaN/Inf/negative color values (爆闪)
diagnose_precision_issues()              # R11G11B10, D16, SRGB mismatches
diagnose_reflection_mismatch()           # Reflection artifact diagnosis
diagnose_mobile_risks()                  # Comprehensive mobile GPU risk check

Para inspección de bajo nivel, todas las herramientas granulares siguen disponibles:

set_event(142)                                    # Navigate to a draw call
├── get_pipeline_state()                          # Inspect rasterizer/blend/depth
├── get_shader_bindings("pixel")                  # Check what textures/buffers are bound
├── get_cbuffer_contents("pixel", 0, filter="ibl") # Read shader constants (filterable)
├── disassemble_shader("pixel", search="SampleSH") # Shader code with context search
└── save_texture(id, "rt.png")                    # Export a specific texture

Herramientas

Gestión de sesión (4)

Herramienta	Descripción
`open_capture`	Abre un archivo `.rdc` (cierra automáticamente el anterior)
`close_capture`	Cierra la captura actual y libera recursos
`get_capture_info`	Metadatos de la captura: API, número de acciones, resolución, known_gpu_quirks (Adreno/Mali/PowerVR/Apple)
`get_frame_overview`	Estadísticas a nivel de frame: recuento de acciones por tipo, memoria de texturas/buffers, render targets, resolución

Navegación de eventos (5)

Herramienta	Descripción
`list_actions`	Lista el árbol de draw calls / acciones: admite `filter` (subcadena de nombre) y `event_type` (draw/clear/copy…)
`get_action`	Detalle completo de una sola acción
`set_event`	Navega a un evento (requerido antes de consultas de pipeline)
`search_actions`	Busca por patrón de nombre y/o flags de acción
`find_draws`	Busca draw calls por estado de renderizado: blend, vértices mínimos, vinculación de textura/shader/RT

Inspección de pipeline (4)

Herramienta	Descripción
`get_pipeline_state`	Estado completo: topología, viewports, rasterizer, blend, profundidad, stencil (enums legibles)
`get_shader_bindings`	Constant buffers, SRVs, UAVs, samplers para una etapa de shader
`get_vertex_inputs`	Atributos de vértice, vinculaciones de vertex/index buffer
`get_draw_call_state`	Análisis de draw en una llamada: información de acción, fórmula de blend, profundidad, stencil, rasterizer, texturas con tamaños, RTs, shaders

Análisis de recursos (4)

Herramienta	Descripción
`list_textures`	Todas las texturas (filtrable por formato, ancho mínimo)
`list_buffers`	Todos los buffers (filtrable por tamaño mínimo)
`list_resources`	Todos los recursos nombrados (filtrable por tipo, patrón de nombre)
`get_resource_usage`	Qué eventos leen/escriben un recurso

Extracción de datos (8)

Herramienta	Descripción
`save_texture`	Exporta a PNG, JPG, BMP, TGA, HDR, EXR o DDS
`get_buffer_data`	Lee bytes del buffer (volcado hexadecimal o array float32)
`pick_pixel`	Valor RGBA en una coordenada
`get_texture_stats`	Mín/máx/promedio por canal con detección de anomalías (NaN/Inf/negativos); admite `all_slices` para cubemaps
`read_texture_pixels`	Lee una región rectangular de píxeles (hasta 64×64) con flags de anomalía por píxel
`export_draw_textures`	Exportación por lotes de todas las texturas vinculadas a un draw call (nombres automáticos, omite placeholders)
`save_render_target`	Guarda una instantánea del RT en un evento (color + profundidad opcional)
`export_mesh`	Exporta la malla como OBJ con posiciones, normales, UVs a partir de datos post-VS

Análisis de shaders (3)

Herramienta	Descripción
`disassemble_shader`	Desensamblado de shader con cadena de fallback automática; admite `search` (palabra clave + contexto) y `line_range`
`get_shader_reflection`	Firmas de entrada/salida, diseño de vinculación de recursos
`get_cbuffer_contents`	Valores reales de las variables del constant buffer; admite `filter` para subcadena del nombre de variable

Avanzado (6)

Herramienta	Descripción
`pixel_history`	Historial completo de modificaciones por píxel en todos los eventos
`get_post_vs_data`	Datos de vértices post-transformación (VS out / GS out)
`diff_draw_calls`	Compara dos draw calls: muestra diferencias de estado con implicaciones legibles
`analyze_render_passes`	Detecta automáticamente los límites de los render passes mediante cambios de Clear/RT, resume cada pase
`sample_pixel_region`	Escaneo de cuadrícula uniforme de una región de RT: detecta puntos críticos NaN/Inf/negativos/sobreexpuestos
`debug_shader_at_pixel`	Depuración de shader por píxel: devuelve traza de variables o valor de píxel + información del shader como fallback

Análisis de rendimiento (4)

Herramienta	Descripción
`get_pass_timing`	Los render passes más costosos: usa contadores de GPU si están disponibles, con fallback a heurística de recuento de triángulos
`analyze_overdraw`	Estimación de overdraw por grupo de render targets
`analyze_bandwidth`	Estimación de ancho de banda de escritura/lectura por render target
`analyze_state_changes`	Encuentra patrones redundantes de cambios de estado y oportunidades de batching

Diagnósticos (4)

Herramienta	Descripción
`diagnose_negative_values`	Escanea todos los RTs float en busca de negativos/NaN/Inf: encuentra el primer evento que los introduce, detecta acumulación de TAA
`diagnose_precision_issues`	Comprueba pérdida de bit de signo en R11G11B10, depth buffers poco profundos, desajustes SRGB/lineal
`diagnose_reflection_mismatch`	Compara los pases de reflexión con los draws de la escena principal: encuentra causas de shader/blend/formato
`diagnose_mobile_risks`	Comprobación exhaustiva en categorías de riesgo de precisión / rendimiento / compatibilidad / específicas de GPU

Prompts

Plantillas de prompt integradas para guiar a la IA en flujos de trabajo comunes:

Prompt	Descripción
`debug_draw_call`	Análisis profundo de un solo draw call: pipeline → shaders → cbuffers → salidas
`find_rendering_issue`	Diagnóstico sistemático a partir de una descripción del problema
`analyze_performance`	Análisis de rendimiento de todo el frame: tiempos de pase, overdraw, ancho de banda, cambios de estado

Cómo funciona

AI Assistant ←—MCP—→ renderdoc-mcp server ←—Python API—→ renderdoc.pyd ←→ GPU replay

El servidor usa la API de replay headless de RenderDoc (renderdoc.pyd) para:

Abrir archivos de captura .rdc sin la GUI
Reproducir frames y consultar el estado del pipeline en cualquier evento
Extraer texturas, buffers, datos de shaders e historial de píxeles
Devolver JSON estructurado para que la IA pueda razonar sobre él

Desarrollo

# Install in dev mode
pip install -e .

# Run tests (no RenderDoc needed — uses mocks)
python -m pytest tests/ -v

# Project structure
src/renderdoc_mcp/
├── server.py                 # FastMCP server, 3 prompt definitions
├── session.py                # Capture lifecycle, resource/texture caches (singleton)
├── util.py                   # Serialization, enum maps, blend formula, module loader
└── tools/
    ├── session_tools.py      # open/close/info (GPU quirks) + get_frame_overview
    ├── event_tools.py        # list/get/set/search actions + find_draws
    ├── pipeline_tools.py     # pipeline state, shader bindings, vertex inputs + get_draw_call_state
    ├── resource_tools.py     # texture/buffer/resource enumeration
    ├── data_tools.py         # save/read/pick/stats + read_texture_pixels + export_draw_textures, save_render_target, export_mesh
    ├── shader_tools.py       # disassembly (fallback chain, search), reflection, cbuffer contents (filter)
    ├── advanced_tools.py     # pixel history, post-VS data + diff_draw_calls (implications), analyze_render_passes, sample_pixel_region, debug_shader_at_pixel
    ├── performance_tools.py  # get_pass_timing, analyze_overdraw, analyze_bandwidth, analyze_state_changes
    └── diagnostic_tools.py  # diagnose_negative_values, diagnose_precision_issues, diagnose_reflection_mismatch, diagnose_mobile_risks

Licencia

MIT

This server cannot be installed

license - not tested

quality - not tested

maintenance

How are these scores calculated?

Maintenance

–Maintainers

–Response time

–Release cycle

–Releases (12mo)

Commit activity

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

driflyte-mcp-server
Driflyte MCP server which lets AI assistants query topic-specific knowledge from web and GitHub.
mcp-wan
MCP server for Wan AI video generation
hithereiamaliff-mcp-nextcloud
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…

View all MCP Connectors

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/fjxyyzg3/renderdoc-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

renderdoc-mcp

Características

Inicio rápido

1. Requisitos previos

2. Instalación

3. Encuentra la ruta de tu renderdoc.pyd

4. Configura tu cliente MCP

Ejemplos de uso

Flujo de herramientas típico

Herramientas

Gestión de sesión (4)

Navegación de eventos (5)

Inspección de pipeline (4)

Análisis de recursos (4)

Extracción de datos (8)

Análisis de shaders (3)

Avanzado (6)

Análisis de rendimiento (4)

Diagnósticos (4)

Prompts

Cómo funciona

Desarrollo

Licencia

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Latest Blog Posts

MCP directory API

3. Encuentra la ruta de tu `renderdoc.pyd`