kailash 0.1.5__py3-none-any.whl → 0.2.0__py3-none-any.whl

kailash/mcp/server_new.py

@@ -0,0 +1,336 @@
+"""
+MCP Server - Base class for creating MCP servers using FastMCP.
+
+This provides a clean way to create MCP servers that run as standalone services,
+not as workflow nodes.
+"""
+
+import asyncio
+import logging
+import signal
+import sys
+from typing import Callable, List, Optional
+
+try:
+    from mcp.server import Server
+    from mcp.server.models import InitializationOptions
+    from mcp.types import EmbeddedResource, ImageContent, Resource, TextContent, Tool
+
+    MCP_AVAILABLE = True
+except ImportError:
+    MCP_AVAILABLE = False
+
+
+class MCPServer:
+    """
+    Base class for creating MCP servers.
+
+    This class provides a foundation for building MCP servers that expose
+    tools, resources, and prompts. Servers run as standalone processes,
+    not as workflow nodes.
+
+    Examples:
+        >>> class MyServer(MCPServer):
+        ...     def setup(self):
+        ...         @self.tool()
+        ...         def search(query: str) -> str:
+        ...             return f"Searching for: {query}"
+        ...
+        ...         @self.resource("data://example")
+        ...         def get_example():
+        ...             return "Example data"
+        >>>
+        >>> server = MyServer("my-server", port=8080)
+        >>> server.run()  # Runs until stopped
+    """
+
+    def __init__(self, name: str, port: Optional[int] = None):
+        """
+        Initialize MCP server.
+
+        Args:
+            name: Server name
+            port: Port for HTTP transport (None for stdio)
+        """
+        if not MCP_AVAILABLE:
+            raise ImportError("MCP SDK not available. Install with: pip install mcp")
+
+        self.name = name
+        self.port = port
+        self.logger = logging.getLogger(f"mcp.{name}")
+
+        # Create MCP server
+        self.server = Server(name)
+        self._setup_done = False
+        self._tools = {}
+        self._resources = {}
+        self._prompts = {}
+
+        # Setup signal handlers
+        signal.signal(signal.SIGINT, self._signal_handler)
+        signal.signal(signal.SIGTERM, self._signal_handler)
+
+    def _signal_handler(self, signum, frame):
+        """Handle shutdown signals."""
+        self.logger.info(f"Received signal {signum}, shutting down...")
+        sys.exit(0)
+
+    def setup(self):
+        """
+        Override this method to setup server tools, resources, and prompts.
+
+        Example:
+            def setup(self):
+                @self.tool()
+                def my_tool(arg: str) -> str:
+                    return f"Processed: {arg}"
+        """
+        pass
+
+    def tool(self, name: Optional[str] = None, description: Optional[str] = None):
+        """
+        Decorator to register a tool with the MCP server.
+
+        Args:
+            name: Tool name (defaults to function name)
+            description: Tool description (defaults to docstring)
+
+        Returns:
+            Decorator function
+        """
+
+        def decorator(func: Callable):
+            tool_name = name or func.__name__
+            tool_desc = description or (func.__doc__ or "").strip()
+
+            # Register with MCP server
+            @self.server.call_tool()
+            async def handle_tool_call(name: str, arguments: dict) -> List[TextContent]:
+                if name == tool_name:
+                    try:
+                        # Call the tool function
+                        if asyncio.iscoroutinefunction(func):
+                            result = await func(**arguments)
+                        else:
+                            result = func(**arguments)
+
+                        # Convert result to TextContent
+                        if isinstance(result, str):
+                            return [TextContent(type="text", text=result)]
+                        else:
+                            import json
+
+                            return [
+                                TextContent(
+                                    type="text", text=json.dumps(result, indent=2)
+                                )
+                            ]
+                    except Exception as e:
+                        error_msg = f"Tool '{tool_name}' failed: {str(e)}"
+                        self.logger.error(error_msg, exc_info=True)
+                        return [TextContent(type="text", text=f"Error: {error_msg}")]
+
+                raise ValueError(f"Unknown tool: {name}")
+
+            # Store tool metadata
+            self._tools[tool_name] = {
+                "name": tool_name,
+                "description": tool_desc,
+                "function": func,
+            }
+
+            return func
+
+        return decorator
+
+    def resource(
+        self, uri: str, name: Optional[str] = None, description: Optional[str] = None
+    ):
+        """
+        Decorator to register a resource with the MCP server.
+
+        Args:
+            uri: Resource URI
+            name: Resource name
+            description: Resource description
+
+        Returns:
+            Decorator function
+        """
+
+        def decorator(func: Callable):
+            resource_name = name or uri.split("/")[-1]
+            resource_desc = description or (func.__doc__ or "").strip()
+
+            # Store resource metadata
+            self._resources[uri] = {
+                "uri": uri,
+                "name": resource_name,
+                "description": resource_desc,
+                "function": func,
+            }
+
+            return func
+
+        return decorator
+
+    def _setup_handlers(self):
+        """Setup MCP protocol handlers."""
+        if self._setup_done:
+            return
+
+        # Call user setup
+        self.setup()
+
+        # Register list_tools handler
+        @self.server.list_tools()
+        async def handle_list_tools() -> List[Tool]:
+            tools = []
+            for tool_name, tool_info in self._tools.items():
+                # Generate input schema from function signature
+                import inspect
+
+                sig = inspect.signature(tool_info["function"])
+
+                properties = {}
+                required = []
+
+                for param_name, param in sig.parameters.items():
+                    if param_name == "self":
+                        continue
+
+                    # Determine type
+                    param_type = "string"  # Default
+                    if param.annotation != inspect.Parameter.empty:
+                        if param.annotation == int:
+                            param_type = "integer"
+                        elif param.annotation == float:
+                            param_type = "number"
+                        elif param.annotation == bool:
+                            param_type = "boolean"
+                        elif param.annotation == dict:
+                            param_type = "object"
+                        elif param.annotation == list:
+                            param_type = "array"
+
+                    properties[param_name] = {
+                        "type": param_type,
+                        "description": f"Parameter {param_name}",
+                    }
+
+                    if param.default == inspect.Parameter.empty:
+                        required.append(param_name)
+
+                input_schema = {
+                    "type": "object",
+                    "properties": properties,
+                    "required": required,
+                }
+
+                tools.append(
+                    Tool(
+                        name=tool_name,
+                        description=tool_info["description"],
+                        inputSchema=input_schema,
+                    )
+                )
+
+            return tools
+
+        # Register list_resources handler
+        @self.server.list_resources()
+        async def handle_list_resources() -> List[Resource]:
+            resources = []
+            for uri, resource_info in self._resources.items():
+                resources.append(
+                    Resource(
+                        uri=uri,
+                        name=resource_info["name"],
+                        description=resource_info["description"],
+                        mimeType="text/plain",  # Default, could be customized
+                    )
+                )
+            return resources
+
+        # Register read_resource handler
+        @self.server.read_resource()
+        async def handle_read_resource(uri: str) -> List[TextContent]:
+            if uri in self._resources:
+                resource_info = self._resources[uri]
+                func = resource_info["function"]
+
+                try:
+                    # Call the resource function
+                    if asyncio.iscoroutinefunction(func):
+                        result = await func()
+                    else:
+                        result = func()
+
+                    # Convert result to TextContent
+                    if isinstance(result, str):
+                        return [TextContent(type="text", text=result)]
+                    else:
+                        import json
+
+                        return [
+                            TextContent(type="text", text=json.dumps(result, indent=2))
+                        ]
+                except Exception as e:
+                    error_msg = f"Resource '{uri}' failed: {str(e)}"
+                    self.logger.error(error_msg, exc_info=True)
+                    return [TextContent(type="text", text=f"Error: {error_msg}")]
+
+            raise ValueError(f"Resource not found: {uri}")
+
+        self._setup_done = True
+
+    def run(self):
+        """
+        Run the MCP server.
+
+        This method blocks until the server is stopped.
+        """
+        self._setup_handlers()
+
+        self.logger.info(f"Starting MCP server '{self.name}'")
+
+        if self.port is not None:
+            # HTTP/SSE transport
+            self.logger.info(f"Server will listen on port {self.port}")
+            # Note: Actual HTTP server implementation would go here
+            # For now, we'll use stdio as the primary transport
+
+        # Run with stdio transport
+        import mcp.server.stdio
+
+        # Configure server options
+        init_options = InitializationOptions(
+            server_name=self.name,
+            server_version="1.0.0",
+            capabilities=self.server.get_capabilities(),
+        )
+
+        # Run the server
+        asyncio.run(
+            mcp.server.stdio.stdio_server(self.server.request_handlers, init_options)
+        )
+
+    async def arun(self):
+        """
+        Async version of run().
+
+        Use this if you need to run the server in an existing async context.
+        """
+        self._setup_handlers()
+
+        self.logger.info(f"Starting MCP server '{self.name}' (async)")
+
+        import mcp.server.stdio
+
+        init_options = InitializationOptions(
+            server_name=self.name,
+            server_version="1.0.0",
+            capabilities=self.server.get_capabilities(),
+        )
+
+        await mcp.server.stdio.stdio_server(self.server.request_handlers, init_options)

