Tutorials

How-To: ChatGPT Astra mit Blender über das Model Context Protocol (MCP) verbinden

Melden

Das Model Context Protocol (MCP) ist ein offener Standard, der es KI-Modellen wie ChatGPT ermöglicht, sicher und direkt mit lokalen Programmen, Daten und Entwicklungsumgebungen zu interagieren. In Kombination mit Blender verwandelt dieses Setup die KI in einen 3D-Assistenten: Du beschreibst einfach per Sprache oder Text, was du willst, und die KI manipuliert Objekte, Materialien und Szenen live in Blender.

In diesem Tutorial erfährst du Schritt für Schritt, wie du die Brücke zwischen ChatGPT (Astra) und Blender über MCP schlägst.

Voraussetzungen

Bevor du beginnst, stelle sicher, dass Folgendes installiert ist:

  • Blender (eine aktuelle Version)
  • Python (auf deinem System installiert)
  • Ein MCP-fähiges Interface / Client (z. B. eine lokale Host-App oder Entwickler-Tools, die ChatGPT/Astra mit MCP-Servern verbinden)
  • Grundkenntnisse im Ausführen von Terminal-Befehlen

Schritt 1: Blender für externe Verbindungen vorbereiten

Blender verfügt über eine mächtige Python-API (bpy), hört aber standardmäßig nicht auf externe Befehle. Wir richten einen kleinen Listener ein.

  1. Öffne Blender.
  2. Wechsle in den Tab Scripting und erstelle ein neues Skript.
  3. Füge folgenden Code ein, um einen einfachen lokalen Socket-Server in Blender zu starten, der Python-Befehle empfangen und ausführen kann:
import bpy
import socket
import threading

def run_server():
    host = '127.0.0.1'
    port = 9999

    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server.bind((host, port))
    server.listen(1)
    print(f"[Blender] Hört auf {host}:{port}...")

    while True:
        client, addr = server.accept()
        data = client.recv(4096).decode('utf-8')
        if data:
            try:
                # Führt den empfangenen Python-Code im Blender-Kontext aus
                exec(data, {'bpy': bpy})
                client.send(b"Erfolg")
            except Exception as e:
                client.send(f"Fehler: {str(e)}".encode('utf-8'))
        client.close()

# Server in separatem Thread starten, damit die Blender-UI nicht blockiert
thread = threading.Thread(target=run_server, daemon=True)
thread.start()
  1. Klicke auf Run Script. Blender wartet nun auf Port 9999 auf Steuerbefehle.

Schritt 2: Den Blender-MCP-Server erstellen

Jetzt bauen wir den eigentlichen MCP-Server. Dieser vermittelt zwischen ChatGPT/Astra (dem MCP-Client) und Blender.

  1. Erstelle einen neuen Ordner auf deinem PC (z. B. blender-mcp).
  2. Installiere das MCP-Python-SDK über das Terminal:
    pip install mcp
  3. Erstelle in dem Ordner eine Datei namens server.py mit folgendem Inhalt:
import socket
from mcp.server.fastmcp import FastMCP

# MCP-Server initialisieren
mcp = FastMCP("Blender-Bridge")

def send_to_blender(code: str) -> str:
    """Sendet Python-Code an den Blender-Socket."""
    host = '127.0.0.1'
    port = 9999
    try:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
            s.connect((host, port))
            s.sendall(code.encode('utf-8'))
            response = s.recv(4096).decode('utf-8')
            return response
    except ConnectionRefusedError:
        return "Fehler: Verbindung zu Blender fehlgeschlagen. Läuft das Blender-Skript?"

@mcp.tool()
def execute_blender_script(code: str) -> str:
    """Führt ein Python-Skript in Blender aus, um 3D-Objekte zu generieren oder zu verändern."""
    result = send_to_blender(code)
    return f"Blender-Rückmeldung: {result}"

if __name__ == "__main__":
    mcp.run()

Schritt 3: ChatGPT Astra mit dem MCP-Server verbinden

Damit ChatGPT weiß, dass es Blender-Befehle ausführen kann, musst du den MCP-Server in deiner MCP-Client-Konfiguration registrieren.

  1. Öffne die Konfigurationsdatei deines MCP-Clients (z. B. mcp_config.json).
  2. Füge den Server unter mcpServers hinzu:
{
  "mcpServers": {
    "blender": {
      "command": "python",
      "args": ["PFAD/ZU/DEINEM/ORDNER/server.py"]
    }
  }
}

(Ersetze PFAD/ZU/DEINEM/ORDNER/server.py durch den absoluten Pfad zu deiner Datei).

  1. Starte deine MCP-Umgebung bzw. die ChatGPT-Astra-Verbindung neu. Das System sollte nun das Tool execute_blender_script erkennen.

Schritt 4: Der Praxistest

Wenn alles eingerichtet ist, kannst du mit ChatGPT Astra über natürliche Sprache 3D-Inhalte erzeugen.

Typische Prompts zum Testen:

  • "Erstelle eine UV-Sphere in Blender, skaliere sie um den Faktor 2 und platziere sie an den Koordinaten (0, 0, 5)."
  • "Lösche alle Würfel in der aktuellen Szene und erstelle ein Raster aus 5x5 bunten Zylindern."
  • "Füge eine Kamera hinzu, die auf das Zentrum gerichtet ist, und erstelle eine warme Punktlichtquelle."

Was im Hintergrund passiert:

  1. ChatGPT versteht deine Anforderung.
  2. Es generiert den passenden bpy-Python-Code (z. B. bpy.ops.mesh.primitive_uv_sphere_add(...)).
  3. ChatGPT ruft das MCP-Tool execute_blender_script auf.
  4. Der MCP-Server schickt den Code via Socket an Blender.
  5. Die Änderung erscheint in Echtzeit in deinem Blender-Viewport.

Tipps zur Fehlerbehebung

  • Verbindung abgelehnt (ConnectionRefusedError): Stelle sicher, dass du das Server-Skript in Blender nach jedem Neustart der Software erneut ausführst.
  • UI friert ein: Achte darauf, dass der Socket-Server in Blender über das Modul threading läuft, da Blender sonst keine Benutzereingaben mehr zulässt.
  • Ungültiger Code: Komplexe Operationen (z. B. Geometrie-Nodes oder Shader-Netzwerke) erfordern präzise Prompts. Wenn ein Fehler zurückgemeldet wird, kann ChatGPT den Code selbstständig korrigieren, da die Fehlermeldung über MCP direkt an das Sprachmodell zurückfließt.
0