edda-framework 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

edda/__init__.py

@@ -30,6 +30,7 @@ from edda.hooks import HooksBase, WorkflowHooks
 from edda.outbox import OutboxRelayer, send_event_transactional
 from edda.retry import RetryPolicy
 from edda.workflow import workflow
+from edda.wsgi import create_wsgi_app
 
 __version__ = "0.1.0"
 
@@ -53,4 +54,5 @@ __all__ = [
     "RetryPolicy",
     "RetryExhaustedError",
     "TerminalError",
+    "create_wsgi_app",
 ]

edda/activity.py

@@ -13,6 +13,8 @@ import time
 from collections.abc import Callable
 from typing import Any, TypeVar, cast
 
+import anyio
+
 from edda.context import WorkflowContext
 from edda.exceptions import RetryExhaustedError, TerminalError, WorkflowCancelledException
 from edda.pydantic_utils import (
@@ -40,12 +42,13 @@ class Activity:
         Initialize activity wrapper.
 
         Args:
-            func: The async function to wrap
+            func: The async or sync function to wrap
             retry_policy: Optional retry policy for this activity.
                          If None, uses the default policy from EddaApp.
         """
         self.func = func
         self.name = func.__name__
+        self.is_async = inspect.iscoroutinefunction(func)
         self.retry_policy = retry_policy
         functools.update_wrapper(self, func)
 
@@ -284,8 +287,12 @@ class Activity:
             "kwargs": {k: to_json_dict(v) for k, v in kwargs.items()},
         }
 
-        # Execute the activity function
-        result = await self.func(ctx, *args, **kwargs)
+        # Execute the activity function (sync or async)
+        if self.is_async:
+            result = await self.func(ctx, *args, **kwargs)
+        else:
+            # Run sync function in thread pool to avoid blocking
+            result = await anyio.to_thread.run_sync(self.func, ctx, *args, **kwargs)
 
         # Convert Pydantic model result to JSON dict for storage
         result_for_storage = to_json_dict(result)
@@ -369,7 +376,7 @@ class Activity:
             return self.retry_policy
 
         # Priority 2: App-level policy (EddaApp default_retry_policy)
-        # Note: This will be implemented in Phase 5 (edda/app.py)
+        # Set by ReplayEngine when creating WorkflowContext (edda/replay.py)
         if hasattr(ctx, "_app_retry_policy") and ctx._app_retry_policy is not None:
             return cast(RetryPolicy, ctx._app_retry_policy)
 
@@ -426,8 +433,9 @@ def activity(
     """
     Decorator for defining activities (atomic units of work) with automatic retry.
 
-    Activities are async functions that take a WorkflowContext as the first
-    parameter, followed by any other parameters.
+    Activities can be async or sync functions that take a WorkflowContext as the first
+    parameter, followed by any other parameters. Sync functions are executed in a
+    thread pool to avoid blocking the event loop.
 
     Activities are automatically wrapped in a transaction, ensuring that
     activity execution, history recording, and event sending are atomic.
@@ -443,34 +451,39 @@ def activity(
     Workflow function.
 
     Example:
-        >>> @activity  # Uses default retry policy (5 attempts, exponential backoff)
-        ... async def reserve_inventory(ctx: WorkflowContext, order_id: str) -> dict:
-        ...     # Your business logic here
+        >>> @activity  # Sync activity (no async/await)
+        ... def reserve_inventory(ctx: WorkflowContext, order_id: str) -> dict:
+        ...     # Your business logic here (executed in thread pool)
+        ...     return {"reservation_id": "123"}
+
+        >>> @activity  # Async activity (recommended for I/O-bound operations)
+        ... async def reserve_inventory_async(ctx: WorkflowContext, order_id: str) -> dict:
+        ...     # Async I/O operations
         ...     return {"reservation_id": "123"}
 
         >>> from edda.retry import RetryPolicy, AGGRESSIVE_RETRY
         >>> @activity(retry_policy=AGGRESSIVE_RETRY)  # Custom retry policy
-        ... async def process_payment(ctx: WorkflowContext, amount: float) -> dict:
+        ... def process_payment(ctx: WorkflowContext, amount: float) -> dict:
         ...     # Fast retries for low-latency services
         ...     return {"status": "completed"}
 
         >>> @activity  # Non-idempotent operations cached during replay
-        ... async def charge_credit_card(ctx: WorkflowContext, amount: float) -> dict:
+        ... def charge_credit_card(ctx: WorkflowContext, amount: float) -> dict:
         ...     # External API call - result is cached, won't be called again on replay
         ...     # If this fails, automatic retry with exponential backoff
         ...     return {"transaction_id": "txn_123"}
 
         >>> from edda.exceptions import TerminalError
         >>> @activity
-        ... async def validate_user(ctx: WorkflowContext, user_id: str) -> dict:
-        ...     user = await fetch_user(user_id)
+        ... def validate_user(ctx: WorkflowContext, user_id: str) -> dict:
+        ...     user = fetch_user(user_id)  # No await needed for sync
         ...     if not user:
         ...         # Don't retry - user doesn't exist
         ...         raise TerminalError(f"User {user_id} not found")
         ...     return {"user_id": user_id, "name": user.name}
 
     Args:
-        func: Async function to wrap as an activity
+        func: Async or sync function to wrap as an activity
         retry_policy: Optional retry policy for this activity.
                      If None, uses the default policy from EddaApp.
 
@@ -480,14 +493,14 @@ def activity(
     Raises:
         RetryExhaustedError: When all retry attempts are exhausted
         TerminalError: For non-retryable errors (no retry attempted)
+
+    Sync activities are executed in a thread pool. For I/O-bound operations
+    (database queries, HTTP requests, etc.), async activities are recommended
+    for better performance.
     """
 
     def decorator(f: F) -> F:
-        # Verify the function is async
-        if not inspect.iscoroutinefunction(f):
-            raise TypeError(f"Activity {f.__name__} must be an async function")
-
-        # Create the Activity wrapper with retry policy
+        # Create the Activity wrapper with retry policy (supports both sync and async)
         activity_wrapper = Activity(f, retry_policy=retry_policy)
 
         # Mark as activity for introspection

edda/integrations/__init__.py

@@ -0,0 +1 @@
+"""Edda integrations package."""

edda/integrations/mcp/__init__.py

@@ -0,0 +1,40 @@
+"""
+Edda MCP (Model Context Protocol) Integration.
+
+Provides MCP server functionality for Edda durable workflows,
+enabling long-running workflow tools via the MCP protocol.
+
+Example:
+    ```python
+    from edda.integrations.mcp import EddaMCPServer
+    from edda import WorkflowContext, activity
+
+    server = EddaMCPServer(
+        name="Order Service",
+        db_url="postgresql://user:pass@localhost/orders",
+    )
+
+    @activity
+    async def reserve_inventory(ctx, items):
+        return {"reserved": True}
+
+    @server.durable_tool(description="Process order workflow")
+    async def process_order(ctx: WorkflowContext, order_id: str):
+        await reserve_inventory(ctx, [order_id], activity_id="reserve:1")
+        return {"status": "completed"}
+
+    # Deploy with uvicorn
+    if __name__ == "__main__":
+        import uvicorn
+        uvicorn.run(server.asgi_app(), host="0.0.0.0", port=8000)
+    ```
+
+The server automatically generates three MCP tools for each @durable_tool:
+- `tool_name`: Start the workflow, returns instance_id
+- `tool_name_status`: Check workflow status
+- `tool_name_result`: Get workflow result (if completed)
+"""
+
+from edda.integrations.mcp.server import EddaMCPServer
+
+__all__ = ["EddaMCPServer"]

edda/integrations/mcp/decorators.py

@@ -0,0 +1,168 @@
+"""Decorators for MCP durable tools."""
+
+from __future__ import annotations
+
+import inspect
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+from edda.workflow import workflow
+
+if TYPE_CHECKING:
+    from edda.integrations.mcp.server import EddaMCPServer
+    from edda.workflow import Workflow
+
+
+def create_durable_tool(
+    server: EddaMCPServer,
+    func: Callable,
+    *,
+    description: str = "",
+) -> Workflow:
+    """
+    Create a durable workflow tool with auto-generated status/result tools.
+
+    This function:
+    1. Wraps the function as an Edda @workflow
+    2. Registers three MCP tools:
+       - {name}: Start workflow, return instance_id
+       - {name}_status: Check workflow status
+       - {name}_result: Get workflow result
+
+    Args:
+        server: EddaMCPServer instance
+        func: Async workflow function
+        description: Tool description
+
+    Returns:
+        Workflow instance
+    """
+    # 1. Create Edda workflow
+    workflow_instance: Workflow = workflow(func, event_handler=False)
+    workflow_name = func.__name__
+
+    # Register in server's workflow registry
+    server._workflows[workflow_name] = workflow_instance
+
+    # 2. Generate main tool (start workflow)
+    tool_description = description or func.__doc__ or f"Start {workflow_name} workflow"
+
+    # Extract parameters from workflow function (excluding ctx)
+    sig = inspect.signature(func)
+    params = [
+        param
+        for name, param in sig.parameters.items()
+        if name != "ctx"  # Exclude WorkflowContext parameter
+    ]
+
+    # Create the tool function
+    async def start_tool(**kwargs: Any) -> dict:
+        """
+        Start workflow and return instance_id.
+
+        This is the main entry point for the durable tool.
+        """
+        # Remove 'ctx' if provided by client (workflow will inject it)
+        kwargs.pop("ctx", None)
+
+        # Start Edda workflow
+        instance_id = await workflow_instance.start(**kwargs)
+
+        # Return MCP-compliant response
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": (
+                        f"Workflow '{workflow_name}' started successfully.\n"
+                        f"Instance ID: {instance_id}\n\n"
+                        f"Use '{workflow_name}_status' tool with instance_id='{instance_id}' to check progress.\n"
+                        f"Use '{workflow_name}_result' tool to get the final result once completed."
+                    ),
+                }
+            ],
+            "isError": False,
+        }
+
+    # Override the function's signature for introspection (FastMCP uses this for schema generation)
+    start_tool.__signature__ = inspect.Signature(parameters=params)  # type: ignore[attr-defined]
+
+    # Register with FastMCP (call as function, not decorator syntax)
+    server._mcp.tool(name=workflow_name, description=tool_description)(start_tool)
+
+    # 3. Generate status tool
+    status_tool_name = f"{workflow_name}_status"
+    status_tool_description = f"Check status of {workflow_name} workflow"
+
+    @server._mcp.tool(name=status_tool_name, description=status_tool_description)
+    async def status_tool(instance_id: str) -> dict:
+        """Check workflow status."""
+        try:
+            instance = await server._edda_app.storage.get_instance(instance_id)
+
+            status = instance["status"]
+            current_activity_id = instance.get("current_activity_id", "N/A")
+
+            status_text = (
+                f"Workflow Status: {status}\n"
+                f"Current Activity: {current_activity_id}\n"
+                f"Instance ID: {instance_id}"
+            )
+
+            return {
+                "content": [{"type": "text", "text": status_text}],
+                "isError": False,
+            }
+        except Exception as e:
+            return {
+                "content": [
+                    {
+                        "type": "text",
+                        "text": f"Error checking status: {str(e)}",
+                    }
+                ],
+                "isError": True,
+            }
+
+    # 4. Generate result tool
+    result_tool_name = f"{workflow_name}_result"
+    result_tool_description = f"Get result of {workflow_name} workflow (if completed)"
+
+    @server._mcp.tool(name=result_tool_name, description=result_tool_description)
+    async def result_tool(instance_id: str) -> dict:
+        """Get workflow result (if completed)."""
+        try:
+            instance = await server._edda_app.storage.get_instance(instance_id)
+
+            status = instance["status"]
+
+            if status != "completed":
+                return {
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": f"Workflow not completed yet. Current status: {status}",
+                        }
+                    ],
+                    "isError": True,
+                }
+
+            output_data = instance.get("output_data")
+            result_text = f"Workflow Result:\n{output_data}"
+
+            return {
+                "content": [{"type": "text", "text": result_text}],
+                "isError": False,
+            }
+        except Exception as e:
+            return {
+                "content": [
+                    {
+                        "type": "text",
+                        "text": f"Error getting result: {str(e)}",
+                    }
+                ],
+                "isError": True,
+            }
+
+    return workflow_instance

edda/integrations/mcp/server.py

@@ -0,0 +1,257 @@
+"""MCP Server implementation for Edda workflows."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from edda.app import EddaApp
+from edda.workflow import Workflow
+
+try:
+    from mcp.server.fastmcp import FastMCP
+except ImportError as e:
+    raise ImportError(
+        "MCP Python SDK is required for MCP integration. "
+        "Install it with: pip install edda-framework[mcp]"
+    ) from e
+
+
+class EddaMCPServer:
+    """
+    MCP (Model Context Protocol) server for Edda durable workflows.
+
+    Integrates EddaApp (CloudEvents + Workflows) with FastMCP to provide
+    long-running workflow tools via the MCP protocol.
+
+    Example:
+        ```python
+        from edda.integrations.mcp import EddaMCPServer
+        from edda import WorkflowContext, activity
+
+        server = EddaMCPServer(
+            name="Order Service",
+            db_url="postgresql://user:pass@localhost/orders",
+        )
+
+        @activity
+        async def reserve_inventory(ctx, items):
+            return {"reserved": True}
+
+        @server.durable_tool(description="Process order workflow")
+        async def process_order(ctx: WorkflowContext, order_id: str):
+            await reserve_inventory(ctx, [order_id], activity_id="reserve:1")
+            return {"status": "completed"}
+
+        # Deploy with uvicorn (HTTP transport)
+        if __name__ == "__main__":
+            import uvicorn
+            uvicorn.run(server.asgi_app(), host="0.0.0.0", port=8000)
+
+        # Or deploy with stdio (for MCP clients, e.g., Claude Desktop)
+        if __name__ == "__main__":
+            import asyncio
+
+            async def main():
+                await server.initialize()
+                await server.run_stdio()
+
+            asyncio.run(main())
+        ```
+
+    The server automatically generates three MCP tools for each @durable_tool:
+    - `tool_name`: Start the workflow, returns instance_id
+    - `tool_name_status`: Check workflow status
+    - `tool_name_result`: Get workflow result (if completed)
+    """
+
+    def __init__(
+        self,
+        name: str,
+        db_url: str,
+        *,
+        outbox_enabled: bool = False,
+        broker_url: str | None = None,
+        token_verifier: Callable[[str], bool] | None = None,
+    ):
+        """
+        Initialize MCP server.
+
+        Args:
+            name: Service name (shown in MCP client)
+            db_url: Database URL for workflow storage
+            outbox_enabled: Enable transactional outbox pattern
+            broker_url: Message broker URL (if outbox enabled)
+            token_verifier: Optional function to verify authentication tokens
+        """
+        self._name = name
+        self._edda_app = EddaApp(
+            service_name=name,
+            db_url=db_url,
+            outbox_enabled=outbox_enabled,
+            broker_url=broker_url,
+        )
+        self._mcp = FastMCP(name, json_response=True, stateless_http=True)
+        self._token_verifier = token_verifier
+
+        # Registry of durable tools (workflow_name -> Workflow instance)
+        self._workflows: dict[str, Workflow] = {}
+
+    def durable_tool(
+        self,
+        func: Callable | None = None,
+        *,
+        description: str = "",
+    ) -> Callable:
+        """
+        Decorator to define a durable workflow tool.
+
+        Automatically generates three MCP tools:
+        1. Main tool: Starts the workflow, returns instance_id
+        2. Status tool: Checks workflow status
+        3. Result tool: Gets workflow result (if completed)
+
+        Args:
+            func: Workflow function (async)
+            description: Tool description for MCP clients
+
+        Returns:
+            Decorated workflow instance
+
+        Example:
+            ```python
+            @server.durable_tool(description="Long-running order processing")
+            async def process_order(ctx, order_id: str):
+                # Workflow logic
+                return {"status": "completed"}
+            ```
+        """
+        from edda.integrations.mcp.decorators import create_durable_tool
+
+        def decorator(f: Callable) -> Workflow:
+            return create_durable_tool(self, f, description=description)
+
+        if func is None:
+            return decorator
+        return decorator(func)
+
+    def asgi_app(self) -> Callable:
+        """
+        Create ASGI application with MCP + CloudEvents support.
+
+        This method uses the Issue #1367 workaround: instead of using Mount,
+        we get the MCP's Starlette app directly and add Edda endpoints to it.
+
+        Routing:
+        - POST /    -> FastMCP (MCP tools via streamable HTTP)
+        - POST /cancel/{instance_id} -> Workflow cancellation
+        - Other POST -> CloudEvents
+
+        Returns:
+            ASGI callable (Starlette app)
+        """
+        from starlette.requests import Request
+        from starlette.responses import Response
+
+        # Get MCP's Starlette app (Issue #1367 workaround: use directly)
+        app = self._mcp.streamable_http_app()
+
+        # Add Edda endpoints to Starlette router BEFORE wrapping with middleware
+        # Note: MCP's streamable HTTP is already mounted at "/" by default
+        # We add additional routes for Edda's CloudEvents and cancellation
+
+        async def edda_cancel_handler(request: Request) -> Response:
+            """Handle workflow cancellation."""
+            instance_id = request.path_params["instance_id"]
+
+            # Create ASGI scope for EddaApp
+            scope = dict(request.scope)
+            scope["path"] = f"/cancel/{instance_id}"
+
+            # Capture response
+            response_data = {"status": 200, "headers": [], "body": b""}
+
+            async def send(message: dict) -> None:
+                if message["type"] == "http.response.start":
+                    response_data["status"] = message["status"]
+                    response_data["headers"] = message.get("headers", [])
+                elif message["type"] == "http.response.body":
+                    response_data["body"] += message.get("body", b"")
+
+            # Forward to EddaApp
+            await self._edda_app(scope, request.receive, send)
+
+            # Return response
+            return Response(
+                content=response_data["body"],
+                status_code=response_data["status"],
+                headers=dict(response_data["headers"]),
+            )
+
+        # Add cancel route
+        app.router.add_route("/cancel/{instance_id}", edda_cancel_handler, methods=["POST"])
+
+        # Add authentication middleware if token_verifier provided (AFTER adding routes)
+        if self._token_verifier is not None:
+            from starlette.middleware.base import BaseHTTPMiddleware
+
+            class AuthMiddleware(BaseHTTPMiddleware):
+                def __init__(self, app: Any, token_verifier: Callable):
+                    super().__init__(app)
+                    self.token_verifier = token_verifier
+
+                async def dispatch(self, request: Request, call_next: Callable):
+                    auth_header = request.headers.get("authorization", "")
+                    if auth_header.startswith("Bearer "):
+                        token = auth_header[7:]
+                        if not self.token_verifier(token):
+                            return Response("Unauthorized", status_code=401)
+                    return await call_next(request)
+
+            # Wrap app with auth middleware
+            app = AuthMiddleware(app, self._token_verifier)
+
+        return app
+
+    async def initialize(self) -> None:
+        """
+        Initialize the EddaApp (setup replay engine, storage, etc.).
+
+        This method must be called before running the server in stdio mode.
+        For HTTP mode (asgi_app()), initialization happens automatically
+        when the ASGI app is deployed.
+
+        Example:
+            ```python
+            async def main():
+                await server.initialize()
+                await server.run_stdio()
+
+            if __name__ == "__main__":
+                import asyncio
+                asyncio.run(main())
+            ```
+        """
+        await self._edda_app.initialize()
+
+    async def run_stdio(self) -> None:
+        """
+        Run MCP server with stdio transport (for MCP clients, e.g., Claude Desktop).
+
+        This method uses stdin/stdout for JSON-RPC communication.
+        stderr can be used for diagnostic messages.
+
+        The server will block until terminated (Ctrl+C or SIGTERM).
+
+        Example:
+            ```python
+            async def main():
+                await server.initialize()
+                await server.run_stdio()
+
+            if __name__ == "__main__":
+                import asyncio
+                asyncio.run(main())
+            ```
+        """
+        await self._mcp.run_stdio_async()

edda/wsgi.py

@@ -0,0 +1,77 @@
+"""
+WSGI adapter for Edda framework.
+
+This module provides a WSGI adapter that wraps EddaApp (ASGI) for use with
+WSGI servers like gunicorn or uWSGI.
+
+The adapter uses a2wsgi to convert the ASGI interface to WSGI.
+"""
+
+from typing import Any
+
+from a2wsgi import ASGIMiddleware
+
+from edda.app import EddaApp
+
+
+def create_wsgi_app(edda_app: EddaApp) -> Any:
+    """
+    Create a WSGI-compatible application from an EddaApp instance.
+
+    This function wraps an EddaApp (ASGI) with a2wsgi's ASGIMiddleware,
+    making it compatible with WSGI servers like gunicorn or uWSGI.
+
+    Args:
+        edda_app: An initialized EddaApp instance
+
+    Returns:
+        A WSGI-compatible application callable
+
+    Example:
+        Basic usage with EddaApp::
+
+            from edda import EddaApp
+            from edda.wsgi import create_wsgi_app
+            from edda.storage.sqlalchemy_storage import SQLAlchemyStorage
+
+            # Create storage and EddaApp
+            storage = SQLAlchemyStorage("sqlite:///edda.db")
+            app = EddaApp(storage=storage)
+
+            # Create WSGI application
+            wsgi_app = create_wsgi_app(app)
+
+        Running with gunicorn::
+
+            # In your module (e.g., demo_app.py):
+            from edda import EddaApp
+            from edda.wsgi import create_wsgi_app
+
+            application = EddaApp(...)  # ASGI
+            wsgi_application = create_wsgi_app(application)  # WSGI
+
+            # Command line:
+            $ gunicorn demo_app:wsgi_application --workers 4
+
+        Running with uWSGI::
+
+            $ uwsgi --http :8000 --wsgi-file demo_app.py --callable wsgi_application
+
+    Background tasks (auto-resume, timer checks, etc.) will run in each
+    worker process.
+
+    For production deployments, ASGI servers (uvicorn, hypercorn) are
+    recommended for better performance with Edda's async architecture.
+    WSGI support is provided for compatibility with existing infrastructure
+    and for users who prefer synchronous programming with sync activities.
+
+    See Also:
+        - :class:`edda.app.EddaApp`: The main ASGI application class
+        - :func:`edda.activity.activity`: Decorator supporting sync activities
+    """
+    # Type ignore due to a2wsgi's strict ASGI type checking
+    # EddaApp implements ASGI 3.0 interface correctly
+    return ASGIMiddleware(edda_app)  # type: ignore[arg-type]
+
+
+__all__ = ["create_wsgi_app"]

{edda_framework-0.1.0.dist-info → edda_framework-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edda-framework
-Version: 0.1.0
+Version: 0.3.0
 Summary: Lightweight Durable Execution Framework
 Project-URL: Homepage, https://github.com/i2y/edda
 Project-URL: Documentation, https://github.com/i2y/edda#readme
@@ -20,7 +20,9 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: System :: Distributed Computing
 Requires-Python: >=3.11
+Requires-Dist: a2wsgi>=1.10.0
 Requires-Dist: aiosqlite>=0.21.0
+Requires-Dist: anyio>=4.0.0
 Requires-Dist: cloudevents>=1.12.0
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: pydantic>=2.0.0
@@ -36,6 +38,8 @@ Requires-Dist: ruff>=0.14.2; extra == 'dev'
 Requires-Dist: testcontainers[mysql]>=4.0.0; extra == 'dev'
 Requires-Dist: testcontainers[postgres]>=4.0.0; extra == 'dev'
 Requires-Dist: tsuno>=0.1.3; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.22.0; extra == 'mcp'
 Provides-Extra: mysql
 Requires-Dist: aiomysql>=0.2.0; extra == 'mysql'
 Provides-Extra: postgresql
@@ -75,6 +79,8 @@ For detailed documentation, visit [https://i2y.github.io/edda/](https://i2y.gith
 - 📦 **Transactional Outbox**: Reliable event publishing with guaranteed delivery
 - ☁️ **CloudEvents Support**: Native support for CloudEvents protocol
 - ⏱️ **Event & Timer Waiting**: Free up worker resources while waiting for events or timers, resume on any available worker
+- 🤖 **MCP Integration**: Expose durable workflows as AI tools via Model Context Protocol
+- 🌍 **ASGI/WSGI Support**: Deploy with your preferred server (uvicorn, gunicorn, uWSGI)
 
 ## Use Cases
 
@@ -638,6 +644,94 @@ api.mount("/workflows", edda_app)
 
 This works with any ASGI framework (Starlette, FastAPI, Quart, etc.)
 
+### WSGI Integration
+
+For WSGI environments (gunicorn, uWSGI, Flask, Django), use the WSGI adapter:
+
+```python
+from edda import EddaApp
+from edda.wsgi import create_wsgi_app
+
+# Create Edda app
+edda_app = EddaApp(db_url="sqlite:///workflow.db")
+
+# Convert to WSGI
+wsgi_application = create_wsgi_app(edda_app)
+```
+
+**Running with WSGI servers:**
+
+```bash
+# With Gunicorn
+gunicorn demo_app:wsgi_application --workers 4
+
+# With uWSGI
+uwsgi --http :8000 --wsgi-file demo_app.py --callable wsgi_application
+```
+
+**Sync Activities**: For WSGI environments or legacy codebases, you can write synchronous activities:
+
+```python
+from edda import activity, WorkflowContext
+
+@activity
+def process_payment(ctx: WorkflowContext, amount: float) -> dict:
+    # Sync function - automatically executed in thread pool
+    # No async/await needed!
+    return {"status": "paid", "amount": amount}
+
+@workflow
+async def payment_workflow(ctx: WorkflowContext, order_id: str) -> dict:
+    # Workflows still use async (for deterministic replay)
+    result = await process_payment(ctx, 99.99, activity_id="pay:1")
+    return result
+```
+
+**Performance note**: ASGI servers (uvicorn, hypercorn) are recommended for better performance with Edda's async architecture. WSGI support is provided for compatibility with existing infrastructure and users who prefer synchronous programming.
+
+## MCP Integration
+
+Edda integrates with the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/), allowing AI assistants like Claude to interact with your durable workflows as long-running tools.
+
+### Quick Example
+
+```python
+from edda.integrations.mcp import EddaMCPServer
+from edda import WorkflowContext, activity
+
+# Create MCP server
+server = EddaMCPServer(
+    name="Order Service",
+    db_url="postgresql://user:pass@localhost/orders",
+)
+
+@activity
+async def process_payment(ctx: WorkflowContext, amount: float):
+    return {"status": "paid", "amount": amount}
+
+@server.durable_tool(description="Process customer order")
+async def process_order(ctx: WorkflowContext, order_id: str):
+    await process_payment(ctx, 99.99)
+    return {"status": "completed", "order_id": order_id}
+
+# Deploy with uvicorn
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(server.asgi_app(), host="0.0.0.0", port=8000)
+```
+
+### Auto-Generated Tools
+
+Each `@durable_tool` automatically generates **three MCP tools**:
+
+1. **Main tool** (`process_order`): Starts the workflow, returns instance ID
+2. **Status tool** (`process_order_status`): Checks workflow progress
+3. **Result tool** (`process_order_result`): Gets final result when completed
+
+This enables AI assistants to work with workflows that take minutes, hours, or even days to complete.
+
+**For detailed documentation**, see [MCP Integration Guide](docs/integrations/mcp.md).
+
 ## Observability Hooks
 
 Extend Edda with custom observability without coupling to specific tools:

{edda_framework-0.1.0.dist-info → edda_framework-0.3.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-edda/__init__.py,sha256=a8Rp16Qmj4iuO1MXmrpO_oGIMLY-vkg-vW6z-CATBas,1596
-edda/activity.py,sha256=pDKs3rh4QpnRnIEAHi3rxEXkDL71pBE_La7skde9vJg,20320
+edda/__init__.py,sha256=gmJd0ooVbGNMOLlSj-r6rEt3IkY-FZYCFjhWjIltqlk,1657
+edda/activity.py,sha256=nRm9eBrr0lFe4ZRQ2whyZ6mo5xd171ITIVhqytUhOpw,21025
 edda/app.py,sha256=YxURvhaC1dKcymOwuS1PHU6_iOl_5cZWse2vAKSyX8w,37471
 edda/compensation.py,sha256=CmnyJy4jAklVrtLJodNOcj6vxET6pdarxM1Yx2RHlL4,11898
 edda/context.py,sha256=YZKBNtblRcaFqte1Y9t2cIP3JHzK-5Tu40x5i5FHtnU,17789
@@ -11,6 +11,11 @@ edda/pydantic_utils.py,sha256=dGVPNrrttDeq1k233PopCtjORYjZitsgASPfPnO6R10,9056
 edda/replay.py,sha256=5RIRd0q2ZrH9iiiy35eOUii2cipYg9dlua56OAXvIk4,32499
 edda/retry.py,sha256=t4_E1skrhotA1XWHTLbKi-DOgCMasOUnhI9OT-O_eCE,6843
 edda/workflow.py,sha256=daSppYAzgXkjY_9-HS93Zi7_tPR6srmchxY5YfwgU-4,7239
+edda/wsgi.py,sha256=1pGE5fhHpcsYnDR8S3NEFKWUs5P0JK4roTAzX9BsIj0,2391
+edda/integrations/__init__.py,sha256=F_CaTvlDEbldfOpPKq_U9ve1E573tS6XzqXnOtyHcXI,33
+edda/integrations/mcp/__init__.py,sha256=YK-8m0DIdP-RSqewlIX7xnWU7TD3NioCiW2_aZSgnn8,1232
+edda/integrations/mcp/decorators.py,sha256=HYZi6Ic_w-ffqMzO0cmuio88OSm1FVQ5jzjePcW48QM,5541
+edda/integrations/mcp/server.py,sha256=N-QTebRKd05LB9r2Cwywm4xU9wsbO_UAdYofoEhArms,8785
 edda/outbox/__init__.py,sha256=azXG1rtheJEjOyoWmMsBeR2jp8Bz02R3wDEd5tQnaWA,424
 edda/outbox/relayer.py,sha256=2tnN1aOQ8pKWfwEGIlYwYLLwyOKXBjZ4XZsIr1HjgK4,9454
 edda/outbox/transactional.py,sha256=LFfUjunqRlGibaINi-efGXFFivWGO7v3mhqrqyGW6Nw,3808
@@ -28,8 +33,8 @@ edda/viewer_ui/data_service.py,sha256=mXV6bL6REa_UKsk8xMGBIFbsbLpIxe91lX3wgn-FOj
 edda/visualizer/__init__.py,sha256=DOpDstNhR0VcXAs_eMKxaL30p_0u4PKZ4o2ndnYhiRo,343
 edda/visualizer/ast_analyzer.py,sha256=plmx7C9X_X35xLY80jxOL3ljg3afXxBePRZubqUIkxY,13663
 edda/visualizer/mermaid_generator.py,sha256=XWa2egoOTNDfJEjPcwoxwQmblUqXf7YInWFjFRI1QGo,12457
-edda_framework-0.1.0.dist-info/METADATA,sha256=6T8Pt-0Y-SkZwsqKVSvMqEhkVlutu_XHbUUtWSF5Urw,26318
-edda_framework-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-edda_framework-0.1.0.dist-info/entry_points.txt,sha256=dPH47s6UoJgUZxHoeSMqZsQkLaSE-SGLi-gh88k2WrU,48
-edda_framework-0.1.0.dist-info/licenses/LICENSE,sha256=udxb-V7_cYKTHqW7lNm48rxJ-Zpf0WAY_PyGDK9BPCo,1069
-edda_framework-0.1.0.dist-info/RECORD,,
+edda_framework-0.3.0.dist-info/METADATA,sha256=fVS73kMWDrVBU3BYcRKFNMGlFhMB12dvaZbOoz2T_LI,29421
+edda_framework-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+edda_framework-0.3.0.dist-info/entry_points.txt,sha256=dPH47s6UoJgUZxHoeSMqZsQkLaSE-SGLi-gh88k2WrU,48
+edda_framework-0.3.0.dist-info/licenses/LICENSE,sha256=udxb-V7_cYKTHqW7lNm48rxJ-Zpf0WAY_PyGDK9BPCo,1069
+edda_framework-0.3.0.dist-info/RECORD,,