# 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:

1. **Das "Gehirn" (dein LLM)** — erreichbar über einen MCP-fähigen Client/Host, in dem du eine eigene `base_url` + API-Key setzen kannst.
2. **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`](https://github.com/ahujasid/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`](https://oakisnotree.com/generative-ai) wirbt ausdrücklich mit Unterstützung für "jeden OpenAI-kompatiblen Endpunkt (vLLM, Ollama, selbst gehostet)". Dazu kommen [`UnrealGenAISupport`](https://skillsllm.com/skill/unrealgenaisupport) und Unreals offizielle [MCP-Integration (im Unity-Stil)](https://unity.com/blog/unity-ai-mcp-how-to-get-started) 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`](https://github.com/IvanMurzak/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`](https://github.com/Kazama-Suichiku/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:

1. **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.
2. 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.
3. 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.