model-compose 0.4.19__tar.gz → 0.4.20__tar.gz

{model_compose-0.4.19 → model_compose-0.4.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.19
+Version: 0.4.20
 Summary: model-compose: Declarative AI Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT
@@ -54,13 +54,41 @@ Dynamic: license-file
 
 ## ✨ Features
 
-- 🎨 **No-Code**: Pure YAML configuration—no scripting required
-- 🔄 **Composable**: Reusable components and multi-step workflows
-- 🚀 **Production Ready**: HTTP/MCP servers + Web UI + Docker deployment
-- 🔌 **Connect Anything**: External AI services, local models, vector stores, and more
-- ⚡ **Stream & Scale**: Real-time streaming and event-driven automation
-- ⚙️ **Configuration**: Environment variables, flexible settings
-- 🔗 **Integration**: Webhooks, tunneling, HTTP servers
+### 🎨 **No-Code AI Orchestration**
+Define complex AI workflows entirely in YAML—no Python, no JavaScript, no coding required. Connect multiple AI services, models, and APIs through simple declarative configuration.
+
+### 🔗 **Universal AI Service Integration**
+Connect to any AI provider out of the box—OpenAI, Anthropic Claude, Google Gemini, ElevenLabs, Stability AI, Replicate, or any custom HTTP API. Mix and match services in a single workflow.
+
+### 🖥️ **Local Model Execution**
+Run models from HuggingFace and other sources locally with native support for transformers, PyTorch, and model serving frameworks. Fine-tune models with LoRA/PEFT, train with custom datasets, all through YAML configuration.
+
+### ⚡ **Real-Time Streaming**
+Built-in SSE (Server-Sent Events) streaming for real-time AI responses. Stream from OpenAI, Claude, local models, or any streaming API with automatic chunking and connection management.
+
+### 🔄 **Advanced Workflow Composition**
+Build multi-step pipelines with conditional logic, data transformation, and parallel execution. Pass data between jobs with powerful variable binding—`${input}`, `${response}`, `${env}`, with type conversion and defaults.
+
+### 🚀 **Production-Ready Controllers**
+Deploy as HTTP REST API or MCP (Model Context Protocol) server by changing one line. Includes concurrency control, health checks, and automatic API documentation.
+
+### 🎯 **Event-Driven Architecture**
+HTTP Callback listeners for async workflows (image generation, video processing). HTTP Trigger listeners for webhooks and external events. Build reactive AI systems that respond to real-world events.
+
+### 🌐 **Smart Tunneling & Gateways**
+Expose local services to the internet instantly with ngrok, Cloudflare, or SSH tunnels. Perfect for webhook integration, Slack bots, and public API deployment without complex networking.
+
+### 🐳 **Container-Native Deployment**
+First-class Docker support with runtime configuration, volume mounting, and environment management. Deploy to any cloud provider or Kubernetes cluster with minimal configuration.
+
+### 🎨 **Instant Web UI**
+Add a visual interface with just 2 lines—get Gradio-powered chat UI or serve custom static frontends. Test workflows, monitor executions, and debug pipelines visually.
+
+### 🗄️ **RAG & Vector Database Ready**
+Native integration with ChromaDB, Milvus, Pinecone, and Weaviate. Build retrieval-augmented generation (RAG) systems with embedding search, document indexing, and semantic retrieval.
+
+### 🔧 **Flexible Component System**
+Reusable components with multi-action support. Define once, use everywhere. Mix HTTP clients, local models, vector stores, shell commands, and custom workflows in any combination.
 
 ---
 
@@ -129,37 +157,30 @@ model-compose up
 
 Your API is now live at `http://localhost:8080` and Web UI at `http://localhost:8081` 🎉
 
-> 💡 Explore [examples](examples/README.md) for more workflows or read the [User Guide](docs/user-guide/README.md).
-
 ---
-## 💡 Key Capabilities
 
-### 🖥️ Built-in Web UI
-Add a web interface by adding just 2 lines to your YAML:
+## 🎯 Powerful Yet Simple
+
+### 🖥️ Add Web UI with 2 Lines
 ```yaml
 controller:
   webui:
     port: 8081
 ```
-Instantly get a user-friendly interface to test and monitor your workflows. Supports both Gradio (default) and custom static frontends.
 
-### 🛰️ MCP Server Ready
-Transform your workflows into MCP tools by changing one line:
+### 🛰️ Switch to MCP Server with 1 Line
 ```yaml
 controller:
   type: mcp-server
 ```
-Just set the type to `mcp-server`. Your workflows become instantly accessible via the Model Context Protocol.
 
-### 🐳 Docker Deployment
-Deploy anywhere with built-in Docker support:
+### 🐳 Deploy in Docker with 1 Line
 ```yaml
 controller:
   runtime: docker
 ```
-Run your workflows in isolated containers with full control over images, volumes, ports, and environment variables.
 
-> 📖 See the [User Guide](docs/user-guide/README.md) for detailed configuration and [Examples](examples/README.md) for ready-to-run samples.
+> 💡 Explore [examples](examples/README.md) for more workflows or read the [User Guide](docs/user-guide/README.md).
 
 ---
 ## 🏗 Architecture

{model_compose-0.4.19 → model_compose-0.4.20}/README.md

@@ -30,13 +30,41 @@
 
 ## ✨ Features
 
-- 🎨 **No-Code**: Pure YAML configuration—no scripting required
-- 🔄 **Composable**: Reusable components and multi-step workflows
-- 🚀 **Production Ready**: HTTP/MCP servers + Web UI + Docker deployment
-- 🔌 **Connect Anything**: External AI services, local models, vector stores, and more
-- ⚡ **Stream & Scale**: Real-time streaming and event-driven automation
-- ⚙️ **Configuration**: Environment variables, flexible settings
-- 🔗 **Integration**: Webhooks, tunneling, HTTP servers
+### 🎨 **No-Code AI Orchestration**
+Define complex AI workflows entirely in YAML—no Python, no JavaScript, no coding required. Connect multiple AI services, models, and APIs through simple declarative configuration.
+
+### 🔗 **Universal AI Service Integration**
+Connect to any AI provider out of the box—OpenAI, Anthropic Claude, Google Gemini, ElevenLabs, Stability AI, Replicate, or any custom HTTP API. Mix and match services in a single workflow.
+
+### 🖥️ **Local Model Execution**
+Run models from HuggingFace and other sources locally with native support for transformers, PyTorch, and model serving frameworks. Fine-tune models with LoRA/PEFT, train with custom datasets, all through YAML configuration.
+
+### ⚡ **Real-Time Streaming**
+Built-in SSE (Server-Sent Events) streaming for real-time AI responses. Stream from OpenAI, Claude, local models, or any streaming API with automatic chunking and connection management.
+
+### 🔄 **Advanced Workflow Composition**
+Build multi-step pipelines with conditional logic, data transformation, and parallel execution. Pass data between jobs with powerful variable binding—`${input}`, `${response}`, `${env}`, with type conversion and defaults.
+
+### 🚀 **Production-Ready Controllers**
+Deploy as HTTP REST API or MCP (Model Context Protocol) server by changing one line. Includes concurrency control, health checks, and automatic API documentation.
+
+### 🎯 **Event-Driven Architecture**
+HTTP Callback listeners for async workflows (image generation, video processing). HTTP Trigger listeners for webhooks and external events. Build reactive AI systems that respond to real-world events.
+
+### 🌐 **Smart Tunneling & Gateways**
+Expose local services to the internet instantly with ngrok, Cloudflare, or SSH tunnels. Perfect for webhook integration, Slack bots, and public API deployment without complex networking.
+
+### 🐳 **Container-Native Deployment**
+First-class Docker support with runtime configuration, volume mounting, and environment management. Deploy to any cloud provider or Kubernetes cluster with minimal configuration.
+
+### 🎨 **Instant Web UI**
+Add a visual interface with just 2 lines—get Gradio-powered chat UI or serve custom static frontends. Test workflows, monitor executions, and debug pipelines visually.
+
+### 🗄️ **RAG & Vector Database Ready**
+Native integration with ChromaDB, Milvus, Pinecone, and Weaviate. Build retrieval-augmented generation (RAG) systems with embedding search, document indexing, and semantic retrieval.
+
+### 🔧 **Flexible Component System**
+Reusable components with multi-action support. Define once, use everywhere. Mix HTTP clients, local models, vector stores, shell commands, and custom workflows in any combination.
 
 ---
 
@@ -105,37 +133,30 @@ model-compose up
 
 Your API is now live at `http://localhost:8080` and Web UI at `http://localhost:8081` 🎉
 
-> 💡 Explore [examples](examples/README.md) for more workflows or read the [User Guide](docs/user-guide/README.md).
-
 ---
-## 💡 Key Capabilities
 
-### 🖥️ Built-in Web UI
-Add a web interface by adding just 2 lines to your YAML:
+## 🎯 Powerful Yet Simple
+
+### 🖥️ Add Web UI with 2 Lines
 ```yaml
 controller:
   webui:
     port: 8081
 ```
-Instantly get a user-friendly interface to test and monitor your workflows. Supports both Gradio (default) and custom static frontends.
 
-### 🛰️ MCP Server Ready
-Transform your workflows into MCP tools by changing one line:
+### 🛰️ Switch to MCP Server with 1 Line
 ```yaml
 controller:
   type: mcp-server
 ```
-Just set the type to `mcp-server`. Your workflows become instantly accessible via the Model Context Protocol.
 
-### 🐳 Docker Deployment
-Deploy anywhere with built-in Docker support:
+### 🐳 Deploy in Docker with 1 Line
 ```yaml
 controller:
   runtime: docker
 ```
-Run your workflows in isolated containers with full control over images, volumes, ports, and environment variables.
 
-> 📖 See the [User Guide](docs/user-guide/README.md) for detailed configuration and [Examples](examples/README.md) for ready-to-run samples.
+> 💡 Explore [examples](examples/README.md) for more workflows or read the [User Guide](docs/user-guide/README.md).
 
 ---
 ## 🏗 Architecture

{model_compose-0.4.19 → model_compose-0.4.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.4.19"
+version = "0.4.20"
 description = "model-compose: Declarative AI Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }

{model_compose-0.4.19 → model_compose-0.4.20}/src/mindor/core/component/base.py

@@ -5,6 +5,7 @@ from mindor.dsl.schema.action import ActionConfig
 from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.gateway import GatewayConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
+from mindor.dsl.schema.runtime import ProcessRuntimeConfig
 from mindor.core.foundation import AsyncService
 from mindor.core.utils.work_queue import WorkQueue
 from mindor.core.logger import logging
@@ -50,15 +51,31 @@ class ComponentService(AsyncService):
         self.config: ComponentConfig = config
         self.global_configs: ComponentGlobalConfigs = global_configs
         self.work_queue: Optional[WorkQueue] = None
+        self._process_manager = None
 
         if self.config.max_concurrent_count > 0:
             self.work_queue = WorkQueue(self.config.max_concurrent_count, self._run)
 
     async def start(self, background: bool = False) -> None:
+        if isinstance(self.config.runtime, ProcessRuntimeConfig):
+            from mindor.core.component.runtime import ComponentProcessRuntimeManager
+
+            self._process_manager = ComponentProcessRuntimeManager(
+                self.id,
+                self.config,
+                self.global_configs
+            )
+            await self._process_manager.start()
+            logging.info(f"Component {self.id} started in separate process")
+            return
+        
         await super().start(background)
         await self.wait_until_ready()
 
     async def run(self, action_id: str, run_id: str, input: Dict[str, Any]) -> Dict[str, Any]:
+        if self._process_manager:
+            return await self._process_manager.run(action_id, run_id, input)
+
         _, action = ActionResolver(self.config.actions).resolve(action_id)
         context = ComponentActionContext(run_id, input)
 
@@ -67,6 +84,13 @@ class ComponentService(AsyncService):
 
         return await self._run(action, context)
 
+    async def stop(self) -> None:
+        if self._process_manager:
+            await self._process_manager.stop()
+            return
+        
+        await super().stop()
+
     async def _start(self) -> None:
         if self.work_queue:
             await self.work_queue.start()

model_compose-0.4.20/src/mindor/core/component/runtime/__init__.py

@@ -0,0 +1,2 @@
+from .process_worker import *
+from .process_manager import *

model_compose-0.4.20/src/mindor/core/component/runtime/process_manager.py

@@ -0,0 +1,70 @@
+from typing import Any, Dict
+from mindor.core.foundation import ProcessRuntimeManager
+from mindor.core.component.base import ComponentGlobalConfigs
+from mindor.core.component.runtime.process_worker import ComponentProcessWorker
+from mindor.dsl.schema.component import ComponentConfig
+from mindor.dsl.schema.runtime import ProcessRuntimeConfig
+from multiprocessing import Queue
+from functools import partial
+
+class ComponentProcessRuntimeManager(ProcessRuntimeManager):
+    """Process runtime manager for components"""
+
+    def __init__(
+        self,
+        component_id: str,
+        config: ComponentConfig,
+        global_configs: ComponentGlobalConfigs
+    ):
+        if not isinstance(config.runtime, ProcessRuntimeConfig):
+            raise ValueError("ComponentProcessRuntimeManager requires ProcessRuntimeConfig")
+
+        self.config = config
+        self.global_configs = global_configs
+
+        # Create a partial function that's picklable
+        # Pass config and global_configs directly to the factory
+        worker_factory = partial(
+            self._component_worker_factory,
+            config=config,
+            global_configs=global_configs
+        )
+
+        super().__init__(
+            worker_id=component_id,
+            runtime_config=config.runtime,
+            worker_factory=worker_factory
+        )
+
+    def _component_worker_factory(
+        self,
+        worker_id: str,
+        request_queue: Queue,
+        response_queue: Queue,
+        config: ComponentConfig,
+        global_configs: ComponentGlobalConfigs
+    ) -> ComponentProcessWorker:
+        """Instance factory method for ComponentProcessWorker
+
+        This function is picklable and receives config directly as parameters.
+        """
+        return ComponentProcessWorker(
+            worker_id,
+            config,
+            global_configs,
+            request_queue,
+            response_queue
+        )
+
+    async def run(
+        self,
+        action_id: str,
+        run_id: str,
+        input_data: Dict[str, Any]
+    ) -> Any:
+        """Execute component action"""
+        return await self.execute({
+            "action_id": action_id,
+            "run_id": run_id,
+            "input": input_data
+        })

model_compose-0.4.20/src/mindor/core/component/runtime/process_worker.py

@@ -0,0 +1,56 @@
+from typing import Any, Dict
+from mindor.core.foundation import ProcessWorker
+from mindor.core.component.base import ComponentGlobalConfigs
+from mindor.core.component.component import create_component
+from mindor.dsl.schema.component import ComponentConfig
+from mindor.dsl.schema.runtime import EmbeddedRuntimeConfig
+from mindor.core.logger import logging
+from multiprocessing import Queue
+
+class ComponentProcessWorker(ProcessWorker):
+    """Worker for running components in separate processes"""
+
+    def __init__(
+        self,
+        component_id: str,
+        config: ComponentConfig,
+        global_configs: ComponentGlobalConfigs,
+        request_queue: Queue,
+        response_queue: Queue
+    ):
+        super().__init__(component_id, request_queue, response_queue)
+        self.config = config
+        self.global_configs = global_configs
+        self.component = None
+
+    async def _initialize(self) -> None:
+        """Initialize and start the component"""
+        embedded_config = self.config.model_copy(deep=True)
+        embedded_config.runtime = EmbeddedRuntimeConfig(type="embedded")
+
+        self.component = create_component(
+            self.worker_id,
+            embedded_config,
+            self.global_configs,
+            daemon=True
+        )
+
+        await self.component.setup()
+        await self.component.start()
+
+        logging.info(f"Component {self.worker_id} started in subprocess")
+
+    async def _execute_task(self, payload: Dict[str, Any]) -> Any:
+        """Execute component action"""
+        action_id = payload["action_id"]
+        run_id = payload["run_id"]
+        input_data = payload["input"]
+
+        output = await self.component.run(action_id, run_id, input_data)
+        return output
+
+    async def _cleanup(self) -> None:
+        """Clean up the component"""
+        if self.component:
+            await self.component.stop()
+            await self.component.teardown()

{model_compose-0.4.19 → model_compose-0.4.20}/src/mindor/core/controller/runtime/docker/docker.py

@@ -26,6 +26,12 @@ class DockerRuntimeLauncher:
         if not self.config.runtime.ports:
             self.config.runtime.ports = [ port for port in [ self.config.port, getattr(self.config.webui, "port", None) ] if port ]
 
+        # Automatically add host.docker.internal for host machine access
+        if not self.config.runtime.extra_hosts:
+            self.config.runtime.extra_hosts = {}
+        if "host.docker.internal" not in self.config.runtime.extra_hosts:
+            self.config.runtime.extra_hosts["host.docker.internal"] = "host-gateway"
+
     async def launch(self, specs: ControllerRuntimeSpecs, detach: bool) -> None:
         docker = DockerRuntimeManager(self.config.runtime, self.verbose)
 

model_compose-0.4.20/src/mindor/core/foundation/__init__.py

@@ -0,0 +1,5 @@
+from .async_service import *
+from .ipc_protocol import *
+from .process_worker import *
+from .process_manager import *
+

model_compose-0.4.20/src/mindor/core/foundation/ipc_protocol.py

@@ -0,0 +1,22 @@
+from typing import Optional, Dict, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+import time
+
+class IpcMessageType(str, Enum):
+    """IPC message types for process communication"""
+    START     = "start"
+    STOP      = "stop"
+    RUN       = "run"
+    RESULT    = "result"
+    ERROR     = "error"
+    HEARTBEAT = "heartbeat"
+    STATUS    = "status"
+    LOG       = "log"
+
+class IpcMessage(BaseModel):
+    """Message format for inter-process communication"""
+    type: IpcMessageType
+    request_id: str
+    payload: Optional[Dict[str, Any]] = None
+    timestamp: int = Field(default_factory=lambda: int(time.time() * 1000))

model_compose-0.4.20/src/mindor/core/foundation/process_manager.py

@@ -0,0 +1,187 @@
+from typing import Any, Dict, Optional, Callable
+from mindor.dsl.schema.runtime import ProcessRuntimeConfig
+from mindor.core.logger import logging
+from .ipc_protocol import IpcMessage, IpcMessageType
+from multiprocessing import Process, Queue
+import asyncio, os, uuid, time
+
+class ProcessRuntimeManager:
+    """
+    Generic process runtime manager for running workers in separate processes.
+
+    Can be used for use cases requiring process isolation.
+    """
+
+    def __init__(
+        self,
+        worker_id: str,
+        runtime_config: ProcessRuntimeConfig,
+        worker_factory: Callable[[str, Queue, Queue], Any]
+    ):
+        """
+        Args:
+            worker_id: Worker identifier
+            runtime_config: Process runtime configuration
+            worker_factory: Factory function to create worker instance
+                           (worker_id, request_queue, response_queue) -> Worker
+        """
+        self.worker_id = worker_id
+        self.runtime_config = runtime_config
+        self.worker_factory = worker_factory
+
+        self.subprocess: Optional[Process] = None
+        self.request_queue: Optional[Queue] = None
+        self.response_queue: Optional[Queue] = None
+        self.pending_requests: Dict[str, asyncio.Future] = {}
+        self.response_handler_task: Optional[asyncio.Task] = None
+
+    async def start(self) -> None:
+        """Start the subprocess"""
+        self.request_queue  = Queue()
+        self.response_queue = Queue()
+
+        self.subprocess = Process(
+            target=self._run_worker,
+            args=(
+                self.worker_id,
+                self.request_queue,
+                self.response_queue
+            ),
+            daemon=False
+        )
+
+        if self.runtime_config.env:
+            for key, value in self.runtime_config.env.items():
+                os.environ[key] = value
+
+        self.subprocess.start()
+        logging.info(f"Started subprocess for worker {self.worker_id} (PID: {self.subprocess.pid})")
+
+        await self._wait_for_ready()
+
+        self.response_handler_task = asyncio.create_task(
+            self._handle_responses()
+        )
+
+    async def stop(self) -> None:
+        """Stop the subprocess"""
+        logging.info(f"Stopping subprocess for worker {self.worker_id}")
+
+        stop_message = IpcMessage(
+            type=IpcMessageType.STOP,
+            request_id=str(uuid.uuid4())
+        )
+        self.request_queue.put(stop_message.model_dump())
+
+        timeout_seconds = self._parse_timeout(self.runtime_config.stop_timeout)
+
+        try:
+            self.subprocess.join(timeout=timeout_seconds)
+        except TimeoutError:
+            logging.warning(f"Process {self.worker_id} did not stop gracefully, terminating")
+            self.subprocess.terminate()
+            self.subprocess.join(timeout=5)
+            if self.subprocess.is_alive():
+                logging.error(f"Process {self.worker_id} did not terminate, killing")
+                self.subprocess.kill()
+
+        if self.response_handler_task:
+            self.response_handler_task.cancel()
+
+    async def execute(self, payload: Dict[str, Any]) -> Any:
+        """Execute a task in the subprocess"""
+        request_id = str(uuid.uuid4())
+
+        message = IpcMessage(
+            type=IpcMessageType.RUN,
+            request_id=request_id,
+            payload=payload
+        )
+
+        future = asyncio.get_event_loop().create_future()
+        self.pending_requests[request_id] = future
+
+        self.request_queue.put(message.model_dump())
+
+        try:
+            result = await future
+            return result
+        finally:
+            self.pending_requests.pop(request_id, None)
+
+    async def _handle_responses(self) -> None:
+        """Handle responses from the subprocess"""
+        while True:
+            try:
+                if not self.response_queue.empty():
+                    message_dict = self.response_queue.get_nowait()
+                    message = IpcMessage(**message_dict)
+
+                    if message.request_id in self.pending_requests:
+                        future = self.pending_requests[message.request_id]
+
+                        if message.type == IpcMessageType.RESULT:
+                            future.set_result(message.payload.get("output"))
+                        elif message.type == IpcMessageType.ERROR:
+                            error = message.payload.get("error", "Unknown error")
+                            future.set_exception(Exception(error))
+
+                await asyncio.sleep(0.01)
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logging.error(f"Error handling response: {e}")
+
+    async def _wait_for_ready(self) -> None:
+        """Wait for subprocess to be ready"""
+        timeout = self._parse_timeout(self.runtime_config.start_timeout)
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            if not self.response_queue.empty():
+                message_dict = self.response_queue.get()
+                message = IpcMessage(**message_dict)
+
+                if message.type == IpcMessageType.RESULT and \
+                   message.payload.get("status") == "ready":
+                    logging.info(f"Subprocess {self.worker_id} is ready")
+                    return
+
+            await asyncio.sleep(0.5)
+
+        raise TimeoutError(
+            f"Process {self.worker_id} did not start within {timeout}s"
+        )
+
+    def _run_worker(
+        self,
+        worker_id: str,
+        request_queue: Queue,
+        response_queue: Queue
+    ) -> None:
+        """Subprocess entry point"""
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+        worker = self.worker_factory(worker_id, request_queue, response_queue)
+
+        try:
+            loop.run_until_complete(worker.run())
+        except KeyboardInterrupt:
+            pass
+        finally:
+            loop.close()
+
+    @staticmethod
+    def _parse_timeout(timeout_str: str) -> float:
+        """Parse timeout string (e.g., '60s', '2m') to seconds"""
+        timeout_str = timeout_str.strip().lower()
+
+        if timeout_str.endswith('s'):
+            return float(timeout_str[:-1])
+        elif timeout_str.endswith('m'):
+            return float(timeout_str[:-1]) * 60
+        elif timeout_str.endswith('h'):
+            return float(timeout_str[:-1]) * 3600
+        else:
+            return float(timeout_str)