codemie-mcp-workflows 0.2.0__py3-none-any.whl

codemie_mcp_workflows/__init__.py

@@ -0,0 +1,15 @@
+"""Workflow execution MCP implementation."""
+
+from .model import (
+    WorkflowExecutionStatus,
+    WorkflowExecutionRequest,
+    WorkflowExecutionResponse,
+)
+from .server import execute_workflow
+
+__all__ = [
+    'WorkflowExecutionStatus',
+    'WorkflowExecutionRequest',
+    'WorkflowExecutionResponse',
+    'execute_workflow',
+]

codemie_mcp_workflows/model.py

@@ -0,0 +1,146 @@
+"""Workflow execution models."""
+import os
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class WorkflowAuthConfig(BaseModel):
+    """Authentication configuration with support for multiple auth methods."""
+    username: Optional[str] = Field(
+        default=None,
+        description="Username for password-based authentication"
+    )
+    password: Optional[str] = Field(
+        default=None,
+        description="Password for password-based authentication"
+    )
+    client_id: str = Field(
+        default="codemie-sdk",
+        description="Client ID for authentication"
+    )
+    client_secret: Optional[str] = Field(
+        default=None,
+        description="Client secret for client credentials"
+    )
+
+    @model_validator(mode="after")
+    def validate_auth_method(self) -> "WorkflowAuthConfig":
+        """Validates that either username/password or client credentials are provided."""
+        has_user_pass = bool(self.username and self.password)
+        has_client_creds = bool(self.client_id and self.client_secret)
+
+        if not (has_user_pass or has_client_creds):
+            raise ValueError(
+                "Authentication configuration missing. Please provide either:\n"
+                "- CODEMIE_USERNAME and CODEMIE_PASSWORD for password authentication\n"
+                "- CODEMIE_AUTH_CLIENT_ID and CODEMIE_AUTH_CLIENT_SECRET for client credentials"
+            )
+        return self
+
+
+REQUIRED_SETTINGS = (
+    "CODEMIE_AUTH_SERVER_URL",
+    "CODEMIE_AUTH_REALM_NAME",
+    "CODEMIE_API_DOMAIN",
+)
+
+_TRUE_VALUES = ("", "true", "1", "yes", "on")
+_FALSE_VALUES = ("false", "0", "no", "off")
+
+
+def _read_required_settings() -> dict:
+    """Returns the required settings; raises one ValueError naming every missing one."""
+    values = {name: os.environ.get(name, "").strip() for name in REQUIRED_SETTINGS}
+    missing = [name for name, value in values.items() if not value]
+    if missing:
+        raise ValueError("Missing required settings: " + ", ".join(missing))
+    return values
+
+
+def _read_verify_ssl() -> bool:
+    """Parses CODEMIE_VERIFY_SSL strictly; TLS verification stays on unless disabled explicitly."""
+    value = os.environ.get("CODEMIE_VERIFY_SSL", "").strip().lower()
+    if value in _TRUE_VALUES:
+        return True
+    if value in _FALSE_VALUES:
+        return False
+    raise ValueError(
+        "Invalid value for CODEMIE_VERIFY_SSL: use true or false"
+    )
+
+
+class WorkflowSettings:
+    """Application settings configured via environment variables."""
+    # Default values as class variables
+    DEFAULT_AUTH_CLIENT_ID = "codemie-sdk"
+
+    auth: WorkflowAuthConfig
+    api_domain: str
+    auth_realm_name: str
+    auth_server_url: str
+    verify_ssl: bool = True
+
+    def __init__(self):
+        required = _read_required_settings()
+        # Authentication settings
+        self.auth = WorkflowAuthConfig(
+            username=os.environ.get("CODEMIE_USERNAME"),
+            password=os.environ.get("CODEMIE_PASSWORD"),
+            client_id=os.environ.get(
+                "CODEMIE_AUTH_CLIENT_ID", self.DEFAULT_AUTH_CLIENT_ID
+            ),
+            client_secret=os.environ.get("CODEMIE_AUTH_CLIENT_SECRET"),
+        )
+
+        # Server configuration
+        self.auth_client_id = os.environ.get(
+            "CODEMIE_AUTH_CLIENT_ID", self.DEFAULT_AUTH_CLIENT_ID
+        )
+        self.auth_realm_name = required["CODEMIE_AUTH_REALM_NAME"]
+        self.auth_server_url = required["CODEMIE_AUTH_SERVER_URL"]
+        self.api_domain = required["CODEMIE_API_DOMAIN"]
+        self.verify_ssl = _read_verify_ssl()
+
+
+class WorkflowExecutionStatus(str, Enum):
+    """Status of workflow execution"""
+    NOT_STARTED = "Not Started"
+    IN_PROGRESS = "In Progress"
+    SUCCEEDED = "Succeeded"
+    FAILED = "Failed"
+    INTERRUPTED = "Interrupted"
+    ABORTED = "Aborted"
+
+
+class WorkflowExecutionResponse(BaseModel):
+    """Response model for workflow execution"""
+    id: str = Field(..., description="Unique identifier of the workflow")
+    execution_id: str = Field(..., description="Unique identifier of the execution")
+    workflow_id: str = Field(..., description="ID of the executed workflow")
+    status: WorkflowExecutionStatus = Field(
+        ..., 
+        alias="overall_status",
+        description="Current execution status"
+    )
+    created_date: datetime = Field(
+        ..., 
+        alias="date",
+        description="Execution creation timestamp"
+    )
+    prompt: str = Field(..., description="User input/prompt for the execution")
+    updated_date: Optional[datetime] = Field(None, description="Last update timestamp")
+    
+    class Config:
+        populate_by_name = True
+
+
+class WorkflowExecutionRequest(BaseModel):
+    """Request model for workflow execution"""
+    workflow_id: str = Field(..., description="ID of the workflow to execute")
+    user_input: str = Field(
+        default="",
+        description="Optional user input/prompt for the workflow"
+    )

