Deine eigene OpenAI-kompatible API für die Erstellung von 3D-Inhalten nutzen

Die gute Nachricht: Stand 2026 hat praktisch jede große 3D-Anwendung irgendeine Form von KI-Integration, und die meisten modernen Implementierungen nutzen das Model Context Protocol (MCP). Das ist von Natur aus modellunabhängig — das heißt, du kannst sie auf jeden Endpunkt richten, der die OpenAI Chat Completions API spricht (selbst gehostetes vLLM/Ollama/LM Studio, Azure OpenAI, OpenRouter, ein Unternehmens-Proxy usw.), statt an OpenAIs eigene Server gebunden zu sein.

Die grundlegende Architektur

Es gibt zwei Ebenen, die du verstehen musst:

Das "Gehirn" (dein LLM) — erreichbar über einen MCP-fähigen Client/Host, in dem du eine eigene base_url + API-Key setzen kannst.
Die "Hände" (ein MCP-Server oder Add-on in der 3D-App) — übersetzt die Tool-Aufrufe des Modells in echte Szenenänderungen (Python-API-Aufrufe, Node-Erstellung, Mesh-Operationen usw.)

Weil Gehirn und Hände über MCP voneinander entkoppelt sind, kannst du auf der Client-/Host-Seite deinen eigenen OpenAI-kompatiblen Endpunkt einsetzen, und dieser steuert dann den MCP-Server der jeweiligen 3D-App, den du installiert hast.

Optionen nach Ansatz

Ansatz	Wie es funktioniert	Unterstützung für eigene Endpunkte
MCP-basierte Steuerung	Ein MCP-Host (Cursor, Cline, OpenCode, Continue, 5ire, Cherry Studio, Open WebUI, LibreChat usw.) sendet deinen Prompt an deine eigene API, und das Modell ruft Tools auf, die von einem MCP-Server in der 3D-App bereitgestellt werden	✅ Beste Option — fast alle diese Hosts haben ein echtes Feld für "OpenAI-kompatiblen" Anbieter für `base_url` + Key
Natives KI-Add-on/Plugin	Ein in die App eingebettetes Plugin hat ein eigenes Einstellungsfenster mit API-Key- und Base-URL-Feld	✅ Unterschiedlich je nach Plugin — viele Forks haben das nach den ursprünglich nur auf OpenAI ausgelegten Versionen ausdrücklich ergänzt
DIY-Scripting	Da Blender, Houdini, Maya, C4D und TouchDesigner alle Python einbetten, kannst du in einem Skript/Operator einfach `requests`/das `openai` SDK gegen deine eigene `base_url` aufrufen	✅ Funktioniert immer — am flexibelsten, aber du schreibst die Tool-Calling-Logik selbst
Eigenständige KI-Pipelines, die die 3D-App versorgen	ComfyUI oder Ähnliches erzeugt Texturen/Assets (oft mit Diffusionsmodellen, nicht mit Chat-Modellen), die du dann importierst	⚠️ Nur für die LLM-Prompt-Verbesserungs-Nodes relevant, nicht für die Diffusions-/3D-Erzeugung selbst

Empfohlene Software nach Anwendungsfall

🥇 Blender — Insgesamt die beste Empfehlung

Tool: blender-mcp (über 23k Stars, aktiv gepflegt) — ein MCP-Server, der jedem verbundenen LLM volle Kontrolle gibt: Objekte, Materialien erstellen/ändern/löschen, beliebiges Python ausführen, die Szene prüfen und sogar Poly-Haven-Assets sowie mit Hyper3D/Hunyuan3D erzeugte Modelle einbinden.
Wie du es auf deine eigene API richtest: blender-mcp selbst ist LLM-unabhängig — es führt nur Tool-Aufrufe aus. Du verbindest es über einen MCP-Host, der eigene OpenAI-kompatible Endpunkte unterstützt, z. B. Cursor, OpenCode, Cline, Continue.dev, 5ire, Open WebUI oder Claude for Creative Work (über einen kompatiblen Proxy). Stell einfach den Anbieter des Hosts auf "OpenAI-kompatibel", gib deine base_url ein und verbinde dich mit Blender.
Warum ich es empfehle: Kostenlos, Open Source, riesige Community, beste Dokumentation, und das Add-on-Ökosystem (3D-Agent, BlenderGPT-Forks, Griptape Nodes) bietet mehrere Einstiegsmöglichkeiten.

