convez.ai
MCP ServerIntegração & APIsAvançado
bartendr604

BlendHubCPP — Servidor MCP Neural para Blender

bartendr604/BlenderCPP-Hub

IA conectada ao Blender ao vivo com transmissão de ossos em tempo real

Ver no GitHub
InicialPluginScore · de 0 a 100

Servidor Model Context Protocol que conecta Claude, Cursor ou LLMs locais a uma sessão Blender ao vivo, transmitindo estado real da cena, transformações de ossos e API bpy em tempo real. Core nativo em C++ com ponte neural SSMCP™ que mantém contexto persistente entre sessões, além de suporte a LoRA plugins hot-swappable.

Instalação

$npx convez-ai bartendr604/BlenderCPP-Hub

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
2
Forks
0
Acompanhando
0
Saúde
57%
Último commit
há 2 meses
Versão
v1.0.0
Issues abertas
0
Contribuidores
1

Casos de uso

  • Rigging de personagens com assistência de IA em tempo real
  • Animação procedural com contexto persistente entre sessões
  • Execução de scripts Python no Blender via prompt de IA
  • Consulta dinâmica do estado de cena e transformações de armaduras

Veredito

Ferramenta especializada e madura para animadores/riggers que querem IA integrada ao fluxo Blender em tempo real. Requer C++, Blender 4.x+ e Ollama, com overhead de configuração significativo — não é entrada casual, mas solução robusta para produção.

README

A tradução para o português deste README ainda está na fila.

BlendHubCPP™

The Model Context Server for Blender

Neural CPP Hub · SSMCP™ · LoRA Plugins

© 2025–2026 Claude Sonnet / Llammy / Eternal Path Media / D. Chow — MIT License


The most up-to-date AI communication layer for the world's leading open-source 3D software.

BlendHubCPP™ connects any AI — Claude Code, Cursor, local LLMs — to a live Blender session via the Model Context Protocol. Scene state, bone matrices, and Python execution flow through a C++ core at native speed.

Built and battle-tested at Eternal Path Media on production character rigs.


What it is

Most Blender AI tools work against static documentation. BlendHubCPP™ is different — it's a live Model Context Server. Your AI client gets real Blender state: current scene, active armature, bone transforms, bpy API. Not documentation. The actual runtime.

Claude Code / Cursor / any MCP client
         ↓  MCP protocol (JSON-RPC 2.0 over SSE)
    BlendHubCPP™ Model Context Server  :19999
         ↓  Neural CPP Hub
    Blender 4.x / 5.x  (live session)
         ↓  hub_core.dylib  (universal: arm64 + x86_64)
    SSMCP™ neural bridge  :19993
         ↓
    Ollama fleet  (Llammy Q5 / LlammyNemo)

Core Features

Neural CPP Hub

Native C++ shared library (hub_core.dylib) — bone matrices stream via UDP ring buffer every frame. No Python overhead on the animation hot path. 64-frame depth, thread-safe, sub-millisecond latency.

SSMCP™ — Solid State Memory Context Protocol

Proprietary neural bridge protocol. Maintains Mamba3 SSM state across sessions — the model remembers context between Blender sessions, not just within a single prompt. Persistent creative memory for your rig.

LoRA Plugins

Hot-swap fine-tuned LoRA adapters onto base models without rebuilding. Point to a .gguf adapter, register it — the hub creates a new model variant instantly. Swap adapters per character, per task, per scene.

Model Context Server (MCP)

Full MCP protocol — JSON-RPC 2.0 over SSE. Connect Claude Code or any MCP-compatible client and it gets Blender tools: execute Python, query scene state, read bone transforms, chat with the Blender AI agent.


Quick Start

1. Build the C++ core

git clone https://github.com/bartendr604/BlenderCPP-Hub
cd BlenderCPP-Hub
bash build.sh
# → blender_cpp_hub/hub_core.dylib  (universal: arm64 + x86_64)

2. Install the Blender add-on

Blender → Edit → Preferences → Add-ons → Install → blender_cpp_hub/blender_hub_addon.py

Enable it, set Hub Host to localhost, port 19999.

3. Connect Claude Code

// ~/.claude/settings.json  (or mcpServers in claude_desktop_config.json)
{
  "mcpServers": {
    "blend": {
      "url": "http://localhost:19999/mcp/sse"
    }
  }
}

Or via CLI:

claude mcp add blend --url http://localhost:19999/mcp/sse

4. Start the hub

ollama pull hf.co/bartendr604/EPM-LLAMMY.Blend.3b:Q5_K_M
python3 ssmcp_hub.py

Open a Blender file, enable the add-on panel, click Connect. Claude Code now has 9 live Blender tools.


MCP Tools