codemie_mcp_workflows/server.py

@@ -0,0 +1,109 @@
+"""Workflow execution MCP server implementation."""
+
+import sys
+from typing import Dict, Any
+
+from mcp.server.fastmcp import FastMCP
+
+from codemie_sdk import CodeMieClient
+from .model import (
+    WorkflowExecutionRequest,
+    WorkflowExecutionResponse,
+    WorkflowSettings
+)
+
+# Initialize settings at module level
+try:
+    settings = WorkflowSettings()
+except Exception as e:
+    print(f"Error initializing settings: {str(e)}", file=sys.stderr)
+    sys.exit(1)
+
+
+def get_client() -> CodeMieClient:
+    """Gets authenticated CodeMie client instance."""
+    try:
+        client = CodeMieClient(
+            username=settings.auth.username,
+            password=settings.auth.password,
+            auth_client_id=settings.auth.client_id,
+            auth_client_secret=settings.auth.client_secret,
+            verify_ssl=settings.verify_ssl,
+            auth_realm_name=settings.auth_realm_name,
+            auth_server_url=settings.auth_server_url,
+            codemie_api_domain=settings.api_domain,
+        )
+
+        if not client.token:
+            print("Failed to obtain authentication token", file=sys.stderr)
+            raise ValueError("Failed to obtain authentication token")
+
+        print("Successfully initialized CodeMie client", file=sys.stderr)
+        return client
+    except Exception as e:
+        print(f"Error initializing client: {str(e)}", file=sys.stderr)
+        raise
+
+# Initialize FastMCP server
+mcp = FastMCP("codemie-workflows")
+
+
+@mcp.tool()
+async def execute_workflow(workflow_id: str, user_input: str = "") -> Dict[str, Any]:
+    """
+    Execute a workflow with the given ID and optional user input.
+    
+    Args:
+        workflow_id: ID of the workflow to execute
+        user_input: Optional user input/prompt for the workflow
+    
+    Returns:
+        Dictionary containing execution details including:
+        - id: Workflow identifier
+        - execution_id: Unique identifier for this execution
+        - workflow_id: Source workflow ID
+        - status: Current execution status
+        - date: Creation timestamp
+        - prompt: User input that triggered the execution
+        - updated_date: Last update timestamp (if available)
+    
+    Raises:
+        ValueError: If workflow_id is invalid or missing
+        Exception: For other execution errors
+    """
+    try:
+        # Input validation
+        request = WorkflowExecutionRequest(
+            workflow_id=workflow_id,
+            user_input=user_input
+        )
+        
+        # Get client and execute workflow
+        client = get_client()
+        response = client.workflows.run(
+            workflow_id=request.workflow_id,
+            user_input=request.user_input
+        )
+        
+        # Validate and return response
+        execution_response = WorkflowExecutionResponse.model_validate(response)
+        return execution_response.model_dump(exclude_none=True)
+        
+    except ValueError as ve:
+        print(f"Validation error: {str(ve)}", file=sys.stderr)
+        raise
+    except Exception as e:
+        print(f"Error executing workflow {workflow_id}: {str(e)}", file=sys.stderr)
+        raise
+
+def main():
+    try:
+        print("Starting CodeMie Workflows MCP server", file=sys.stderr)
+        # Initialize and run the server
+        mcp.run(transport="stdio")
+    except Exception as e:
+        print(f"Error starting MCP server: {str(e)}", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

codemie_mcp_workflows-0.2.0.dist-info/METADATA

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: codemie-mcp-workflows
+Version: 0.2.0
+Summary: MCP server for connecting to CodeMie Workflows API
+License: Apache-2.0
+Author: EPAM Systems
+Requires-Python: >=3.12,<4.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Requires-Dist: certifi (>=2025.1.31)
+Requires-Dist: codemie-sdk-python (>=0.1.620,<0.2)
+Requires-Dist: httpx (>=0.27.0,<0.28.0)
+Requires-Dist: mcp (>=1.6.0,<2.0.0)
+Requires-Dist: pydantic (>=2.11.2,<3.0.0)
+Project-URL: Homepage, https://github.com/codemie-ai/codemie-mcp-servers
+Project-URL: Repository, https://github.com/codemie-ai/codemie-mcp-servers
+Description-Content-Type: text/markdown
+
+# CodeMie Workflows MCP Server
+
+Python server implementing Model Context Protocol (MCP) for CodeMie Workflows operations.
+
+## Features
+- Execute CodeMie workflows
+- Manage workflow executions
+- Integration with CodeMie Workflow API
+
+Note: The server requires authentication credentials via environment variables.
+
+## API
+
+### Tools
+
+#### execute
+Execute a specific workflow
+Inputs:
+- `workflow_id (string)`: Workflow identifier to execute
+- `parameters (object, optional)`: Workflow execution parameters
+- `execution_id (string, optional)`: Custom execution identifier
+
+Returns workflow execution details and status
+
+## Breaking changes in 0.2.0
+
+- The Python package is now `codemie_mcp_workflows`. The command `codemie-mcp-workflows` is unchanged.
+- The server no longer has built-in server addresses. `CODEMIE_AUTH_SERVER_URL`, `CODEMIE_AUTH_REALM_NAME` and `CODEMIE_API_DOMAIN` are required. Without them the server exits with an error.
+
+## Installation
+
+Ensure you have `Python 3.12` or later installed.
+
+**Important:** Before running the MCP server, you must configure the required environment variables (see [Environment Variables](#environment-variables) section below).
+
+### Using uv (recommended)
+
+When using [`uv`](https://docs.astral.sh/uv/) no specific installation is needed. We will
+use [`uvx`](https://docs.astral.sh/uv/guides/tools/) to directly run *codemie-mcp-workflows*.
+
+```bash
+uvx codemie-mcp-workflows
+```
+
+### Using pip
+
+Alternatively you can install the package with pip:
+
+```bash
+pip install codemie-mcp-workflows
+```
+
+After installation, you can run it as a script using:
+
+```bash
+codemie-mcp-workflows
+```
+
+## Configuration 
+
+### Configure for Claude.app
+
+Add to your Claude settings:
+
+<details>
+<summary>Using uvx</summary>
+
+**Required variables:**
+```json
+"mcpServers": {
+  "codemie-workflows": {
+    "command": "uvx",
+    "args": ["codemie-mcp-workflows"],
+    "env": {
+      "CODEMIE_AUTH_SERVER_URL": "https://auth.example.com/auth",
+      "CODEMIE_AUTH_REALM_NAME": "your-realm",
+      "CODEMIE_API_DOMAIN": "https://codemie.example.com/code-assistant-api",
+      "CODEMIE_USERNAME": "your-username",
+      "CODEMIE_PASSWORD": "your-password"
+    }
+  }
+}
+```
+
+**Optional variables:**
+```json
+"env": {
+  "CODEMIE_AUTH_CLIENT_ID": "codemie-sdk",
+  "CODEMIE_VERIFY_SSL": "true"
+}
+```
+</details>
+
+<details>
+<summary>Using pip installation</summary>
+
+**Required variables:**
+```json
+"mcpServers": {
+  "codemie-workflows": {
+    "command": "codemie-mcp-workflows",
+    "args": [],
+    "env": {
+      "CODEMIE_AUTH_SERVER_URL": "https://auth.example.com/auth",
+      "CODEMIE_AUTH_REALM_NAME": "your-realm",
+      "CODEMIE_API_DOMAIN": "https://codemie.example.com/code-assistant-api",
+      "CODEMIE_USERNAME": "your-username",
+      "CODEMIE_PASSWORD": "your-password"
+    }
+  }
+}
+```
+
+**Optional variables:**
+```json
+"env": {
+  "CODEMIE_AUTH_CLIENT_ID": "codemie-sdk",
+  "CODEMIE_VERIFY_SSL": "true"
+}
+```
+</details>
+
+### Environment Variables
+
+#### Mandatory Variables
+
+The following environment variables **must** be configured before running the MCP server:
+
+**Platform settings (all three are required, an empty value counts as missing):**
+- `CODEMIE_AUTH_SERVER_URL`: URL of your authentication server, for example `https://auth.example.com/auth`
+- `CODEMIE_AUTH_REALM_NAME`: authentication realm name
+- `CODEMIE_API_DOMAIN`: URL of your CodeMie API, for example `https://codemie.example.com/code-assistant-api`
+
+The server has no built-in addresses. If any of the three is missing it prints `Missing required settings: <names>` and exits with a non-zero code, before any network call.
+
+**Authentication (choose one method):**
+
+*Option 1: Username/Password*
+- `CODEMIE_USERNAME`: Your CodeMie username
+- `CODEMIE_PASSWORD`: Your CodeMie password
+
+*Option 2: Client Credentials*
+- `CODEMIE_AUTH_CLIENT_SECRET`: Auth client secret
+
+#### Optional Variables
+
+- `CODEMIE_AUTH_CLIENT_ID`: authentication client ID (default: `codemie-sdk`)
+
+- `CODEMIE_VERIFY_SSL`: TLS certificate verification flag (default: `true`). Set `false` only for local testing.
+

codemie_mcp_workflows-0.2.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+codemie_mcp_workflows/__init__.py,sha256=e3KMvA8fwzW6bIGQyychNGMCxiI93N2W7wG4ZXz8Zlc,330
+codemie_mcp_workflows/model.py,sha256=CeXiu4P29rntJToXR2fRJVxyl9U2Ui4y6hiHjlpIB2o,5030
+codemie_mcp_workflows/server.py,sha256=5U4PvUESbelda_uTrEALkmL0Pqz7gx9rdJbePD5fMfs,3441
+codemie_mcp_workflows-0.2.0.dist-info/METADATA,sha256=wWX5BQSjb2typ_5WcZGEGmK1Cgfvnm8LemMf6EzACAY,4990
+codemie_mcp_workflows-0.2.0.dist-info/WHEEL,sha256=L-WvLdSBvJWHXv5zrQxDvNRnIgoBzLUpcbuiw19KCuQ,88
+codemie_mcp_workflows-0.2.0.dist-info/entry_points.txt,sha256=-MkOEJGwWylUMZdXu8WPcCT7dsNjr2iRJOYUMnYmOYc,75
+codemie_mcp_workflows-0.2.0.dist-info/RECORD,,

codemie_mcp_workflows-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.5.0
+Root-Is-Purelib: true
+Tag: py3-none-any

codemie_mcp_workflows-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+codemie-mcp-workflows=codemie_mcp_workflows.server:main
+