kailash 0.1.2__tar.gz → 0.1.3__tar.gz

{kailash-0.1.2/src/kailash.egg-info → kailash-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kailash
-Version: 0.1.2
+Version: 0.1.3
 Summary: Python SDK for the Kailash container-node architecture
 Home-page: https://github.com/integrum/kailash-python-sdk
 Author: Integrum
@@ -41,7 +41,8 @@ Requires-Dist: autodoc>=0.5.0
 Requires-Dist: myst-parser>=4.0.1
 Requires-Dist: black>=25.1.0
 Requires-Dist: psutil>=7.0.0
-Requires-Dist: fastapi[all]>=0.115.12
+Requires-Dist: fastapi>=0.115.12
+Requires-Dist: uvicorn[standard]>=0.31.0
 Requires-Dist: pytest-asyncio>=1.0.0
 Requires-Dist: pre-commit>=4.2.0
 Requires-Dist: twine>=6.1.0
@@ -89,6 +90,7 @@ Dynamic: requires-python
 - ⚡ **Fast Installation**: Uses `uv` for lightning-fast Python package management
 - 🤖 **AI-Powered**: Complete LLM agents, embeddings, and hierarchical RAG architecture
 - 🧠 **Retrieval-Augmented Generation**: Full RAG pipeline with intelligent document processing
+- 🌐 **REST API Wrapper**: Expose any workflow as a production-ready API in 3 lines
 
 ## 🎯 Who Is This For?
 
@@ -273,6 +275,66 @@ results, run_id = runtime.execute(workflow)
 print("RAG Response:", results["llm_agent"]["response"])
 ```
 
+### Workflow API Wrapper - Expose Workflows as REST APIs
+
+Transform any Kailash workflow into a production-ready REST API in just 3 lines of code:
+
+```python
+from kailash.api.workflow_api import WorkflowAPI
+
+# Take any workflow and expose it as an API
+api = WorkflowAPI(workflow)
+api.run(port=8000)  # That's it! Your workflow is now a REST API
+```
+
+#### Features
+
+- **Automatic REST Endpoints**:
+  - `POST /execute` - Execute workflow with inputs
+  - `GET /workflow/info` - Get workflow metadata
+  - `GET /health` - Health check endpoint
+  - Automatic OpenAPI docs at `/docs`
+
+- **Multiple Execution Modes**:
+  ```python
+  # Synchronous execution (wait for results)
+  curl -X POST http://localhost:8000/execute \
+    -d '{"inputs": {...}, "mode": "sync"}'
+
+  # Asynchronous execution (get execution ID)
+  curl -X POST http://localhost:8000/execute \
+    -d '{"inputs": {...}, "mode": "async"}'
+
+  # Check async status
+  curl http://localhost:8000/status/{execution_id}
+  ```
+
+- **Specialized APIs** for specific domains:
+  ```python
+  from kailash.api.workflow_api import create_workflow_api
+
+  # Create a RAG-specific API with custom endpoints
+  api = create_workflow_api(rag_workflow, api_type="rag")
+  # Adds /documents and /query endpoints
+  ```
+
+- **Production Ready**:
+  ```python
+  # Development
+  api.run(reload=True, log_level="debug")
+
+  # Production with SSL
+  api.run(
+      host="0.0.0.0",
+      port=443,
+      ssl_keyfile="key.pem",
+      ssl_certfile="cert.pem",
+      workers=4
+  )
+  ```
+
+See the [API demo example](examples/integration_examples/integration_api_demo.py) for complete usage patterns.
+
 ## 📚 Documentation
 
 | Resource | Description |
@@ -316,6 +378,11 @@ The SDK includes a rich set of pre-built nodes for common operations:
 - `Filter` - Filter records
 - `Aggregator` - Aggregate data
 
+**Logic Nodes**
+- `Switch` - Conditional routing
+- `Merge` - Combine multiple inputs
+- `WorkflowNode` - Wrap workflows as reusable nodes
+
 </td>
 </tr>
 <tr>
@@ -384,6 +451,35 @@ workflow.connect("route", "process_valid")
 workflow.connect("route", "handle_errors")
 ```
 
+#### Hierarchical Workflow Composition
+```python
+from kailash.workflow import Workflow
+from kailash.nodes.logic import WorkflowNode
+from kailash.runtime.local import LocalRuntime
+
+# Create a reusable data processing workflow
+inner_workflow = Workflow("data_processor", name="Data Processor")
+# ... add nodes to inner workflow ...
+
+# Wrap the workflow as a node
+processor_node = WorkflowNode(
+    workflow=inner_workflow,
+    name="data_processor"
+)
+
+# Use in a larger workflow
+main_workflow = Workflow("main", name="Main Pipeline")
+main_workflow.add_node("process", processor_node)
+main_workflow.add_node("analyze", analyzer_node)
+
+# Connect workflows
+main_workflow.connect("process", "analyze")
+
+# Execute - parameters automatically mapped to inner workflow
+runtime = LocalRuntime()
+results, _ = runtime.execute(main_workflow)
+```
+
 #### Immutable State Management
 ```python
 from kailash.workflow import Workflow

{kailash-0.1.2 → kailash-0.1.3}/README.md

@@ -30,6 +30,7 @@
 - ⚡ **Fast Installation**: Uses `uv` for lightning-fast Python package management
 - 🤖 **AI-Powered**: Complete LLM agents, embeddings, and hierarchical RAG architecture
 - 🧠 **Retrieval-Augmented Generation**: Full RAG pipeline with intelligent document processing
+- 🌐 **REST API Wrapper**: Expose any workflow as a production-ready API in 3 lines
 
 ## 🎯 Who Is This For?
 
@@ -214,6 +215,66 @@ results, run_id = runtime.execute(workflow)
 print("RAG Response:", results["llm_agent"]["response"])
 ```
 
+### Workflow API Wrapper - Expose Workflows as REST APIs
+
+Transform any Kailash workflow into a production-ready REST API in just 3 lines of code:
+
+```python
+from kailash.api.workflow_api import WorkflowAPI
+
+# Take any workflow and expose it as an API
+api = WorkflowAPI(workflow)
+api.run(port=8000)  # That's it! Your workflow is now a REST API
+```
+
+#### Features
+
+- **Automatic REST Endpoints**:
+  - `POST /execute` - Execute workflow with inputs
+  - `GET /workflow/info` - Get workflow metadata
+  - `GET /health` - Health check endpoint
+  - Automatic OpenAPI docs at `/docs`
+
+- **Multiple Execution Modes**:
+  ```python
+  # Synchronous execution (wait for results)
+  curl -X POST http://localhost:8000/execute \
+    -d '{"inputs": {...}, "mode": "sync"}'
+
+  # Asynchronous execution (get execution ID)
+  curl -X POST http://localhost:8000/execute \
+    -d '{"inputs": {...}, "mode": "async"}'
+
+  # Check async status
+  curl http://localhost:8000/status/{execution_id}
+  ```
+
+- **Specialized APIs** for specific domains:
+  ```python
+  from kailash.api.workflow_api import create_workflow_api
+
+  # Create a RAG-specific API with custom endpoints
+  api = create_workflow_api(rag_workflow, api_type="rag")
+  # Adds /documents and /query endpoints
+  ```
+
+- **Production Ready**:
+  ```python
+  # Development
+  api.run(reload=True, log_level="debug")
+
+  # Production with SSL
+  api.run(
+      host="0.0.0.0",
+      port=443,
+      ssl_keyfile="key.pem",
+      ssl_certfile="cert.pem",
+      workers=4
+  )
+  ```
+
+See the [API demo example](examples/integration_examples/integration_api_demo.py) for complete usage patterns.
+
 ## 📚 Documentation
 
 | Resource | Description |
@@ -257,6 +318,11 @@ The SDK includes a rich set of pre-built nodes for common operations:
 - `Filter` - Filter records
 - `Aggregator` - Aggregate data
 
+**Logic Nodes**
+- `Switch` - Conditional routing
+- `Merge` - Combine multiple inputs
+- `WorkflowNode` - Wrap workflows as reusable nodes
+
 </td>
 </tr>
 <tr>
@@ -325,6 +391,35 @@ workflow.connect("route", "process_valid")
 workflow.connect("route", "handle_errors")
 ```
 
+#### Hierarchical Workflow Composition
+```python
+from kailash.workflow import Workflow
+from kailash.nodes.logic import WorkflowNode
+from kailash.runtime.local import LocalRuntime
+
+# Create a reusable data processing workflow
+inner_workflow = Workflow("data_processor", name="Data Processor")
+# ... add nodes to inner workflow ...
+
+# Wrap the workflow as a node
+processor_node = WorkflowNode(
+    workflow=inner_workflow,
+    name="data_processor"
+)
+
+# Use in a larger workflow
+main_workflow = Workflow("main", name="Main Pipeline")
+main_workflow.add_node("process", processor_node)
+main_workflow.add_node("analyze", analyzer_node)
+
+# Connect workflows
+main_workflow.connect("process", "analyze")
+
+# Execute - parameters automatically mapped to inner workflow
+runtime = LocalRuntime()
+results, _ = runtime.execute(main_workflow)
+```
+
 #### Immutable State Management
 ```python
 from kailash.workflow import Workflow

{kailash-0.1.2 → kailash-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kailash"
-version = "0.1.2"
+version = "0.1.3"
 description = "Python SDK for the Kailash container-node architecture"
 authors = [
     {name = "Integrum", email = "info@integrum.com"}
@@ -45,7 +45,8 @@ dependencies = [
     "myst-parser>=4.0.1",
     "black>=25.1.0",
     "psutil>=7.0.0",
-    "fastapi[all]>=0.115.12",
+    "fastapi>=0.115.12",
+    "uvicorn[standard]>=0.31.0",
     "pytest-asyncio>=1.0.0",
     "pre-commit>=4.2.0",
     "twine>=6.1.0",

kailash-0.1.3/src/kailash/api/__init__.py

@@ -0,0 +1,7 @@
+"""
+Kailash API module for exposing workflows as REST APIs.
+"""
+
+from .workflow_api import HierarchicalRAGAPI, WorkflowAPI, create_workflow_api
+
+__all__ = ["WorkflowAPI", "HierarchicalRAGAPI", "create_workflow_api"]

kailash-0.1.3/src/kailash/api/workflow_api.py

@@ -0,0 +1,383 @@
+"""
+Lean API wrapper for Kailash workflows using FastAPI.
+
+This module provides a general-purpose API wrapper that can expose any Kailash
+workflow as a REST API with minimal configuration.
+"""
+
+import asyncio
+from contextlib import asynccontextmanager
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+import uvicorn
+from fastapi import BackgroundTasks, FastAPI, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel, Field
+
+from kailash.runtime.local import LocalRuntime
+from kailash.workflow.builder import WorkflowBuilder
+from kailash.workflow.graph import Workflow
+
+
+class ExecutionMode(str, Enum):
+    """Execution modes for workflow API."""
+
+    SYNC = "sync"
+    ASYNC = "async"
+    STREAM = "stream"
+
+
+class WorkflowRequest(BaseModel):
+    """Base request model for workflow execution."""
+
+    inputs: Dict[str, Any] = Field(..., description="Input data for workflow nodes")
+    config: Optional[Dict[str, Any]] = Field(
+        None, description="Node configuration overrides"
+    )
+    mode: ExecutionMode = Field(ExecutionMode.SYNC, description="Execution mode")
+
+
+class WorkflowResponse(BaseModel):
+    """Base response model for workflow execution."""
+
+    outputs: Dict[str, Any] = Field(..., description="Output data from workflow nodes")
+    execution_time: float = Field(..., description="Execution time in seconds")
+    workflow_id: str = Field(..., description="Workflow identifier")
+    version: str = Field(..., description="Workflow version")
+
+
+class WorkflowAPI:
+    """
+    Lean API wrapper for Kailash workflows.
+
+    This class provides a minimal, efficient way to expose any Kailash workflow
+    as a REST API with support for synchronous, asynchronous, and streaming execution.
+
+    Example:
+        >>> # For any workflow
+        >>> from my_workflows import rag_workflow
+        >>> api = WorkflowAPI(rag_workflow)
+        >>> api.run(port=8000)
+    """
+
+    def __init__(
+        self,
+        workflow: Union[WorkflowBuilder, Workflow],
+        app_name: str = "Kailash Workflow API",
+        version: str = "1.0.0",
+        description: str = "API wrapper for Kailash workflow execution",
+    ):
+        """
+        Initialize the API wrapper.
+
+        Args:
+            workflow: The WorkflowBuilder or Workflow instance to expose
+            app_name: Name of the API application
+            version: API version
+            description: API description
+        """
+        if isinstance(workflow, WorkflowBuilder):
+            self.workflow = workflow
+            self.workflow_graph = workflow.build()
+            self.workflow_id = getattr(workflow, "workflow_id", "unnamed")
+            self.version = getattr(workflow, "version", "1.0.0")
+        else:  # Workflow instance
+            self.workflow = workflow
+            self.workflow_graph = workflow
+            self.workflow_id = workflow.workflow_id
+            self.version = workflow.version
+
+        self.runtime = LocalRuntime()
+
+        # Create FastAPI app with lifespan management
+        self.app = FastAPI(
+            title=app_name,
+            version=version,
+            description=description,
+            lifespan=self._lifespan,
+        )
+
+        # Setup routes
+        self._setup_routes()
+
+        # Cache for async executions
+        self._execution_cache: Dict[str, Dict[str, Any]] = {}
+
+    @asynccontextmanager
+    async def _lifespan(self, app: FastAPI):
+        """Manage app lifecycle."""
+        # Startup
+        yield
+        # Shutdown - cleanup cache
+        self._execution_cache.clear()
+
+    def _setup_routes(self):
+        """Setup API routes dynamically based on workflow."""
+
+        # Main execution endpoint
+        @self.app.post("/execute", response_model=WorkflowResponse)
+        async def execute_workflow(
+            request: WorkflowRequest, background_tasks: BackgroundTasks
+        ):
+            """Execute the workflow with provided inputs."""
+
+            if request.mode == ExecutionMode.SYNC:
+                return await self._execute_sync(request)
+            elif request.mode == ExecutionMode.ASYNC:
+                return await self._execute_async(request, background_tasks)
+            else:  # STREAM
+                return StreamingResponse(
+                    self._execute_stream(request), media_type="application/json"
+                )
+
+        # Status endpoint for async executions
+        @self.app.get("/status/{execution_id}")
+        async def get_execution_status(execution_id: str):
+            """Get status of async execution."""
+            if execution_id not in self._execution_cache:
+                raise HTTPException(status_code=404, detail="Execution not found")
+            return self._execution_cache[execution_id]
+
+        # Workflow metadata endpoint
+        @self.app.get("/workflow/info")
+        async def get_workflow_info():
+            """Get workflow metadata and structure."""
+            graph_data = self.workflow_graph
+            return {
+                "id": self.workflow_id,
+                "version": self.version,
+                "nodes": list(graph_data.nodes()),
+                "edges": list(graph_data.edges()),
+                "input_nodes": [
+                    n for n in graph_data.nodes() if graph_data.in_degree(n) == 0
+                ],
+                "output_nodes": [
+                    n for n in graph_data.nodes() if graph_data.out_degree(n) == 0
+                ],
+            }
+
+        # Health check
+        @self.app.get("/health")
+        async def health_check():
+            """Check API health."""
+            return {"status": "healthy", "workflow": self.workflow_id}
+
+    async def _execute_sync(self, request: WorkflowRequest) -> WorkflowResponse:
+        """Execute workflow synchronously."""
+        import time
+
+        start_time = time.time()
+
+        try:
+            # Apply configuration overrides if provided
+            if request.config:
+                for node_id, config in request.config.items():
+                    # This would need workflow builder enhancement to support
+                    # dynamic config updates
+                    pass
+
+            # Execute workflow with inputs
+            results = await asyncio.to_thread(
+                self.runtime.execute, self.workflow_graph, request.inputs
+            )
+
+            # Handle tuple return from runtime
+            if isinstance(results, tuple):
+                results = results[0] if results else {}
+
+            execution_time = time.time() - start_time
+
+            return WorkflowResponse(
+                outputs=results,
+                execution_time=execution_time,
+                workflow_id=self.workflow_id,
+                version=self.version,
+            )
+
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    async def _execute_async(
+        self, request: WorkflowRequest, background_tasks: BackgroundTasks
+    ):
+        """Execute workflow asynchronously."""
+        import uuid
+
+        execution_id = str(uuid.uuid4())
+
+        # Initialize cache entry
+        self._execution_cache[execution_id] = {
+            "status": "pending",
+            "workflow_id": self.workflow_id,
+            "version": self.version,
+        }
+
+        # Schedule background execution
+        background_tasks.add_task(self._run_async_execution, execution_id, request)
+
+        return {
+            "execution_id": execution_id,
+            "status": "pending",
+            "message": f"Execution started. Check status at /status/{execution_id}",
+        }
+
+    async def _run_async_execution(self, execution_id: str, request: WorkflowRequest):
+        """Run async execution in background."""
+        try:
+            self._execution_cache[execution_id]["status"] = "running"
+
+            result = await self._execute_sync(request)
+
+            self._execution_cache[execution_id].update(
+                {"status": "completed", "result": result.dict()}
+            )
+
+        except Exception as e:
+            self._execution_cache[execution_id].update(
+                {"status": "failed", "error": str(e)}
+            )
+
+    async def _execute_stream(self, request: WorkflowRequest):
+        """Execute workflow with streaming response."""
+        import json
+        import time
+
+        try:
+            # For streaming, we'd need workflow runner enhancement
+            # to support progress callbacks. For now, simulate with
+            # start/end events
+
+            yield json.dumps(
+                {
+                    "event": "start",
+                    "workflow_id": self.workflow_id,
+                    "timestamp": time.time(),
+                }
+            ) + "\n"
+
+            result = await self._execute_sync(request)
+
+            yield json.dumps(
+                {"event": "complete", "result": result.dict(), "timestamp": time.time()}
+            ) + "\n"
+
+        except Exception as e:
+            yield json.dumps(
+                {"event": "error", "error": str(e), "timestamp": time.time()}
+            ) + "\n"
+
+    def run(self, host: str = "0.0.0.0", port: int = 8000, **kwargs):
+        """Run the API server."""
+        uvicorn.run(self.app, host=host, port=port, **kwargs)
+
+
+# Specialized API wrapper for Hierarchical RAG workflows
+class HierarchicalRAGAPI(WorkflowAPI):
+    """
+    Specialized API wrapper for Hierarchical RAG workflows.
+
+    Provides RAG-specific endpoints and models for better developer experience.
+    """
+
+    def __init__(self, workflow: WorkflowBuilder, **kwargs):
+        super().__init__(workflow, **kwargs)
+        self._setup_rag_routes()
+
+    def _setup_rag_routes(self):
+        """Setup RAG-specific routes."""
+
+        class Document(BaseModel):
+            id: str
+            title: str
+            content: str
+
+        class RAGQuery(BaseModel):
+            query: str
+            top_k: int = 3
+            similarity_method: str = "cosine"
+            temperature: float = 0.7
+            max_tokens: int = 500
+
+        class RAGResponse(BaseModel):
+            answer: str
+            sources: List[Dict[str, Any]]
+            query: str
+            execution_time: float
+
+        @self.app.post("/documents")
+        async def add_documents(documents: List[Document]):
+            """Add documents to the knowledge base."""
+            # This would integrate with document storage
+            return {"message": f"Added {len(documents)} documents"}
+
+        @self.app.post("/query", response_model=RAGResponse)
+        async def query_rag(request: RAGQuery):
+            """Query the RAG system."""
+            import time
+
+            start_time = time.time()
+
+            # Transform to workflow format
+            workflow_request = WorkflowRequest(
+                inputs={
+                    "query": request.query,
+                    "config": {
+                        "relevance_scorer": {
+                            "top_k": request.top_k,
+                            "similarity_method": request.similarity_method,
+                        },
+                        "llm_agent": {
+                            "temperature": request.temperature,
+                            "max_tokens": request.max_tokens,
+                        },
+                    },
+                }
+            )
+
+            result = await self._execute_sync(workflow_request)
+
+            # Extract RAG-specific outputs
+            outputs = result.outputs
+            answer = (
+                outputs.get("llm_response", {})
+                .get("choices", [{}])[0]
+                .get("message", {})
+                .get("content", "")
+            )
+            sources = outputs.get("relevant_chunks", [])
+
+            return RAGResponse(
+                answer=answer,
+                sources=sources,
+                query=request.query,
+                execution_time=time.time() - start_time,
+            )
+
+
+# Factory function for creating API wrappers
+def create_workflow_api(
+    workflow: WorkflowBuilder, api_type: str = "generic", **kwargs
+) -> WorkflowAPI:
+    """
+    Factory function to create appropriate API wrapper.
+
+    Args:
+        workflow: The workflow to wrap
+        api_type: Type of API wrapper ("generic", "rag", etc.)
+        **kwargs: Additional arguments for API initialization
+
+    Returns:
+        Configured WorkflowAPI instance
+
+    Example:
+        >>> api = create_workflow_api(my_workflow, api_type="rag")
+        >>> api.run(port=8000)
+    """
+    api_classes = {
+        "generic": WorkflowAPI,
+        "rag": HierarchicalRAGAPI,
+    }
+
+    api_class = api_classes.get(api_type, WorkflowAPI)
+    return api_class(workflow, **kwargs)

{kailash-0.1.2 → kailash-0.1.3}/src/kailash/nodes/api/http.py

@@ -428,7 +428,6 @@ class HTTPRequestNode(Node):
             self.logger.info(f"Making {method} request to {url}")
 
         response = None
-        last_error = None
 
         for attempt in range(retry_count + 1):
             if attempt > 0:
@@ -453,7 +452,6 @@ class HTTPRequestNode(Node):
                 break
 
             except requests.RequestException as e:
-                last_error = e
                 self.logger.warning(f"Request failed: {str(e)}")
 
                 # Last attempt, no more retries
@@ -779,7 +777,6 @@ class AsyncHTTPRequestNode(AsyncNode):
             self.logger.info(f"Making async {method} request to {url}")
 
         response = None
-        last_error = None
 
         for attempt in range(retry_count + 1):
             if attempt > 0:
@@ -860,7 +857,6 @@ class AsyncHTTPRequestNode(AsyncNode):
                     return result
 
             except (aiohttp.ClientError, asyncio.TimeoutError) as e:
-                last_error = e
                 self.logger.warning(f"Async request failed: {str(e)}")
 
                 # Last attempt, no more retries