kailash 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

kailash/nodes/monitoring/performance_benchmark.py

@@ -117,7 +117,7 @@ class PerformanceBenchmarkNode(SecurityMixin, PerformanceMixin, LoggingMixin, No
         ...     time.sleep(0.1)  # Simulate work
         ...     return "completed"
         >>>
-        >>> result = perf_node.run(
+        >>> result = perf_node.execute(
         ...     action="benchmark",
         ...     operation_name="test_operation",
         ...     operation_func=my_operation
@@ -125,7 +125,7 @@ class PerformanceBenchmarkNode(SecurityMixin, PerformanceMixin, LoggingMixin, No
         >>> print(f"Execution time: {result['execution_time_ms']}ms")
         >>>
         >>> # Monitor continuous performance
-        >>> monitor_result = perf_node.run(
+        >>> monitor_result = perf_node.execute(
         ...     action="monitor",
         ...     operations=["api_response", "db_query"],
         ...     duration_seconds=60
@@ -233,8 +233,7 @@ class PerformanceBenchmarkNode(SecurityMixin, PerformanceMixin, LoggingMixin, No
                 name="operations",
                 type=list,
                 description="List of operations to monitor",
-                required=False,
-                default=[],
+                required=True,
             ),
             "duration_seconds": NodeParameter(
                 name="duration_seconds",
@@ -268,6 +267,63 @@ class PerformanceBenchmarkNode(SecurityMixin, PerformanceMixin, LoggingMixin, No
                 description="Time range for querying metrics",
                 required=False,
             ),
+            "enable_monitoring": NodeParameter(
+                name="enable_monitoring",
+                type=bool,
+                description="Enable continuous monitoring",
+                required=False,
+                default=True,
+            ),
+            "performance_targets": NodeParameter(
+                name="performance_targets",
+                type=dict,
+                description="Performance targets for monitoring",
+                required=False,
+                default={},
+            ),
+            "alert_thresholds": NodeParameter(
+                name="alert_thresholds",
+                type=dict,
+                description="Alert thresholds for performance metrics",
+                required=False,
+                default={},
+            ),
+            "enable_mcp_metrics": NodeParameter(
+                name="enable_mcp_metrics",
+                type=bool,
+                description="Enable MCP metrics collection",
+                required=False,
+                default=False,
+            ),
+        }
+
+    def get_output_schema(self) -> Dict[str, NodeParameter]:
+        """Get node output schema for validation and documentation.
+
+        Returns:
+            Dictionary mapping output field names to NodeParameter objects
+        """
+        return {
+            "results": NodeParameter(
+                name="results",
+                type=list,
+                description="List of benchmark results",
+            ),
+            "summary": NodeParameter(
+                name="summary",
+                type=dict,
+                description="Summary statistics of benchmark results",
+            ),
+            "alerts": NodeParameter(
+                name="alerts",
+                type=list,
+                description="Performance alerts triggered during benchmarking",
+            ),
+            "recommendations": NodeParameter(
+                name="recommendations",
+                type=list,
+                description="Performance optimization recommendations",
+            ),
         }
 
     def execute(self, **kwargs) -> Dict[str, Any]:
@@ -279,6 +335,13 @@ class PerformanceBenchmarkNode(SecurityMixin, PerformanceMixin, LoggingMixin, No
         Returns:
             Performance benchmark results
         """
+        # If action is not provided, infer it from the parameters
+        if "action" not in kwargs:
+            if "operations" in kwargs:
+                kwargs["action"] = "benchmark"
+            else:
+                kwargs["action"] = "monitor"
+
         return self.run(**kwargs)
 
     def run(
@@ -326,15 +389,78 @@ class PerformanceBenchmarkNode(SecurityMixin, PerformanceMixin, LoggingMixin, No
 
             # Route to appropriate action handler
             if action == "benchmark":
-                if not operation_name or not operation_func:
+                # Handle single operation or list of operations
+                if operations and len(operations) > 0:
+                    # Handle list of operations
+                    all_results = []
+                    for i, operation in enumerate(operations):
+                        if callable(operation):
+                            op_name = getattr(operation, "__name__", f"operation_{i}")
+                            result = self._benchmark_operation(
+                                op_name, operation, kwargs
+                            )
+                            # Extract individual results from the benchmark operation
+                            if result.get("success", False):
+                                detailed_results = result.get("detailed_results", [])
+                                all_results.extend(detailed_results)
+                            else:
+                                # Add failed operation result
+                                all_results.append(
+                                    {
+                                        "operation_name": op_name,
+                                        "success": False,
+                                        "error_message": result.get(
+                                            "error", "Benchmark failed"
+                                        ),
+                                        "execution_time_ms": 0,
+                                        "memory_used_mb": 0,
+                                        "cpu_usage_percent": 0,
+                                        "metadata": {},
+                                        "timestamp": datetime.now(UTC),
+                                    }
+                                )
+                        else:
+                            # String operation name - would need to look up the function
+                            all_results.append(
+                                {
+                                    "operation_name": str(operation),
+                                    "success": False,
+                                    "error_message": "Operation function not provided",
+                                    "execution_time_ms": 0,
+                                    "memory_used_mb": 0,
+                                    "cpu_usage_percent": 0,
+                                    "metadata": {},
+                                    "timestamp": datetime.now(UTC),
+                                }
+                            )
+
+                    # Return combined results
+                    result = {
+                        "results": all_results,
+                        "summary": {
+                            "total_operations": len(all_results),
+                            "successful_operations": sum(
+                                1 for r in all_results if r.get("success", False)
+                            ),
+                            "failed_operations": sum(
+                                1 for r in all_results if not r.get("success", False)
+                            ),
+                        },
+                        "alerts": [],
+                        "recommendations": [],
+                    }
+                    self.perf_stats["total_benchmarks"] += len(operations)
+                elif operation_name and operation_func:
+                    # Handle single operation
+                    result = self._benchmark_operation(
+                        operation_name, operation_func, kwargs
+                    )
+                    self.perf_stats["total_benchmarks"] += 1
+                else:
                     return {
                         "success": False,
-                        "error": "operation_name and operation_func required for benchmark",
+                        "error": "Either operations list or operation_name and operation_func required for benchmark",
                     }
-                result = self._benchmark_operation(
-                    operation_name, operation_func, kwargs
-                )
-                self.perf_stats["total_benchmarks"] += 1
                 if result.get("success", False):
                     self.perf_stats["successful_benchmarks"] += 1
                 else:
@@ -1514,7 +1640,7 @@ class PerformanceBenchmarkNode(SecurityMixin, PerformanceMixin, LoggingMixin, No
         }
 
         try:
-            self.security_event_node.run(**security_event)
+            self.security_event_node.execute(**security_event)
         except Exception as e:
             self.log_with_context("WARNING", f"Failed to log performance alert: {e}")
 

kailash/nodes/rag/advanced.py

@@ -255,7 +255,7 @@ Respond with JSON only:
         )
 
         try:
-            verification_response = self.verifier_agent.run(
+            verification_response = self.verifier_agent.execute(
                 messages=[{"role": "user", "content": verification_input}]
             )
 
@@ -447,7 +447,7 @@ class RAGFusionNode(Node):
         # - "tuning neural network hyperparameters"
         # - "neural network training optimization"
 
-        result = await rag_fusion.run(
+        result = await rag_fusion.execute(
             documents=documents,
             query="How to optimize neural networks"
         )
@@ -628,7 +628,7 @@ Original Query: {original_query}
 Generate {self.num_query_variations} high-quality variations that will improve retrieval coverage:
 """
 
-            response = self.query_generator.run(
+            response = self.query_generator.execute(
                 messages=[{"role": "user", "content": generation_input}]
             )
 
@@ -919,7 +919,7 @@ class HyDENode(Node):
         # 3. "Cryptographic systems must evolve to be quantum-resistant..."
         # Then retrieves documents similar to these hypotheses
 
-        result = await hyde.run(
+        result = await hyde.execute(
             documents=documents,
             query="What are the implications of quantum computing for cryptography?"
         )
@@ -1077,7 +1077,7 @@ Query: {query}
 Generate {self.num_hypotheses if self.use_multiple_hypotheses else 1} detailed hypothetical answer(s) that could help find relevant documents:
 """
 
-            response = self.hypothesis_generator.run(
+            response = self.hypothesis_generator.execute(
                 messages=[{"role": "user", "content": hypothesis_input}]
             )
 
@@ -1250,7 +1250,7 @@ class StepBackRAGNode(Node):
         #   - Abstract docs about normalization concepts
         # Combines both for comprehensive answer
 
-        result = await step_back.run(
+        result = await step_back.execute(
             documents=documents,
             query="Why does batch normalization help neural networks?"
         )
@@ -1394,7 +1394,7 @@ Specific Query: {specific_query}
 Generate a broader, more abstract version that would help retrieve relevant background information:
 """
 
-            response = self.abstraction_generator.run(
+            response = self.abstraction_generator.execute(
                 messages=[{"role": "user", "content": abstraction_input}]
             )
 

kailash/nodes/rag/agentic.py

@@ -62,7 +62,7 @@ class AgenticRAGNode(WorkflowNode):
         # 4. Use calculator for growth calculations
         # 5. Synthesize findings with citations
 
-        result = await agentic_rag.run(
+        result = await agentic_rag.execute(
             documents=financial_docs,
             query="Compare the revenue growth of tech companies in 2023 vs 2022"
         )
@@ -219,7 +219,54 @@ def execute_tool(action_string, documents, context):
                 "sum": sum, "len": len, "pow": pow
             })
 
-            result = eval(params, safe_dict)
+            # Enterprise security: Use ast.literal_eval for safe mathematical expressions
+            import ast
+            try:
+                # Try ast.literal_eval first for simple mathematical expressions
+                result = ast.literal_eval(params)
+            except (ValueError, SyntaxError):
+                # Fallback to safe mathematical evaluation
+                import operator
+                import math
+
+                # Define safe operators and functions
+                safe_ops = {
+                    '+': operator.add,
+                    '-': operator.sub,
+                    '*': operator.mul,
+                    '/': operator.truediv,
+                    '**': operator.pow,
+                    'abs': abs,
+                    'max': max,
+                    'min': min,
+                    'round': round,
+                    'sqrt': math.sqrt,
+                    'sin': math.sin,
+                    'cos': math.cos,
+                    'tan': math.tan,
+                    'log': math.log,
+                    'exp': math.exp,
+                    'pi': math.pi,
+                    'e': math.e,
+                }
+                safe_ops.update(safe_dict)
+
+                # Parse and evaluate safely
+                try:
+                    # Simple expression parser for basic math
+                    import re
+                    # Replace function calls and operators with safe alternatives
+                    safe_expr = params
+                    for func in ['sqrt', 'sin', 'cos', 'tan', 'log', 'exp']:
+                        safe_expr = re.sub(rf'\b{func}\(([^)]+)\)', rf'safe_ops["{func}"](\1)', safe_expr)
+
+                    # Only evaluate if it's a simple mathematical expression
+                    if re.match(r'^[0-9+\-*/.() \w]+$', safe_expr.replace('safe_ops', '')):
+                        result = eval(safe_expr, {"__builtins__": {}}, {"safe_ops": safe_ops})
+                    else:
+                        result = f"Cannot evaluate complex expression: {params}"
+                except:
+                    result = f"Invalid mathematical expression: {params}"
             results = {
                 "tool": "calculate",
                 "expression": params,

kailash/nodes/rag/conversational.py

@@ -62,19 +62,19 @@ class ConversationalRAGNode(WorkflowNode):
         session = await conv_rag.create_session(user_id="user123")
 
         # First turn
-        response1 = await conv_rag.run(
+        response1 = await conv_rag.execute(
             query="What is transformer architecture?",
             session_id=session.id
         )
 
         # Follow-up with context
-        response2 = await conv_rag.run(
+        response2 = await conv_rag.execute(
             query="How does its attention mechanism work?",  # "its" refers to transformer
             session_id=session.id
         )
 
         # Topic switch with smooth transition
-        response3 = await conv_rag.run(
+        response3 = await conv_rag.execute(
             query="Now tell me about BERT",
             session_id=session.id
         )

kailash/nodes/rag/evaluation.py

@@ -57,7 +57,7 @@ class RAGEvaluationNode(WorkflowNode):
         )
 
         # Evaluate a RAG system
-        results = await evaluator.run(
+        results = await evaluator.execute(
             test_queries=[
                 {"query": "What is transformer architecture?",
                  "reference": "Transformers use self-attention..."},
@@ -461,7 +461,7 @@ class RAGBenchmarkNode(Node):
             concurrent_users=[1, 5, 10]
         )
 
-        results = await benchmark.run(
+        results = await benchmark.execute(
             rag_systems={"system_a": rag_a, "system_b": rag_b},
             test_queries=queries
         )
@@ -674,7 +674,7 @@ class TestDatasetGeneratorNode(Node):
             difficulty_levels=["easy", "medium", "hard"]
         )
 
-        dataset = generator.run(
+        dataset = generator.execute(
             num_samples=100,
             domain="machine learning"
         )

kailash/nodes/rag/federated.py

@@ -60,7 +60,7 @@ class FederatedRAGNode(WorkflowNode):
         )
 
         # Query across all federated sources
-        result = await federated_rag.run(
+        result = await federated_rag.execute(
             query="Latest treatment protocols for condition X",
             node_endpoints={
                 "hospital_a": "https://hospitalA.api/rag",
@@ -598,7 +598,7 @@ class EdgeRAGNode(Node):
             update_strategy="incremental"
         )
 
-        result = await edge_rag.run(
+        result = await edge_rag.execute(
             query="Local sensor anomaly detection",
             local_data=sensor_readings,
             sync_with_cloud=False
@@ -848,7 +848,7 @@ class CrossSiloRAGNode(Node):
             audit_mode="comprehensive"
         )
 
-        result = await cross_silo_rag.run(
+        result = await cross_silo_rag.execute(
             query="Industry-wide trend analysis",
             requester_org="org_a",
             access_permissions=["read_aggregated", "no_raw_data"]

kailash/nodes/rag/graph.py

@@ -60,7 +60,7 @@ class GraphRAGNode(WorkflowNode):
         # 3. Traverse graph to find influence paths
         # 4. Synthesize multi-hop connections
 
-        result = await graph_rag.run(
+        result = await graph_rag.execute(
             documents=research_papers,
             query="How did key researchers influence the development of transformers?"
         )
@@ -474,7 +474,7 @@ class GraphBuilderNode(Node):
             similarity_threshold=0.85
         )
 
-        graph = await builder.run(
+        graph = await builder.execute(
             documents=documents,
             existing_graph=previous_graph  # Optional: update existing
         )
@@ -599,7 +599,7 @@ class GraphQueryNode(Node):
         querier = GraphQueryNode()
 
         # Find influence paths
-        result = await querier.run(
+        result = await querier.execute(
             graph=knowledge_graph,
             query_type="path",
             source_entity="BERT",

kailash/nodes/rag/multimodal.py

@@ -62,7 +62,7 @@ class MultimodalRAGNode(WorkflowNode):
         # 3. Code implementations with visual outputs
         # 4. Combine into comprehensive answer with images
 
-        result = await multimodal_rag.run(
+        result = await multimodal_rag.execute(
             documents=mixed_media_docs,  # Contains text and image paths
             query="Show me the architecture diagram for transformers"
         )
@@ -446,7 +446,7 @@ class VisualQuestionAnsweringNode(Node):
     Example:
         vqa = VisualQuestionAnsweringNode()
 
-        result = await vqa.run(
+        result = await vqa.execute(
             image_path="architecture_diagram.png",
             question="What components are shown in this diagram?"
         )
@@ -569,7 +569,7 @@ class ImageTextMatchingNode(Node):
     Example:
         matcher = ImageTextMatchingNode()
 
-        matches = await matcher.run(
+        matches = await matcher.execute(
             query="neural network architecture",
             image_collection=image_database
         )

kailash/nodes/rag/optimized.py

@@ -57,13 +57,13 @@ class CacheOptimizedRAGNode(WorkflowNode):
         )
 
         # First query: ~500ms (goes to retrieval)
-        result1 = await cached_rag.run(query="What is deep learning?")
+        result1 = await cached_rag.execute(query="What is deep learning?")
 
         # Exact match: ~10ms (from cache)
-        result2 = await cached_rag.run(query="What is deep learning?")
+        result2 = await cached_rag.execute(query="What is deep learning?")
 
         # Similar query: ~15ms (semantic cache)
-        result3 = await cached_rag.run(query="Explain deep learning")
+        result3 = await cached_rag.execute(query="Explain deep learning")
 
     Parameters:
         cache_ttl: Time-to-live in seconds
@@ -306,7 +306,7 @@ class AsyncParallelRAGNode(WorkflowNode):
         )
 
         # Runs all 4 strategies in parallel, takes time of slowest
-        result = await parallel_rag.run(
+        result = await parallel_rag.execute(
             documents=documents,
             query="Complex technical question requiring precision"
         )
@@ -700,7 +700,7 @@ class BatchOptimizedRAGNode(WorkflowNode):
         # Process 100 queries efficiently
         queries = ["query1", "query2", ..., "query100"]
 
-        results = await batch_rag.run(
+        results = await batch_rag.execute(
             queries=queries,
             documents=documents
         )

kailash/nodes/rag/privacy.py

@@ -58,7 +58,7 @@ class PrivacyPreservingRAGNode(WorkflowNode):
         )
 
         # Query with sensitive information
-        result = await private_rag.run(
+        result = await private_rag.execute(
             query="What is John Smith's diagnosis based on symptoms X, Y, Z?",
             documents=medical_records,
             user_consent={"data_usage": True, "retention_days": 7}
@@ -608,7 +608,7 @@ class SecureMultiPartyRAGNode(Node):
         )
 
         # Each party contributes encrypted data
-        result = await smpc_rag.run(
+        result = await smpc_rag.execute(
             query="Average treatment success rate",
             party_data={
                 "hospital_a": encrypted_data_a,
@@ -800,7 +800,7 @@ class ComplianceRAGNode(Node):
             default_retention_days=30
         )
 
-        result = await compliance_rag.run(
+        result = await compliance_rag.execute(
             query="Patient symptoms analysis",
             user_consent={
                 "purpose": "medical_diagnosis",

kailash/nodes/rag/query_processing.py

@@ -56,7 +56,7 @@ class QueryExpansionNode(Node):
         # - "deep learning optimization"
         # - "AI optimization techniques"
 
-        expanded = await expander.run(query="ML optimization")
+        expanded = await expander.execute(query="ML optimization")
 
     Parameters:
         expansion_method: Algorithm (llm, wordnet, custom)
@@ -236,7 +236,7 @@ class QueryDecompositionNode(Node):
         # 4. "How are CNNs used in vision?"
         # 5. "What are the key differences?"
 
-        plan = await decomposer.run(
+        plan = await decomposer.execute(
             query="Compare transformer and CNN architectures for NLP and vision"
         )
 
@@ -426,7 +426,7 @@ class QueryRewritingNode(Node):
         #   technical: "neural network training process Keras implementation"
         #   simplified: "train neural network keras"
 
-        rewritten = await rewriter.run(
+        rewritten = await rewriter.execute(
             query="how 2 trian nueral netwrk wit keras"
         )
 
@@ -656,7 +656,7 @@ class QueryIntentClassifierNode(Node):
         #   requirements: ["needs_examples", "needs_code"]
         #   recommended_strategy: "statistical"
 
-        intent = await classifier.run(
+        intent = await classifier.execute(
             query="Show me Python code to implement gradient descent"
         )
 
@@ -924,7 +924,7 @@ class MultiHopQueryPlannerNode(Node):
         # Hop 3: "What BERT innovations are used in modern models?"
         # Hop 4: "How do modern models improve on BERT?"
 
-        plan = await planner.run(
+        plan = await planner.execute(
             query="How has BERT influenced modern NLP architectures?"
         )
 
@@ -1179,7 +1179,7 @@ class AdaptiveQueryProcessorNode(Node):
         # - Decomposition (if complex)
         # - Multi-hop planning (if required)
 
-        optimized = await processor.run(
+        optimized = await processor.execute(
             query="compair transfomer vs lstm for sequnce tasks"
         )
         # Corrects spelling, decomposes comparison, plans retrieval

kailash/nodes/rag/realtime.py

@@ -63,7 +63,7 @@ class RealtimeRAGNode(WorkflowNode):
         ])
 
         # Query with real-time data
-        result = await realtime_rag.run(
+        result = await realtime_rag.execute(
             query="What are the latest developments in AI?"
         )
         # Returns most recent relevant information

kailash/nodes/rag/registry.py

@@ -8,11 +8,7 @@ Provides a unified interface for users to find the right RAG approach.
 import logging
 from typing import Any, Dict, List, Optional, Type
 
-from .router import (
-    RAGPerformanceMonitorNode,
-    RAGQualityAnalyzerNode,
-    RAGStrategyRouterNode,
-)
+from .router import RAGPerformanceMonitorNode, RAGQualityAnalyzerNode, RAGStrategyRouterNode
 from .strategies import (
     HierarchicalRAGNode,
     HybridRAGNode,
@@ -448,7 +444,7 @@ performance_monitor = registry.create_utility("performance_monitor")
 ```python
 # Use strategy directly
 semantic_rag = registry.create_strategy("semantic")
-result = semantic_rag.run(documents=docs, operation="index")
+result = semantic_rag.execute(documents=docs, operation="index")
 ```
 
 ### In Workflows:

kailash/nodes/rag/router.py

@@ -88,7 +88,7 @@ class RAGStrategyRouterNode(Node):
         )
 
         try:
-            llm_response = self.llm_agent.run(
+            llm_response = self.llm_agent.execute(
                 messages=[{"role": "user", "content": llm_input}]
             )