kailash/mcp/servers/__init__.py

@@ -0,0 +1,12 @@
+"""
+Pre-built MCP servers for common use cases.
+
+Available servers:
+- AIRegistryServer: Provides access to AI use case registry data
+- FileSystemServer: Provides access to local file system
+- DatabaseServer: Provides access to database resources
+"""
+
+from .ai_registry import AIRegistryServer
+
+__all__ = ["AIRegistryServer"]

kailash/mcp/servers/ai_registry.py

@@ -0,0 +1,289 @@
+"""AI Registry MCP Server using FastMCP.
+
+This server provides access to AI use case registry data via MCP,
+exposing tools for searching, analyzing, and exploring AI implementations.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict
+
+from kailash.mcp.server import MCPServer
+
+
+class AIRegistryServer(MCPServer):
+    """MCP server for AI use case registry.
+
+    Provides tools and resources for exploring AI use cases from
+    ISO/IEC standards and industry implementations.
+
+    Examples:
+        >>> server = AIRegistryServer(
+        ...     registry_file="data/ai_registry.json",
+        ...     port=8080
+        ... )
+        >>> server.start()  # Runs until stopped
+    """
+
+    def __init__(
+        self,
+        registry_file: str = "research/combined_ai_registry.json",
+        name: str = "ai-registry",
+        port: int = 8080,
+        host: str = "localhost",
+    ):
+        """Initialize the AI Registry server.
+
+        Args:
+            registry_file: Path to JSON file containing AI use cases
+            name: Server name
+            port: Port to listen on
+            host: Host to bind to
+        """
+        super().__init__(name, port, host)
+        self.registry_file = registry_file
+        self._registry_data = None
+        self._load_registry()
+
+    def _load_registry(self):
+        """Load the AI registry data from file."""
+        try:
+            registry_path = Path(self.registry_file)
+            if registry_path.exists():
+                with open(registry_path, "r", encoding="utf-8") as f:
+                    self._registry_data = json.load(f)
+            else:
+                # Provide sample data if file not found
+                self._registry_data = {
+                    "use_cases": [
+                        {
+                            "use_case_id": 1,
+                            "name": "Medical Diagnosis Assistant",
+                            "application_domain": "Healthcare",
+                            "description": "AI system to assist doctors in diagnosing diseases",
+                            "ai_methods": ["Machine Learning", "Deep Learning"],
+                            "status": "Production",
+                        },
+                        {
+                            "use_case_id": 2,
+                            "name": "Fraud Detection System",
+                            "application_domain": "Finance",
+                            "description": "Real-time fraud detection in financial transactions",
+                            "ai_methods": ["Anomaly Detection", "Pattern Recognition"],
+                            "status": "Production",
+                        },
+                    ]
+                }
+        except Exception as e:
+            self.logger.error(f"Failed to load registry: {e}")
+            self._registry_data = {"use_cases": []}
+
+    def setup(self):
+        """Setup server tools and resources."""
+
+        @self.add_tool()
+        def search_use_cases(query: str, limit: int = 10) -> Dict[str, Any]:
+            """Search for AI use cases matching the query.
+
+            Args:
+                query: Search query string
+                limit: Maximum number of results to return
+
+            Returns:
+                Search results with matching use cases
+            """
+            if not self._registry_data:
+                return {"results": [], "count": 0, "query": query}
+
+            use_cases = self._registry_data.get("use_cases", [])
+            results = []
+
+            query_lower = query.lower()
+            for use_case in use_cases:
+                # Search in multiple fields
+                searchable_text = " ".join(
+                    [
+                        str(use_case.get("name", "")),
+                        str(use_case.get("description", "")),
+                        str(use_case.get("application_domain", "")),
+                        " ".join(use_case.get("ai_methods", [])),
+                    ]
+                )
+
+                if query_lower in searchable_text.lower():
+                    results.append(use_case)
+                    if len(results) >= limit:
+                        break
+
+            return {"results": results, "count": len(results), "query": query}
+
+        @self.add_tool()
+        def filter_by_domain(domain: str) -> Dict[str, Any]:
+            """Filter use cases by application domain.
+
+            Args:
+                domain: Application domain to filter by
+
+            Returns:
+                Use cases in the specified domain
+            """
+            if not self._registry_data:
+                return {"domain": domain, "use_cases": [], "count": 0}
+
+            use_cases = self._registry_data.get("use_cases", [])
+            filtered = [
+                uc
+                for uc in use_cases
+                if uc.get("application_domain", "").lower() == domain.lower()
+            ]
+
+            return {"domain": domain, "use_cases": filtered, "count": len(filtered)}
+
+        @self.add_tool()
+        def get_use_case_details(use_case_id: int) -> Dict[str, Any]:
+            """Get detailed information about a specific use case.
+
+            Args:
+                use_case_id: ID of the use case
+
+            Returns:
+                Detailed use case information
+            """
+            if not self._registry_data:
+                return {"error": "No registry data available"}
+
+            use_cases = self._registry_data.get("use_cases", [])
+            for use_case in use_cases:
+                if use_case.get("use_case_id") == use_case_id:
+                    return {"use_case": use_case}
+
+            return {"error": f"Use case {use_case_id} not found"}
+
+        @self.add_tool()
+        def list_domains() -> Dict[str, Any]:
+            """List all available application domains.
+
+            Returns:
+                List of domains with use case counts
+            """
+            if not self._registry_data:
+                return {"domains": []}
+
+            use_cases = self._registry_data.get("use_cases", [])
+            domain_counts = {}
+
+            for use_case in use_cases:
+                domain = use_case.get("application_domain", "Unknown")
+                domain_counts[domain] = domain_counts.get(domain, 0) + 1
+
+            domains = [
+                {"name": domain, "count": count}
+                for domain, count in domain_counts.items()
+            ]
+
+            return {
+                "domains": sorted(domains, key=lambda x: x["count"], reverse=True),
+                "total_domains": len(domains),
+            }
+
+        @self.add_resource("registry://stats")
+        def get_registry_stats():
+            """Get statistics about the AI registry."""
+            if not self._registry_data:
+                return {"error": "No registry data available"}
+
+            use_cases = self._registry_data.get("use_cases", [])
+
+            # Calculate statistics
+            total_count = len(use_cases)
+            domain_counts = {}
+            method_counts = {}
+            status_counts = {}
+
+            for use_case in use_cases:
+                # Count by domain
+                domain = use_case.get("application_domain", "Unknown")
+                domain_counts[domain] = domain_counts.get(domain, 0) + 1
+
+                # Count by AI method
+                for method in use_case.get("ai_methods", []):
+                    method_counts[method] = method_counts.get(method, 0) + 1
+
+                # Count by status
+                status = use_case.get("status", "Unknown")
+                status_counts[status] = status_counts.get(status, 0) + 1
+
+            return {
+                "total_use_cases": total_count,
+                "domains": domain_counts,
+                "ai_methods": method_counts,
+                "status_distribution": status_counts,
+            }
+
+        @self.add_resource("registry://domains/{domain}")
+        def get_domain_resource(domain: str):
+            """Get all use cases for a specific domain."""
+            result = filter_by_domain(domain)
+            return result
+
+        @self.add_prompt("analyze_use_case")
+        def analyze_use_case_prompt(
+            use_case_name: str, focus_area: str = "implementation"
+        ) -> str:
+            """Generate a prompt for analyzing a use case.
+
+            Args:
+                use_case_name: Name of the use case
+                focus_area: Area to focus on (implementation, challenges, benefits)
+
+            Returns:
+                Analysis prompt
+            """
+            return f"""Please analyze the AI use case '{use_case_name}' with a focus on {focus_area}.
+
+Consider the following aspects:
+1. Technical implementation requirements
+2. Key challenges and how to address them
+3. Expected benefits and ROI
+4. Best practices and recommendations
+5. Similar use cases and lessons learned
+
+Provide a comprehensive analysis with actionable insights."""
+
+
+# Convenience function to start the server
+def start_server(
+    registry_file: str = "research/combined_ai_registry.json",
+    port: int = 8080,
+    host: str = "localhost",
+):
+    """Start the AI Registry MCP server.
+
+    Args:
+        registry_file: Path to registry JSON file
+        port: Port to listen on
+        host: Host to bind to
+    """
+    server = AIRegistryServer(registry_file, port=port, host=host)
+    server.start()
+
+
+if __name__ == "__main__":
+    # Allow running as a module
+    import sys
+
+    registry_file = os.environ.get(
+        "REGISTRY_FILE", "research/combined_ai_registry.json"
+    )
+    port = int(os.environ.get("PORT", "8080"))
+    host = os.environ.get("HOST", "localhost")
+
+    if "--help" in sys.argv:
+        print("AI Registry MCP Server")
+        print("Environment variables:")
+        print("  REGISTRY_FILE - Path to AI registry JSON file")
+        print("  PORT - Port to listen on (default: 8080)")
+        print("  HOST - Host to bind to (default: localhost)")
+    else:
+        start_server(registry_file, port, host)

kailash/nodes/__init__.py

@@ -1,14 +1,16 @@
 """Node system for the Kailash SDK."""
 
 # Import all node modules to ensure registration
-from kailash.nodes import ai, api, code, data, logic, mcp, transform
+from kailash.nodes import ai, api, code, data, logic, mixins, transform
 from kailash.nodes.base import Node, NodeParameter, NodeRegistry, register_node
 from kailash.nodes.base_async import AsyncNode
+from kailash.nodes.base_cycle_aware import CycleAwareNode
 from kailash.nodes.code import PythonCodeNode
 
 __all__ = [
     "Node",
     "AsyncNode",
+    "CycleAwareNode",
     "NodeParameter",
     "NodeRegistry",
     "register_node",
@@ -19,6 +21,6 @@ __all__ = [
     "code",
     "data",
     "logic",
-    "mcp",
+    "mixins",
     "transform",
 ]

kailash/nodes/ai/__init__.py

@@ -25,6 +25,7 @@ from .intelligent_agent_orchestrator import (
     OrchestrationManagerNode,
     QueryAnalysisNode,
 )
+from .iterative_llm_agent import IterativeLLMAgentNode
 from .llm_agent import LLMAgentNode
 from .models import (
     ModelPredictor,
@@ -51,6 +52,7 @@ __all__ = [
     "FunctionCallingAgent",
     "PlanningAgent",
     "LLMAgentNode",
+    "IterativeLLMAgentNode",
     # A2A Communication
     "A2AAgentNode",
     "SharedMemoryPoolNode",