kailash 0.6.1__py3-none-any.whl → 0.6.3__py3-none-any.whl

kailash/nodes/ai/ai_providers.py

@@ -387,10 +387,16 @@ class OllamaProvider(UnifiedAIProvider):
             return self._available
 
         try:
+            import os
+
             import ollama
 
+            # Check with environment-configured host if available
+            host = os.getenv("OLLAMA_BASE_URL") or os.getenv("OLLAMA_HOST")
+            client = ollama.Client(host=host) if host else ollama.Client()
+
             # Check if Ollama is running
-            ollama.list()
+            client.list()
             self._available = True
         except Exception:
             self._available = False
@@ -409,6 +415,9 @@ class OllamaProvider(UnifiedAIProvider):
                     * temperature, max_tokens, top_p, top_k, repeat_penalty
                     * seed, stop, num_ctx, num_batch, num_thread
                     * tfs_z, typical_p, mirostat, mirostat_tau, mirostat_eta
+                backend_config (dict): Backend configuration including:
+                    * host (str): Ollama host URL (default: from env or http://localhost:11434)
+                    * port (int): Ollama port (if provided, will be appended to host)
 
         Returns:
             Dict containing the standardized response.
@@ -418,6 +427,28 @@ class OllamaProvider(UnifiedAIProvider):
 
             model = kwargs.get("model", "llama3.1:8b-instruct-q8_0")
             generation_config = kwargs.get("generation_config", {})
+            backend_config = kwargs.get("backend_config", {})
+
+            # Configure Ollama client with custom host if provided
+            if backend_config:
+                host = backend_config.get("host", "localhost")
+                port = backend_config.get("port")
+                if port:
+                    # Construct full URL if port is provided
+                    host = (
+                        f"http://{host}:{port}"
+                        if not host.startswith("http")
+                        else f"{host}:{port}"
+                    )
+                elif backend_config.get("base_url"):
+                    host = backend_config["base_url"]
+                self._client = ollama.Client(host=host)
+            elif self._client is None:
+                # Use default client
+                import os
+
+                host = os.getenv("OLLAMA_BASE_URL") or os.getenv("OLLAMA_HOST")
+                self._client = ollama.Client(host=host) if host else ollama.Client()
 
             # Map generation_config to Ollama options
             options = {
@@ -482,7 +513,7 @@ class OllamaProvider(UnifiedAIProvider):
                     processed_messages.append(msg)
 
             # Call Ollama
-            response = ollama.chat(
+            response = self._client.chat(
                 model=model, messages=processed_messages, options=options
             )
 
@@ -522,16 +553,37 @@ class OllamaProvider(UnifiedAIProvider):
         Supported kwargs:
         - model (str): Ollama model name (default: "snowflake-arctic-embed2")
         - normalize (bool): Normalize embeddings to unit length
+        - backend_config (dict): Backend configuration (host, port, base_url)
         """
         try:
             import ollama
 
             model = kwargs.get("model", "snowflake-arctic-embed2")
             normalize = kwargs.get("normalize", False)
+            backend_config = kwargs.get("backend_config", {})
+
+            # Configure Ollama client if not already configured
+            if backend_config and not hasattr(self, "_client"):
+                host = backend_config.get("host", "localhost")
+                port = backend_config.get("port")
+                if port:
+                    host = (
+                        f"http://{host}:{port}"
+                        if not host.startswith("http")
+                        else f"{host}:{port}"
+                    )
+                elif backend_config.get("base_url"):
+                    host = backend_config["base_url"]
+                self._client = ollama.Client(host=host)
+            elif not hasattr(self, "_client") or self._client is None:
+                import os
+
+                host = os.getenv("OLLAMA_BASE_URL") or os.getenv("OLLAMA_HOST")
+                self._client = ollama.Client(host=host) if host else ollama.Client()
 
             embeddings = []
             for text in texts:
-                response = ollama.embeddings(model=model, prompt=text)
+                response = self._client.embeddings(model=model, prompt=text)
                 embedding = response.get("embedding", [])
 
                 if normalize and embedding:

kailash/nodes/ai/iterative_llm_agent.py

@@ -457,7 +457,7 @@ class IterativeLLMAgentNode(LLMAgentNode):
         try:
             # Ensure MCP client is initialized
             if not hasattr(self, "_mcp_client"):
-                from kailash.mcp import MCPClient
+                from kailash.mcp_server import MCPClient
 
                 self._mcp_client = MCPClient()
 

kailash/nodes/ai/llm_agent.py

@@ -853,6 +853,62 @@ class LLMAgentNode(Node):
             "loaded_from": "mock_storage",
         }
 
+    def _run_async_in_sync_context(self, coro):
+        """
+        Run async coroutine in a synchronous context, handling existing event loops.
+
+        This helper method detects if an event loop is already running and handles
+        the execution appropriately to avoid "RuntimeError: This event loop is already running".
+
+        Args:
+            coro: The coroutine to execute
+
+        Returns:
+            The result of the coroutine execution
+
+        Raises:
+            TimeoutError: If the operation times out (30 seconds)
+            Exception: Any exception raised by the coroutine
+        """
+        import asyncio
+
+        try:
+            # Check if there's already a running event loop
+            loop = asyncio.get_running_loop()
+            # If we're here, there's a running loop - create a new thread
+            import threading
+
+            result = None
+            exception = None
+
+            def run_in_thread():
+                nonlocal result, exception
+                try:
+                    # Create new event loop in thread
+                    new_loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(new_loop)
+                    try:
+                        result = new_loop.run_until_complete(coro)
+                    finally:
+                        new_loop.close()
+                except Exception as e:
+                    exception = e
+
+            thread = threading.Thread(target=run_in_thread)
+            thread.start()
+            thread.join(timeout=30)  # 30 second timeout
+
+            if thread.is_alive():
+                raise TimeoutError("MCP operation timed out after 30 seconds")
+
+            if exception:
+                raise exception
+            return result
+
+        except RuntimeError:
+            # No running event loop, use asyncio.run()
+            return asyncio.run(coro)
+
     def _retrieve_mcp_context(
         self, mcp_servers: list[dict], mcp_context: list[str]
     ) -> list[dict[str, Any]]:
@@ -929,7 +985,7 @@ class LLMAgentNode(Node):
                 import asyncio
                 from datetime import datetime
 
-                from kailash.mcp import MCPClient
+                from kailash.mcp_server import MCPClient
 
                 # Initialize MCP client if not already done
                 if not hasattr(self, "_mcp_client"):
@@ -939,14 +995,14 @@ class LLMAgentNode(Node):
                 for server_config in mcp_servers:
                     try:
                         # List resources from server
-                        resources = asyncio.run(
+                        resources = self._run_async_in_sync_context(
                             self._mcp_client.list_resources(server_config)
                         )
 
                         # Read specific resources if requested
                         for uri in mcp_context:
                             try:
-                                resource_data = asyncio.run(
+                                resource_data = self._run_async_in_sync_context(
                                     self._mcp_client.read_resource(server_config, uri)
                                 )
 
@@ -1014,17 +1070,48 @@ class LLMAgentNode(Node):
                                     }
                                 )
 
+                    except TimeoutError as e:
+                        self.logger.warning(
+                            f"MCP server '{server_config.get('name', 'unknown')}' timed out after 30 seconds: {e}"
+                        )
+                        # Fall back to mock for this server
+                        context_data.append(
+                            {
+                                "uri": f"mcp://{server_config.get('name', 'unknown')}/fallback",
+                                "content": "MCP server timed out - using fallback content. Check if the server is running and accessible.",
+                                "source": server_config.get("name", "unknown"),
+                                "retrieved_at": datetime.now().isoformat(),
+                                "relevance_score": 0.5,
+                                "metadata": {
+                                    "error": "timeout",
+                                    "error_message": str(e),
+                                },
+                            }
+                        )
                     except Exception as e:
-                        self.logger.debug(f"MCP server connection failed: {e}")
+                        error_type = type(e).__name__
+                        self.logger.error(
+                            f"MCP server '{server_config.get('name', 'unknown')}' connection failed ({error_type}): {e}"
+                        )
+
+                        # Provide helpful error messages based on exception type
+                        if "coroutine" in str(e).lower() and "await" in str(e).lower():
+                            self.logger.error(
+                                "This appears to be an async/await issue. Please report this bug to the Kailash SDK team."
+                            )
+
                         # Fall back to mock for this server
                         context_data.append(
                             {
                                 "uri": f"mcp://{server_config.get('name', 'unknown')}/fallback",
-                                "content": "Connection failed, using fallback content",
+                                "content": f"Connection failed ({error_type}) - using fallback content. Error: {str(e)}",
                                 "source": server_config.get("name", "unknown"),
                                 "retrieved_at": datetime.now().isoformat(),
                                 "relevance_score": 0.5,
-                                "metadata": {"error": str(e)},
+                                "metadata": {
+                                    "error": error_type,
+                                    "error_message": str(e),
+                                },
                             }
                         )
 
@@ -1032,11 +1119,17 @@ class LLMAgentNode(Node):
                 if context_data:
                     return context_data
 
-            except ImportError:
+            except ImportError as e:
                 # MCPClient not available, fall back to mock
+                self.logger.info(
+                    "MCP client not available. Install the MCP SDK with 'pip install mcp' to use real MCP servers."
+                )
                 pass
             except Exception as e:
-                self.logger.debug(f"MCP retrieval error: {e}")
+                self.logger.error(
+                    f"Unexpected error in MCP retrieval: {type(e).__name__}: {e}"
+                )
+                self.logger.info("Falling back to mock MCP implementation.")
 
         # Fallback to mock implementation
         for uri in mcp_context:
@@ -1089,9 +1182,7 @@ class LLMAgentNode(Node):
 
         if use_real_mcp:
             try:
-                import asyncio
-
-                from kailash.mcp import MCPClient
+                from kailash.mcp_server import MCPClient
 
                 # Initialize MCP client if not already done
                 if not hasattr(self, "_mcp_client"):
@@ -1101,7 +1192,7 @@ class LLMAgentNode(Node):
                 for server_config in mcp_servers:
                     try:
                         # Discover tools asynchronously
-                        tools = asyncio.run(
+                        tools = self._run_async_in_sync_context(
                             self._mcp_client.discover_tools(server_config)
                         )
 
@@ -1131,16 +1222,27 @@ class LLMAgentNode(Node):
                                     {"type": "function", "function": function_def}
                                 )
 
+                    except TimeoutError as e:
+                        self.logger.warning(
+                            f"Tool discovery timed out for MCP server '{server_config.get('name', 'unknown')}': {e}"
+                        )
                     except Exception as e:
-                        self.logger.debug(
-                            f"Failed to discover tools from {server_config.get('name', 'unknown')}: {e}"
+                        error_type = type(e).__name__
+                        self.logger.error(
+                            f"Failed to discover tools from '{server_config.get('name', 'unknown')}' ({error_type}): {e}"
                         )
 
             except ImportError:
                 # MCPClient not available, use mock tools
+                self.logger.info(
+                    "MCP client not available for tool discovery. Install with 'pip install mcp' for real MCP tools."
+                )
                 pass
             except Exception as e:
-                self.logger.debug(f"MCP tool discovery error: {e}")
+                self.logger.error(
+                    f"Unexpected error in MCP tool discovery: {type(e).__name__}: {e}"
+                )
+                self.logger.info("Using mock tools as fallback.")
 
         # If no real tools discovered, provide minimal generic tools
         if not discovered_tools:
@@ -1665,7 +1767,7 @@ class LLMAgentNode(Node):
         server_config = mcp_tool.get("function", {}).get("mcp_server_config", {})
 
         try:
-            from kailash.mcp import MCPClient
+            from kailash.mcp_server import MCPClient
 
             # Initialize MCP client if not already done
             if not hasattr(self, "_mcp_client"):

kailash/nodes/data/sql.py

@@ -494,6 +494,30 @@ class SQLDatabaseNode(Node):
             "execution_time": execution_time,
         }
 
+    async def async_run(self, **kwargs) -> dict[str, Any]:
+        """
+        Async wrapper for the run method to maintain backward compatibility.
+
+        This method provides an async interface while maintaining the same
+        functionality as the synchronous run method. The underlying SQLAlchemy
+        operations are still synchronous but wrapped for async compatibility.
+
+        Args:
+            **kwargs: Same parameters as run()
+
+        Returns:
+            Same return format as run()
+
+        Note:
+            This is a compatibility method. The actual database operations
+            are still synchronous underneath.
+        """
+        import asyncio
+
+        # Run the synchronous method in a thread pool to avoid blocking
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, lambda: self.run(**kwargs))
+
     @classmethod
     def get_pool_status(cls) -> dict[str, Any]:
         """Get status of all shared connection pools."""

kailash/resources/registry.py

@@ -266,6 +266,12 @@ class ResourceRegistry:
                     )
 
             # Try generic cleanup methods
+            elif hasattr(resource, "aclose"):
+                # Use aclose for modern async resources (e.g., Redis)
+                if asyncio.iscoroutinefunction(resource.aclose):
+                    await resource.aclose()
+                else:
+                    resource.aclose()
             elif hasattr(resource, "close"):
                 if asyncio.iscoroutinefunction(resource.close):
                     await resource.close()

kailash/runtime/async_local.py

@@ -717,6 +717,13 @@ class AsyncLocalRuntime(LocalRuntime):
                             # Navigate the path (e.g., "result.data")
                             path_parts = source_path.split(".")
                             current_data = source_data
+
+                            # CRITICAL FIX: Handle paths starting with "result"
+                            # When source_path is "result.field", the node output IS the result
+                            if path_parts[0] == "result" and len(path_parts) > 1:
+                                # Skip the "result" prefix and navigate from the actual data
+                                path_parts = path_parts[1:]
+
                             for part in path_parts:
                                 if (
                                     isinstance(current_data, dict)

kailash/utils/export.py

@@ -4,6 +4,7 @@ import json
 import logging
 import re
 from copy import deepcopy
+from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
 
@@ -643,6 +644,157 @@ class WorkflowExporter:
         except Exception as e:
             raise ExportException(f"Failed to export workflow manifest: {e}") from e
 
+    def export_as_code(self, workflow: Workflow, output_path: str | None = None) -> str:
+        """Export workflow as executable Python code.
+
+        Args:
+            workflow: Workflow to export
+            output_path: Optional path to write Python file
+
+        Returns:
+            Python code string
+
+        Raises:
+            ExportException: If export fails
+        """
+        if not workflow:
+            raise ExportException("Workflow is required")
+
+        try:
+            if self.pre_export_hook:
+                self.pre_export_hook(workflow, "python")
+
+            # Generate Python code
+            metadata = workflow.metadata if hasattr(workflow, "metadata") else {}
+            if isinstance(metadata, dict):
+                name = metadata.get("name", "workflow")
+                description = metadata.get("description", "Generated workflow")
+            else:
+                name = getattr(metadata, "name", "workflow")
+                description = getattr(metadata, "description", "Generated workflow")
+
+            code_lines = [
+                "#!/usr/bin/env python3",
+                '"""',
+                f"Generated workflow: {name}",
+                f"Description: {description}",
+                f"Generated at: {datetime.now(UTC).isoformat()}",
+                '"""',
+                "",
+                "from kailash import WorkflowBuilder",
+                "from kailash.runtime.local import LocalRuntime",
+                "",
+                "",
+                "def build_workflow():",
+                '    """Build the workflow."""',
+                "    builder = WorkflowBuilder()",
+                "",
+            ]
+
+            # Add nodes
+            for node_id, node in workflow.nodes.items():
+                node_type = node.node_type
+                config = node.config
+
+                # Format config as Python dict
+                config_str = self._format_dict_for_code(config, indent=8)
+
+                code_lines.extend(
+                    [
+                        f"    # Add {node_type} node",
+                        f'    builder.add_node("{node_type}", "{node_id}", config={config_str})',
+                        "",
+                    ]
+                )
+
+            # Add connections
+            if workflow.connections:
+                code_lines.append("    # Add connections")
+                for conn in workflow.connections:
+                    code_lines.append(
+                        f'    builder.add_connection("{conn.source_node}", "{conn.source_output}", '
+                        f'"{conn.target_node}", "{conn.target_input}")'
+                    )
+                code_lines.append("")
+
+            # Build workflow
+            code_lines.extend(
+                [
+                    f'    return builder.build("{name}")',
+                    "",
+                    "",
+                    "def main():",
+                    '    """Execute the workflow."""',
+                    "    # Build workflow",
+                    "    workflow = build_workflow()",
+                    "    ",
+                    "    # Create runtime",
+                    "    runtime = LocalRuntime()",
+                    "    ",
+                    "    # Execute workflow",
+                    "    result = runtime.execute(workflow)",
+                    "    ",
+                    "    # Print results",
+                    '    print("Workflow execution completed!")',
+                    '    print(f"Result: {result}")',
+                    "",
+                    "",
+                    'if __name__ == "__main__":',
+                    "    main()",
+                    "",
+                ]
+            )
+
+            python_code = "\n".join(code_lines)
+
+            if output_path:
+                try:
+                    Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+                    Path(output_path).write_text(python_code)
+                    # Make executable
+                    Path(output_path).chmod(0o755)
+                except Exception as e:
+                    raise ExportException(
+                        f"Failed to write Python code to '{output_path}': {e}"
+                    ) from e
+
+            if self.post_export_hook:
+                self.post_export_hook(workflow, "python", python_code)
+
+            return python_code
+
+        except ExportException:
+            raise
+        except Exception as e:
+            raise ExportException(f"Failed to export workflow as code: {e}") from e
+
+    def _format_dict_for_code(self, data: dict, indent: int = 0) -> str:
+        """Format dictionary for Python code generation."""
+        if not data:
+            return "{}"
+
+        lines = ["{"]
+        indent_str = " " * indent
+        inner_indent = " " * (indent + 4)
+
+        for i, (key, value) in enumerate(data.items()):
+            if isinstance(value, str):
+                value_str = f'"{value}"'
+            elif isinstance(value, dict):
+                value_str = self._format_dict_for_code(value, indent + 4)
+            elif isinstance(value, list):
+                value_str = str(value)
+            else:
+                value_str = str(value)
+
+            line = f'{inner_indent}"{key}": {value_str}'
+            if i < len(data) - 1:
+                line += ","
+            lines.append(line)
+
+        lines.append(indent_str + "}")
+        return "\n".join(lines)
+
     def export_with_templates(
         self, workflow: Workflow, template_name: str, output_dir: str
     ) -> dict[str, str]:

kailash/workflow/builder.py

@@ -162,6 +162,48 @@ class WorkflowBuilder:
 
         logger.info(f"Connected '{from_node}.{from_output}' to '{to_node}.{to_input}'")
 
+    def connect(
+        self,
+        from_node: str,
+        to_node: str,
+        mapping: dict = None,
+        from_output: str = None,
+        to_input: str = None,
+    ) -> None:
+        """
+        Connect two nodes in the workflow with flexible parameter formats.
+
+        This method provides a more intuitive API for connecting nodes and supports
+        both simple connections and complex mapping-based connections.
+
+        Args:
+            from_node: Source node ID
+            to_node: Target node ID
+            mapping: Dict mapping from_output to to_input (e.g., {"data": "input"})
+            from_output: Single output field (alternative to mapping)
+            to_input: Single input field (alternative to mapping)
+
+        Examples:
+            # Simple connection
+            workflow.connect("node1", "node2", from_output="data", to_input="input")
+
+            # Mapping-based connection
+            workflow.connect("node1", "node2", mapping={"data": "input"})
+
+            # Default data flow
+            workflow.connect("node1", "node2")  # Uses "data" -> "data"
+        """
+        if mapping:
+            # Handle mapping-based connections
+            for from_out, to_in in mapping.items():
+                self.add_connection(from_node, from_out, to_node, to_in)
+        elif from_output and to_input:
+            # Handle explicit parameter connections
+            self.add_connection(from_node, from_output, to_node, to_input)
+        else:
+            # Default data flow
+            self.add_connection(from_node, "data", to_node, "data")
+
     def set_metadata(self, **kwargs) -> "WorkflowBuilder":
         """
         Set workflow metadata.