class MayaService(DCCRPyCService): def get_scene_info(self): return {"scene": "Maya scene info"}

def exposed_execute_cmd(self, cmd_name, *args, **kwargs):
    pass

server = create_dcc_server( dcc_name="maya", service_class=MayaService, port=18812, ) server.start(threaded=True)

</augment_code_snippet>

### Client-side

<augment_code_snippet path="README.md" mode="EXCERPT">
````python
from dcc_mcp_ipc.client import BaseDCCClient


client = BaseDCCClient("maya", host="localhost", port=18812)
client.connect()
result = client.call("get_scene_info")
client.disconnect()

adapter = get_action_adapter("maya")

def create_sphere(radius: float = 1.0, name: str = "sphere1") -> dict: return {"success": True, "message": f"Created {name}", "context": {"name": name}}

adapter.register_action( "create_sphere", create_sphere, description="Create a sphere primitive", category="modeling", tags=["primitive", "mesh"], )

result = adapter.call_action("create_sphere", radius=2.0, name="mySphere") print(result.success) # True print(result.to_dict()) # {"success": True, ...}

</augment_code_snippet>

### Zero-code Skills via SkillManager

Drop a `SKILL.md` file into a directory structure:

```
my_skills/
  create_light/
    SKILL.md      # frontmatter: name, description, tools, scripts
    run.py        # executed when the tool is called
```

<augment_code_snippet path="README.md" mode="EXCERPT">
````python
from dcc_mcp_ipc.skills import SkillManager
from dcc_mcp_ipc.action_adapter import get_action_adapter


adapter = get_action_adapter("maya")
mgr = SkillManager(adapter=adapter, dcc_name="maya")

mgr.load_paths(["/pipeline/skills"])
mgr.start_watching()

# Now "create_light" is callable as an MCP tool
result = adapter.call_action("create_light", intensity=100.0)

pool = ConnectionPool()

with pool.get_client("maya", host="localhost") as client: result = client.call("execute_cmd", "sphere", radius=5) print(result)

</augment_code_snippet>

### Service Factories

Three factory patterns are available for different lifecycle needs:

<augment_code_snippet path="README.md" mode="EXCERPT">
````python
from dcc_mcp_ipc.server import (
    create_service_factory,
    create_shared_service_instance,
    create_raw_threaded_server,
)


class SceneManager:
    def __init__(self):
        self.scenes = {}

    def add_scene(self, name, data):
        self.scenes[name] = data


scene_manager = SceneManager()

# Per-connection instance
service_factory = create_service_factory(MayaService, scene_manager)

# Shared singleton instance
shared_service = create_shared_service_instance(MayaService, scene_manager)

# Raw threaded server
server = create_raw_threaded_server(service_factory, port=18812)
server.start()

Client side

config = IpcTransportConfig(host="localhost", port=19000) transport = IpcClientTransport(config) transport.connect() result = transport.execute("get_scene_info") transport.disconnect()

Server side (inside DCC plugin)

def handle_channel(channel): msg = channel.recv() # process and respond ...

addr = TransportAddress.default_local("maya", os.getpid()) server = IpcServerTransport(addr, handler=handle_channel) bound_addr = server.start()

</augment_code_snippet>

### Creating a Custom DCC Adapter

<augment_code_snippet path="README.md" mode="EXCERPT">
````python
from dcc_mcp_ipc.adapter import DCCAdapter
from dcc_mcp_ipc.client import BaseDCCClient


class MayaAdapter(DCCAdapter):
    def _initialize_client(self) -> None:
        self.client = BaseDCCClient(
            dcc_name="maya",
            host=self.host,
            port=self.port,
            connection_timeout=self.connection_timeout,
        )

    def create_sphere(self, radius: float = 1.0):
        self.ensure_connected()
        assert self.client is not None
        return self.client.execute_dcc_command(f"sphere -r {radius};")

async def main(): client = AsyncDCCClient("maya", host="localhost", port=18812) await client.connect() result = await client.call("get_scene_info") await client.disconnect()

asyncio.run(main())

</augment_code_snippet>

### Testing with Mock Services

<augment_code_snippet path="README.md" mode="EXCERPT">
````python
import threading
from dcc_mcp_ipc.testing.mock_services import MockDCCService
from dcc_mcp_ipc.client import BaseDCCClient


server = MockDCCService.start(port=18812)

client = BaseDCCClient("mock_dcc", host="localhost", port=18812)
client.connect()
info = client.get_dcc_info()
print(info)  # {"name": "mock_dcc", ...}
client.disconnect()
server.stop()