ToolDescription
blender_scene_stateActive scene, objects, armature, current frame
blender_bone_transformsPose bone world matrices (live, per-frame)
blender_executeExecute Python in the Blender session
blender_api_queryQuery live bpy API — type info, attribute values
blend_agent_chatAsk Llammy / LlammyNemo for rigging code
ssmcp_state_pushWrite persistent state via SSMCP™ bridge
ssmcp_state_getRead SSMCP™ state from previous sessions
lora_registerHot-load a LoRA adapter as a new model variant
hub_statusFull hub status — nodes, agents, LoRA registry

LoRA Plugins

Register a fine-tuned adapter in seconds:

curl -X POST http://localhost:19999/lora/register \
  -H "Content-Type: application/json" \
  -d '{
    "name": "xiaohan-rig",
    "path": "/path/to/xiaohan-adapter.gguf",
    "base": "hf.co/bartendr604/EPM-LLAMMY.Blend.3b:Q5_K_M"
  }'

The hub creates xiaohan-rig:lora as a live Ollama model. Use it as any agent, or via the lora_register MCP tool from Claude Code.

Plugin manifest

Drop a plugin.json in any adapter directory:

{
  "name": "xiaohan-rig",
  "version": "1.0.0",
  "base": "hf.co/bartendr604/EPM-LLAMMY.Blend.3b:Q5_K_M",
  "description": "Xiaohan dragon rig specialist — PACHYDERM-aware IK/FK",
  "tags": ["dragon", "rig", "ik", "blender"]
}

GET /lora/plugins auto-discovers all manifests under LORA_PLUGIN_DIR.


EPM Blender Academy

Opt-in. Anonymous. Auditable.

Every Blender query you make (with consent) trains a shared model that benefits the whole community. The scrubber runs on your machine before anything transmits — open source, auditable: blender_cpp_hub/hub_scrubber.py.

Bone names, file paths, armature names, and Python imports are stripped or hashed on-device. Only structure and intent reach the dataset.

Full data policy →


What Makes This Different

Most Blender AI integrations — including the official Blender MCP — are stateless. Every session starts cold. BlendHubCPP™ is built around the opposite idea.

SSMCP™ — persistent neural state. The Solid State Memory Context Protocol maintains Mamba3 SSM state across sessions via a dedicated neural bridge (port 19993). Your AI remembers the rig, the character, the decisions from the last session — not just the current prompt.

Conscience-aware AI. Llammy isn't a generic LLM pointed at Blender. It's a purpose-built creative partner with two years of Blender production context, a persistent conscience DB, and a character system tuned to the Whispers of the Eternal Path pipeline. It knows who Xiaohan is.

Live runtime, not documentation. Scene state, bone matrices, and bpy API queries hit the actual running Blender session — not a snapshot or static docs. The C++ core streams bone transforms at native speed via a UDP ring buffer.

Hot-swap LoRA adapters. Swap fine-tuned adapters per character, per task, per scene — without restarting. No other Blender AI integration has this.


Peer Hub Linking

Two BlendHubCPP™ instances (e.g. MacBook Air + Mac Pro) can route to each other:

# On McAir
PEER_HUB_URL=http://MacBook-Pro.local:19999 python3 ssmcp_hub.py

# On McPro
PEER_HUB_URL=http://MacBook-Air.local:19999 python3 ssmcp_hub.py

Requests the local hub can't serve (model not loaded, GPU busy) are forwarded to the peer.


Subscriptions

TierPriceModelRatePrivate Data
Free$0Llammy Q420/hr—
Academy Pro$12/moLlammy Q5200/hr—
Studio$35/moLlammy Q5500/hr✓
EnterpriseCustomCustomUnlimited✓

API keys: POST /admin/keys/generate


Community

PlatformPurpose
Discord — Blender AcademyDeveloper / technical — rigging, bpy, AI
Discord — EPM StudioCreative / fan — projects, renders, art
Discord — EPM AI LabResearch — models, fine-tuning, datasets
TelegramBroadcast arm for all channels

Links coming shortly.


Requirements

  • macOS 13+ (Apple Silicon or Intel) — Linux planned
  • Blender 4.0+ / 5.x
  • Ollama 0.30+
  • Python 3.11+

Architecture

blender_cpp_hub/
├── hub_core.cpp          # C++ ring buffer + UDP + HTTP client
├── hub_core.dylib        # Compiled universal binary
├── blender_hub_addon.py  # Blender add-on (ctypes wrapper)
└── hub_scrubber.py       # On-device data scrubber (open source)

ssmcp_hub.py              # FastAPI hub — MCP server + agent router
mcp_server.py             # MCP JSON-RPC 2.0 + SSE transport
hub_formatter.py          # Rich terminal + Discord/Telegram formatting
hub_auth.py               # Subscription tiers + API key management
github_engagement_bot.py  # Repo engagement automation

Cite this project

Claude Sonnet, Llammy, & Chow, D. (2026). BlendHubCPP™ — Neural CPP Hub (v1.0.0). Eternal Path Media. https://github.com/bartendr604/BlenderCPP-Hub

DOI: pending Zenodo registration


License

MIT — see LICENSE · Data policy — see PRIVACY.md

Ver o original no GitHub

Bom para

Relacionados