🥈 Unreal Engine — Am besten für Spiele-/Echtzeit-Umgebungen

Tools: Das generative-AI-Plugin oakisnotree wirbt ausdrücklich mit Unterstützung für "jeden OpenAI-kompatiblen Endpunkt (vLLM, Ollama, selbst gehostet)". Dazu kommen UnrealGenAISupport und Unreals offizielle MCP-Integration (im Unity-Stil) sowie Community-Plugins wie Autonomix.
Warum: Wenn du Level, Umgebungen oder interaktive Erlebnisse statt statischer Renderings baust, bekommst du damit einen Agenten, der Actors, Blueprints und Materialien direkt bearbeiten kann.

🥉 Unity — Ähnlich wie Unreal

Tool: Unity-MCP (von IvanMurzak) plus Unitys eigenes offizielles MCP-Paket — verbindet Claude, Cursor, Windsurf oder jeden eigenen MCP-Client mit dem Editor.

Houdini — Am besten für prozedurale/VFX-Arbeit

Tools: Houdini-Agent, aufgebaut auf dem OpenAI-Function-Calling-Protokoll — liest Node-Netzwerke, erstellt/ändert/verbindet Nodes, schreibt VEX und erzeugt Assets.
Warum: Wenn du prozedurale Geometrie, Simulationen oder VFX-Pipelines brauchst, ist das die technisch tiefgehendste Option. Da Houdini vollen Python-Zugriff bietet, ist es für einen Entwickler trivial, eine eigene base_url in jedes HDA einzubauen.

TouchDesigner — Am besten für Echtzeit-/generative Visuals

Es gibt kein dominantes fertiges Plugin, aber mit TouchDesigners Python DAT ist es sehr einfach, jeden OpenAI-kompatiblen Endpunkt direkt aufzurufen, um Parameter zu steuern, Text/Logik für Echtzeit-Visuals zu erzeugen oder Szenenänderungen direkt per Skript auszuführen.

Cinema 4D — Im Moment die schwächste Option

Maxons native KI (2025.3+) ist derzeit nur auf die lokale Asset-Suche beschränkt, und ihr größerer KI-Schwerpunkt (Tencent-HY-3D-Partnerschaft) ist ein Generierungsdienst, keine LLM-Agenten-Integration, und soll keine Kontrolle über eigene Endpunkte bieten. Es gibt ältere Plugins im Kaedim-Stil, aber noch nichts, das mit Blenders MCP-Ökosystem vergleichbar wäre. Wenn du C4D-Qualität beim Rendering mit KI-Agentensteuerung willst, bauen viele Leute die Szene in Blender über MCP und übertragen/exportieren sie dann nach C4D, oder warten darauf, dass Maxons Roadmap reifer wird.

Meine Empfehlung

Da der Preis keine Rolle spielt, würde ich Folgendes aufsetzen:

Blender + blender-mcp als deine primäre 3D-Umgebung, gesteuert über Cursor oder OpenCode (beide haben saubere Einstellungen für "OpenAI-kompatiblen Anbieter" und ausgereifte MCP-Unterstützung), die auf deinen eigenen Endpunkt zeigen. Damit bekommst du heute die leistungsfähigste, am besten unterstützte und flexibelste Pipeline.
Wenn dein Ziel Spiele-/Echtzeit-/interaktive Inhalte statt statischer Szenen sind, ergänze Unreal Engine + oakisnotree oder Unity-MCP — beide sind ausdrücklich für Bring-your-own-Endpoint gedacht.
Wenn du prozedurale/VFX-lastige Arbeit brauchst (Simulationen, komplexe Node-Graphs), ergänze Houdini + Houdini-Agent.

Diese Kombination deckt Modeling/Szenenaufbau (Blender), Echtzeit-/Spielumgebungen (Unreal/Unity) und prozedurale VFX (Houdini) ab — alles steuerbar mit deinem eigenen selbst gehosteten oder Drittanbieter-OpenAI-kompatiblen Modell.