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{Dies ist ein persönliches }}$ $\Large\color{#ff69b4}{\mathtt{✨ vibe\text{-}coding ✨}}$ $\Large\color{#ff69b4}{\textsf{Projekt —}}$ $\Large\color{#ff69b4}{\textsf{aus Spaß gebaut, nicht für den Produktiveinsatz.}}$

$\small\color{gray}{\textsf{Ich habe keine Ahnung, warum dieses Repo so viele Sterne hat...}}$

MCP-Server für RenderDoc – lassen Sie KI-Assistenten GPU-Frame-Aufnahmen (.rdc-Dateien) für Grafik-Debugging und Leistungsanalyse analysieren.

Basiert auf dem Model Context Protocol, funktioniert mit Claude Desktop, Claude Code und jedem MCP-kompatiblen Client.

Funktionen

42 Tools, die den gesamten RenderDoc-Analyse-Workflow abdecken
10 High-Level-Tools für die Ein-Klick-Analyse (Draw-Call-Zustand, Frame-Übersicht, Diff, Stapelexport, Pixelbereichsabtastung usw.)
3 integrierte Prompts für geführtes Debugging
Menschenlesbare Ausgabe – Mischmodi, Tiefenfunktionen, Topologie werden als Namen statt Zahlen angezeigt
GPU-Eigenheiten-Erkennung – erkennt automatisch Adreno/Mali/PowerVR/Apple-spezifische Fallstricke anhand des Treibernamens
Headless – keine GUI erforderlich, läuft vollständig über RenderDocs Python-Replay-API
Reines Python – einzelnes pip install, kein Build-Schritt
Unterstützt D3D11-, D3D12-, OpenGL-, Vulkan- und OpenGL-ES-Aufnahmen

Schnellstart

1. Voraussetzungen

Python 3.10+
RenderDoc installiert (Download)
- Sie benötigen das Python-Modul renderdoc.pyd (Windows) oder renderdoc.so (Linux)
- Es ist in jeder RenderDoc-Installation enthalten

2. Installieren

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

3. Finden Sie Ihren `renderdoc.pyd`-Pfad

Das Python-Modul befindet sich in Ihrem RenderDoc-Installationsverzeichnis:

Plattform	Typischer Pfad
Windows	`C:\Program Files\RenderDoc\renderdoc.pyd`
Linux	`/usr/lib/renderdoc/librenderdoc.so` oder wo Sie es erstellt haben

Sie benötigen das Verzeichnis, das diese Datei enthält.

4. MCP-Client konfigurieren

Bearbeiten Sie claude_desktop_config.json (Einstellungen → Entwickler → Konfiguration bearbeiten):

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

Fügen Sie zu .claude/settings.json hinzu:

{
  "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

Verwendungsbeispiele

Nach der Konfiguration sprechen Sie einfach mit Ihrem KI-Assistenten:

„Öffne frame.rdc und zeig mir, was im Frame passiert"

„Finde den Draw-Call, der das Charaktermodell rendert, und prüfe seinen Pipeline-Zustand"

„Warum wird meine Schattenkarte schwarz gerendert? Prüfe den Tiefendurchlauf"

„Analysiere die Leistung – gibt es redundante Draw-Calls?"

Typischer Tool-Ablauf

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

Für Leistungs- und Diagnoseanalyse:

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

Für die Analyse auf niedrigerer Ebene bleiben alle granularen Tools verfügbar:

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

Tools

Sitzungsverwaltung (4)

Tool	Beschreibung
`open_capture`	Öffnet eine `.rdc`-Datei (schließt die vorherige automatisch)
`close_capture`	Schließt die aktuelle Aufnahme und gibt Ressourcen frei
`get_capture_info`	Aufnahmemetadaten: API, Aktionsanzahl, Auflösung, bekannte_GPU-Eigenheiten (Adreno/Mali/PowerVR/Apple)
`get_frame_overview`	Statistiken auf Frame-Ebene: Aktionsanzahl nach Typ, Textur-/Pufferspeicher, Renderziele, Auflösung

Ereignisnavigation (5)

Tool	Beschreibung
`list_actions`	Listet den Draw-Call-/Aktionsbaum auf – unterstützt `filter` (Namens-Teilstring) und `event_type` (draw/clear/copy…)
`get_action`	Vollständige Details für eine einzelne Aktion
`set_event`	Zu einem Ereignis navigieren (erforderlich vor Pipeline-Abfragen)
`search_actions`	Nach Namensmuster und/oder Aktionsflags suchen
`find_draws`	Draw-Calls nach Rendering-Zustand durchsuchen: Blend, Mindestanzahl an Scheitelpunkten, Textur-/Shader-/RT-Bindung

Pipeline-Inspektion (4)

Tool	Beschreibung
`get_pipeline_state`	Vollständiger Zustand: Topologie, Viewports, Rasterizer, Blend, Tiefe, Schablone (menschenlesbare Aufzählungen)
`get_shader_bindings`	Konstante Puffer, SRVs, UAVs, Sampler für eine Shader-Stufe
`get_vertex_inputs`	Vertex-Attribute, Vertex-/Indexpuffer-Bindungen
`get_draw_call_state`	Draw-Analyse mit einem Aufruf: Aktionsinfo, Blend-Formel, Tiefe, Schablone, Rasterizer, Texturen mit Größen, RTs, Shader

Ressourcenanalyse (4)

Tool	Beschreibung
`list_textures`	Alle Texturen (filterbar nach Format, Mindestbreite)
`list_buffers`	Alle Puffer (filterbar nach Mindestgröße)
`list_resources`	Alle benannten Ressourcen (filterbar nach Typ, Namensmuster)
`get_resource_usage`	Welche Ereignisse eine Ressource lesen/schreiben

Datenextraktion (8)

Tool	Beschreibung
`save_texture`	Export nach PNG, JPG, BMP, TGA, HDR, EXR oder DDS
`get_buffer_data`	Pufferbytes lesen (Hex-Dump oder Float32-Array)
`pick_pixel`	RGBA-Wert an einer Koordinate
`get_texture_stats`	Min/Max/Mittelwert pro Kanal mit Anomalieerkennung (NaN/Inf/negativ); unterstützt `all_slices` für Cubemaps
`read_texture_pixels`	Einen rechteckigen Pixelbereich (bis zu 64×64) mit Pixel-für-Pixel-Anomalie-Flags lesen
`export_draw_textures`	Stapelexport aller an einen Draw-Call gebundenen Texturen (automatische Namen, überspringt Platzhalter)
`save_render_target`	RT-Schnappschuss bei einem Ereignis speichern (Farbe + optionale Tiefe)
`export_mesh`	Netz als OBJ exportieren mit Positionen, Normalen, UVs aus Post-VS-Daten

Shader-Analyse (3)

Tool	Beschreibung
`disassemble_shader`	Shader-Disassemblierung mit automatischer Fallback-Kette; unterstützt `search` (Schlüsselwort + Kontext) und `line_range`
`get_shader_reflection`	Eingabe-/Ausgabesignaturen, Ressourcenbindungslayout
`get_cbuffer_contents`	Tatsächliche Konstantenpuffer-Variablenwerte; unterstützt `filter` für Variablennamen-Teilstring

Erweitert (6)

Tool	Beschreibung
`pixel_history`	Vollständiger Pixel-für-Pixel-Änderungsverlauf über alle Ereignisse
`get_post_vs_data`	Post-Transformations-Vertexdaten (VS out / GS out)
`diff_draw_calls`	Zwei Draw-Calls vergleichen – zeigt Zustandsunterschiede mit menschenlesbaren Auswirkungen
`analyze_render_passes`	Render-Pass-Grenzen automatisch erkennen anhand von Clear-/RT-Wechseln, jeden Durchlauf zusammenfassen
`sample_pixel_region`	Gleichmäßige Rasterabtastung einer RT-Region – erkennt NaN/Inf/negativ/überbelichtete Hotspots
`debug_shader_at_pixel`	Pixelweises Shader-Debugging – gibt Variablenverfolgung oder Pixelwert + Shader-Info als Fallback zurück

Leistungsanalyse (4)

Tool	Beschreibung
`get_pass_timing`	Teuerste Render-Passes – verwendet GPU-Zähler, falls verfügbar, sonst Dreiecksanzahl-Heuristik
`analyze_overdraw`	Overdraw-Schätzung pro Renderzielgruppe
`analyze_bandwidth`	Schreib-/Lese-Bandbreitenschätzung pro Renderziel
`analyze_state_changes`	Findet redundante Zustandswechselmuster und Batching-Möglichkeiten

Diagnose (4)

Tool	Beschreibung
`diagnose_negative_values`	Scannt alle Float-RTs auf negativ/NaN/Inf – findet das erste Ereignis, das sie einführt, erkennt TAA-Akkumulation
`diagnose_precision_issues`	Prüft R11G11B10-Vorzeichenbitverlust, flache Tiefenpuffer, SRGB/Linear-Konflikte
`diagnose_reflection_mismatch`	Vergleicht Reflexionsdurchläufe mit Hauptszenen-Draws – findet Shader-/Blend-/Formatursachen
`diagnose_mobile_risks`	Umfassende Prüfung über Präzisions-/Leistungs-/Kompatibilitäts-/GPU-spezifische Risikokategorien

Prompts

Integrierte Prompt-Vorlagen, die KI durch gängige Arbeitsabläufe führen:

Prompt	Beschreibung
`debug_draw_call`	Einzelnen Draw-Call eingehend untersuchen: Pipeline → Shader → CBuffer → Ausgaben
`find_rendering_issue`	Systematische Diagnose anhand einer Problembeschreibung
`analyze_performance`	Frame-weite Leistungsanalyse: Pass-Timing, Overdraw, Bandbreite, Zustandsänderungen

So funktioniert es

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

Der Server verwendet RenderDocs Headless-Replay-API (renderdoc.pyd), um:

.rdc-Aufnahmedateien ohne GUI zu öffnen
Frames wiederzugeben und den Pipeline-Zustand bei jedem Ereignis abzufragen
Texturen, Puffer, Shader-Daten und Pixelverlauf zu extrahieren
Strukturiertes JSON zurückzugeben, über das die KI nachdenken kann

Entwicklung

# 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

Lizenz

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

Funktionen

Schnellstart

1. Voraussetzungen

2. Installieren

3. Finden Sie Ihren renderdoc.pyd-Pfad

4. MCP-Client konfigurieren

Verwendungsbeispiele

Typischer Tool-Ablauf

Tools

Sitzungsverwaltung (4)

Ereignisnavigation (5)

Pipeline-Inspektion (4)

Ressourcenanalyse (4)

Datenextraktion (8)

Shader-Analyse (3)

Erweitert (6)

Leistungsanalyse (4)

Diagnose (4)

Prompts

So funktioniert es

Entwicklung

Lizenz

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Latest Blog Posts

MCP directory API

3. Finden Sie Ihren `renderdoc.pyd`-Pfad