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

{kailash-0.1.4.dist-info → kailash-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kailash
-Version: 0.1.4
+Version: 0.2.0
 Summary: Python SDK for the Kailash container-node architecture
 Home-page: https://github.com/integrum/kailash-python-sdk
 Author: Integrum
@@ -47,6 +47,13 @@ Requires-Dist: pytest-asyncio>=1.0.0
 Requires-Dist: pre-commit>=4.2.0
 Requires-Dist: twine>=6.1.0
 Requires-Dist: ollama>=0.5.1
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: websockets>=12.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: python-jose>=3.5.0
+Requires-Dist: pytest-xdist>=3.6.0
+Requires-Dist: pytest-timeout>=2.3.0
+Requires-Dist: pytest-split>=0.9.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=3.0; extra == "dev"
@@ -66,7 +73,7 @@ Dynamic: requires-python
   <a href="https://pepy.tech/project/kailash"><img src="https://static.pepy.tech/badge/kailash" alt="Downloads"></a>
   <img src="https://img.shields.io/badge/license-MIT-green.svg" alt="MIT License">
   <img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Code style: black">
-  <img src="https://img.shields.io/badge/tests-753%20passing-brightgreen.svg" alt="Tests: 753 passing">
+  <img src="https://img.shields.io/badge/tests-734%20passing-brightgreen.svg" alt="Tests: 734 passing">
   <img src="https://img.shields.io/badge/coverage-100%25-brightgreen.svg" alt="Coverage: 100%">
 </p>
 
@@ -92,6 +99,13 @@ Dynamic: requires-python
 - 🧠 **Retrieval-Augmented Generation**: Full RAG pipeline with intelligent document processing
 - 🌐 **REST API Wrapper**: Expose any workflow as a production-ready API in 3 lines
 - 🚪 **Multi-Workflow Gateway**: Manage multiple workflows through unified API with MCP integration
+- 🤖 **Self-Organizing Agents**: Autonomous agent pools with intelligent team formation and convergence detection
+- 🧠 **Agent-to-Agent Communication**: Shared memory pools and intelligent caching for coordinated multi-agent systems
+- 🔒 **Production Security**: Comprehensive security framework with path traversal prevention, code sandboxing, and audit logging
+- 🎨 **Visual Workflow Builder**: Kailash Workflow Studio - drag-and-drop interface for creating and managing workflows (coming soon)
+- 🔁 **Cyclic Workflows (v0.2.0)**: Universal Hybrid Cyclic Graph Architecture with 30,000+ iterations/second performance
+- 🛠️ **Developer Tools**: CycleAnalyzer, CycleDebugger, CycleProfiler for production-ready cyclic workflows
+- 📈 **High Performance**: Optimized execution engine supporting 100,000+ iteration workflows
 
 ## 🎯 Who Is This For?
 
@@ -276,6 +290,141 @@ results, run_id = runtime.execute(workflow)
 print("RAG Response:", results["llm_agent"]["response"])
 ```
 
+### Cyclic Workflows - Iterative Processing with Convergence
+
+Build workflows that iterate until a condition is met, perfect for optimization, retries, and ML training:
+
+```python
+from kailash.workflow import Workflow
+from kailash.nodes.base_cycle_aware import CycleAwareNode
+from kailash.nodes.base import NodeParameter
+from kailash.runtime.local import LocalRuntime
+from typing import Any, Dict
+
+# Create a custom cycle-aware node for data quality improvement
+class DataQualityImproverNode(CycleAwareNode):
+    def get_parameters(self) -> Dict[str, NodeParameter]:
+        return {
+            "data": NodeParameter(name="data", type=list, required=True),
+            "target_quality": NodeParameter(name="target_quality", type=float, required=False, default=0.95)
+        }
+
+    def run(self, context: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+        """Iteratively improve data quality."""
+        data = kwargs["data"]
+        target_quality = kwargs.get("target_quality", 0.95)
+
+        # Get current iteration and previous state
+        iteration = self.get_iteration(context)
+        prev_state = self.get_previous_state(context)
+
+        # Calculate current quality
+        quality = prev_state.get("quality", 0.5) + 0.1  # Improve by 10% each iteration
+        quality = min(quality, 1.0)
+
+        # Process data (simplified)
+        processed_data = [item for item in data if item is not None]
+
+        # Track quality history
+        quality_history = self.accumulate_values(context, "quality_history", quality, max_history=10)
+
+        # Detect convergence trend
+        trend = self.detect_convergence_trend(context, "quality_history", window_size=5)
+        converged = quality >= target_quality or (trend and trend["slope"] < 0.01)
+
+        # Log progress
+        self.log_cycle_info(context, f"Iteration {iteration}: Quality={quality:.2%}")
+
+        # Save state for next iteration
+        self.set_cycle_state({"quality": quality, "processed_count": len(processed_data)})
+
+        return {
+            "data": processed_data,
+            "quality": quality,
+            "converged": converged,
+            "iteration": iteration,
+            "history": quality_history
+        }
+
+# Build cyclic workflow
+workflow = Workflow("quality_improvement", "Iterative Data Quality")
+workflow.add_node("improver", DataQualityImproverNode())
+
+# Create a cycle - node connects to itself!
+workflow.connect("improver", "improver",
+                 mapping={"data": "data"},  # Pass data to next iteration
+                 cycle=True,  # This is a cycle
+                 max_iterations=20,  # Safety limit
+                 convergence_check="converged == True")  # Stop condition
+
+# Execute with automatic iteration management
+runtime = LocalRuntime()
+results, run_id = runtime.execute(workflow, parameters={
+    "improver": {
+        "data": [1, None, 3, None, 5, 6, None, 8, 9, 10],
+        "target_quality": 0.9
+    }
+})
+
+print(f"Converged after {results['improver']['iteration']} iterations")
+print(f"Final quality: {results['improver']['quality']:.2%}")
+print(f"Quality history: {results['improver']['history']}")
+```
+
+### NEW in v0.2.0: CycleBuilder API
+
+The new CycleBuilder API provides a fluent interface for creating cyclic workflows:
+
+```python
+# Modern approach with CycleBuilder
+workflow.create_cycle("optimization_loop")
+    .connect("gradient", "optimizer")
+    .connect("optimizer", "evaluator")
+    .connect("evaluator", "gradient")
+    .max_iterations(100)
+    .converge_when("loss < 0.01")
+    .early_stop_when("gradient_norm < 1e-6")
+    .checkpoint_every(10)
+    .build()
+
+# Developer tools for production workflows
+from kailash.workflow import CycleAnalyzer, CycleDebugger, CycleProfiler
+
+# Analyze cycle patterns
+analyzer = CycleAnalyzer(workflow)
+report = analyzer.analyze()
+print(f"Found {len(report.cycles)} cycles")
+print(f"Max depth: {report.max_cycle_depth}")
+
+# Debug with breakpoints
+debugger = CycleDebugger(workflow)
+debugger.set_breakpoint("optimizer", iteration=50)
+debugger.set_trace("gradient_norm", lambda x: x < 0.001)
+
+# Profile performance
+profiler = CycleProfiler(workflow)
+profile_data = profiler.profile(runtime, parameters)
+print(f"Bottleneck: {profile_data.bottleneck_node}")
+print(f"Iterations/sec: {profile_data.iterations_per_second}")
+```
+
+#### Cyclic Workflow Features
+
+- **Built-in Iteration Management**: No manual loops or recursion needed
+- **State Persistence**: Maintain state across iterations with `get_previous_state()` and `set_cycle_state()`
+- **Convergence Detection**: Automatic trend analysis with `detect_convergence_trend()`
+- **Value Accumulation**: Track metrics over time with `accumulate_values()`
+- **Safety Limits**: Max iterations prevent infinite loops
+- **Performance**: Optimized execution with ~30,000 iterations/second
+- **Developer Tools**: CycleAnalyzer, CycleDebugger, CycleProfiler for production workflows
+
+Common cyclic patterns include:
+- **Retry with Backoff**: ETL pipelines with automatic retry
+- **Optimization Loops**: Iterative parameter tuning
+- **ML Training**: Training until accuracy threshold
+- **Polling**: API polling with rate limiting
+- **Stream Processing**: Windowed data processing
+
 ### Workflow API Wrapper - Expose Workflows as REST APIs
 
 Transform any Kailash workflow into a production-ready REST API in just 3 lines of code:
@@ -410,6 +559,173 @@ gateway.run(port=8000)
 
 See the [Gateway examples](examples/integration_examples/gateway_comprehensive_demo.py) for complete implementation patterns.
 
+### Self-Organizing Agent Pools - Autonomous Multi-Agent Systems
+
+Build intelligent agent systems that can autonomously form teams, share information, and solve complex problems collaboratively:
+
+```python
+from kailash import Workflow
+from kailash.runtime import LocalRuntime
+from kailash.nodes.ai.intelligent_agent_orchestrator import (
+    OrchestrationManagerNode,
+    IntelligentCacheNode,
+    ConvergenceDetectorNode
+)
+from kailash.nodes.ai.self_organizing import (
+    AgentPoolManagerNode,
+    TeamFormationNode,
+    ProblemAnalyzerNode
+)
+from kailash.nodes.ai.a2a import SharedMemoryPoolNode, A2AAgentNode
+
+# Create self-organizing agent workflow
+workflow = Workflow("self_organizing_research")
+
+# Shared infrastructure
+memory_pool = SharedMemoryPoolNode(
+    memory_size_limit=1000,
+    attention_window=50
+)
+workflow.add_node("memory", memory_pool)
+
+# Intelligent caching to prevent redundant operations
+cache = IntelligentCacheNode(
+    ttl=3600,  # 1 hour cache
+    similarity_threshold=0.8,
+    max_entries=1000
+)
+workflow.add_node("cache", cache)
+
+# Problem analysis and team formation
+problem_analyzer = ProblemAnalyzerNode()
+team_former = TeamFormationNode(
+    formation_strategy="capability_matching",
+    optimization_rounds=3
+)
+workflow.add_node("analyzer", problem_analyzer)
+workflow.add_node("team_former", team_former)
+
+# Self-organizing agent pool
+pool_manager = AgentPoolManagerNode(
+    max_active_agents=20,
+    agent_timeout=120
+)
+workflow.add_node("pool", pool_manager)
+
+# Convergence detection for stopping criteria
+convergence = ConvergenceDetectorNode(
+    quality_threshold=0.85,
+    improvement_threshold=0.02,
+    max_iterations=10
+)
+workflow.add_node("convergence", convergence)
+
+# Orchestration manager coordinates the entire system
+orchestrator = OrchestrationManagerNode(
+    max_iterations=10,
+    quality_threshold=0.85,
+    parallel_execution=True
+)
+workflow.add_node("orchestrator", orchestrator)
+
+# Execute with complex business problem
+runtime = LocalRuntime()
+result, _ = runtime.execute(workflow, parameters={
+    "orchestrator": {
+        "query": "Analyze market trends and develop growth strategy for fintech",
+        "agent_pool_size": 12,
+        "mcp_servers": [
+            {"name": "market_data", "command": "python", "args": ["-m", "market_mcp"]},
+            {"name": "financial", "command": "python", "args": ["-m", "finance_mcp"]},
+            {"name": "research", "command": "python", "args": ["-m", "research_mcp"]}
+        ],
+        "context": {
+            "domain": "fintech",
+            "depth": "comprehensive",
+            "output_format": "strategic_report"
+        }
+    }
+})
+
+print(f"Solution Quality: {result['orchestrator']['quality_score']:.2%}")
+print(f"Agents Used: {result['orchestrator']['agents_deployed']}")
+print(f"Iterations: {result['orchestrator']['iterations_completed']}")
+print(f"Final Strategy: {result['orchestrator']['final_solution']['strategy']}")
+```
+
+#### Key Self-Organizing Features
+
+- **Autonomous Team Formation**: Agents automatically form optimal teams based on:
+  - Capability matching for skill-specific tasks
+  - Swarm-based formation for exploration
+  - Market-based allocation for resource constraints
+  - Hierarchical organization for complex problems
+
+- **Intelligent Information Sharing**:
+  - **SharedMemoryPoolNode**: Selective attention mechanisms for relevant information
+  - **IntelligentCacheNode**: Semantic similarity detection prevents redundant operations
+  - **A2AAgentNode**: Direct agent-to-agent communication with context awareness
+
+- **Convergence Detection**: Automatic termination when:
+  - Solution quality exceeds threshold (e.g., 85% confidence)
+  - Improvement rate drops below minimum (e.g., <2% per iteration)
+  - Maximum iterations reached
+  - Time limits exceeded
+
+- **MCP Integration**: Agents can access external tools and data sources:
+  - File systems, databases, APIs
+  - Web scraping and research tools
+  - Specialized domain knowledge bases
+  - Real-time data streams
+
+- **Performance Optimization**:
+  - Multi-level caching strategies
+  - Parallel agent execution
+  - Resource management and monitoring
+  - Cost tracking for API usage
+
+See the [Self-Organizing Agents examples](examples/integration_examples/) for complete implementation patterns and the [Agent Systems Guide](docs/guides/self_organizing_agents.rst) for detailed documentation.
+
+### Zero-Code MCP Ecosystem - Visual Workflow Builder
+
+Build and deploy workflows through an interactive web interface without writing any code:
+
+```python
+from kailash.api.gateway import WorkflowAPIGateway
+from kailash.api.mcp_integration import MCPServerRegistry
+
+# Run the MCP ecosystem demo
+# cd examples/integration_examples
+# ./run_ecosystem.sh
+
+# Or run programmatically:
+python examples/integration_examples/mcp_ecosystem_demo.py
+```
+
+#### Features
+
+- **Drag-and-Drop Builder**: Visual interface for creating workflows
+  - Drag nodes from palette (CSV Reader, Python Code, JSON Writer, etc.)
+  - Drop onto canvas to build workflows
+  - Deploy with one click
+
+- **Live Dashboard**: Real-time monitoring and statistics
+  - Connected MCP server status
+  - Running workflow count
+  - Execution logs with timestamps
+
+- **Pre-built Templates**: One-click deployment
+  - GitHub → Slack Notifier
+  - Data Processing Pipeline (CSV → Transform → JSON)
+  - AI Research Assistant
+
+- **Technology Stack**: Lightweight and fast
+  - Backend: FastAPI + Kailash SDK
+  - Frontend: Vanilla HTML/CSS/JavaScript (no frameworks)
+  - Zero build process required
+
+See the [MCP Ecosystem example](examples/integration_examples/) for the complete zero-code workflow deployment platform.
+
 ## 📚 Documentation
 
 | Resource | Description |
@@ -471,6 +787,21 @@ The SDK includes a rich set of pre-built nodes for common operations:
 - `SentimentAnalyzer` - Sentiment analysis
 - `NamedEntityRecognizer` - NER extraction
 
+**Self-Organizing Agent Nodes**
+- `SharedMemoryPoolNode` - Agent memory sharing
+- `A2AAgentNode` - Agent-to-agent communication
+- `A2ACoordinatorNode` - Multi-agent coordination
+- `IntelligentCacheNode` - Semantic caching system
+- `MCPAgentNode` - MCP-enabled agents
+- `QueryAnalysisNode` - Query complexity analysis
+- `OrchestrationManagerNode` - System orchestration
+- `ConvergenceDetectorNode` - Solution convergence
+- `AgentPoolManagerNode` - Agent pool management
+- `ProblemAnalyzerNode` - Problem decomposition
+- `TeamFormationNode` - Optimal team creation
+- `SolutionEvaluatorNode` - Multi-criteria evaluation
+- `SelfOrganizingAgentNode` - Adaptive individual agents
+
 </td>
 <td width="50%">
 
@@ -918,6 +1249,95 @@ This example demonstrates:
 - **Context formatting** for LLM input
 - **Answer generation** using Ollama's llama3.2 model
 
+### 🔒 Access Control and Security
+
+Kailash SDK provides comprehensive access control and security features for enterprise deployments:
+
+#### Role-Based Access Control (RBAC)
+```python
+from kailash.access_control import UserContext, PermissionRule, NodePermission
+from kailash.runtime.access_controlled import AccessControlledRuntime
+
+# Define user with roles
+user = UserContext(
+    user_id="analyst_001",
+    tenant_id="company_abc",
+    email="analyst@company.com",
+    roles=["analyst", "viewer"]
+)
+
+# Create secure runtime
+runtime = AccessControlledRuntime(user_context=user)
+
+# Execute workflow with automatic permission checks
+results, run_id = runtime.execute(workflow, parameters={})
+```
+
+#### Multi-Tenant Isolation
+```python
+from kailash.access_control import get_access_control_manager, PermissionEffect, WorkflowPermission
+
+# Configure tenant-based access rules
+acm = get_access_control_manager()
+acm.enabled = True
+
+# Tenant isolation rule
+acm.add_rule(PermissionRule(
+    id="tenant_isolation",
+    resource_type="workflow",
+    resource_id="customer_analytics",
+    permission=WorkflowPermission.EXECUTE,
+    effect=PermissionEffect.ALLOW,
+    tenant_id="company_abc"  # Only this tenant can access
+))
+```
+
+#### Data Masking and Field Protection
+```python
+from kailash.nodes.base_with_acl import add_access_control
+
+# Add access control to sensitive data nodes
+secure_reader = add_access_control(
+    CSVReaderNode(file_path="customers.csv"),
+    enable_access_control=True,
+    required_permission=NodePermission.READ_OUTPUT,
+    mask_output_fields=["ssn", "phone"]  # Mask for non-admin users
+)
+
+workflow.add_node("secure_data", secure_reader)
+```
+
+#### Permission-Based Routing
+```python
+# Different execution paths based on user permissions
+from kailash.access_control import NodePermission
+
+# Admin users get full processing
+admin_processor = PythonCodeNode.from_function(
+    lambda data: {"result": process_all_data(data)},
+    name="admin_processor"
+)
+
+# Analyst users get limited processing
+analyst_processor = PythonCodeNode.from_function(
+    lambda data: {"result": process_limited_data(data)},
+    name="analyst_processor"
+)
+
+# Runtime automatically routes based on user permissions
+workflow.add_node("admin_path", admin_processor)
+workflow.add_node("analyst_path", analyst_processor)
+```
+
+**Security Features:**
+- 🔐 **JWT Authentication**: Token-based authentication with refresh support
+- 👥 **Multi-Tenant Isolation**: Complete data separation between tenants
+- 🛡️ **Field-Level Security**: Mask sensitive data based on user roles
+- 📊 **Audit Logging**: Complete access attempt logging for compliance
+- 🚫 **Path Traversal Prevention**: Built-in protection against directory attacks
+- 🏗️ **Backward Compatibility**: Existing workflows work unchanged
+- ⚡ **Performance Optimized**: Minimal overhead with caching
+
 ## 💻 CLI Commands
 
 The SDK includes a comprehensive CLI for workflow management:
@@ -1104,7 +1524,7 @@ pre-commit run pytest-check
 <td width="40%">
 
 ### ✅ Completed
-- Core node system with 15+ node types
+- Core node system with 66+ node types
 - Workflow builder with DAG validation
 - Local & async execution engines
 - Task tracking with metrics
@@ -1114,21 +1534,33 @@ pre-commit run pytest-check
 - Immutable state management
 - API integration with rate limiting
 - OAuth 2.0 authentication
+- Production security framework
+- Path traversal prevention
+- Code execution sandboxing
+- Comprehensive security testing
 - SharePoint Graph API integration
+- **Self-organizing agent pools with 13 specialized nodes**
+- **Agent-to-agent communication and shared memory**
+- **Intelligent caching and convergence detection**
+- **MCP integration for external tool access**
+- **Multi-strategy team formation algorithms**
 - **Real-time performance metrics collection**
 - **Performance visualization dashboards**
 - **Real-time monitoring dashboard with WebSocket streaming**
 - **Comprehensive performance reports (HTML, Markdown, JSON)**
-- **89% test coverage (571 tests)**
-- **15 test categories all passing**
-- 37 working examples
+- **100% test coverage (591 tests)**
+- **All test categories passing**
+- 68 working examples
 
 </td>
 <td width="30%">
 
 ### 🚧 In Progress
-- Comprehensive API documentation
-- Security audit & hardening
+- **Kailash Workflow Studio** - Visual workflow builder UI
+  - React-based drag-and-drop interface
+  - Multi-tenant architecture with Docker
+  - WorkflowStudioAPI backend
+  - Real-time execution monitoring
 - Performance optimizations
 - Docker runtime finalization
 
@@ -1146,11 +1578,12 @@ pre-commit run pytest-check
 </table>
 
 ### 🎯 Test Suite Status
-- **Total Tests**: 571 passing (89%)
-- **Test Categories**: 15/15 at 100%
-- **Integration Tests**: 65 passing
-- **Examples**: 37/37 working
-- **Code Coverage**: 89%
+- **Total Tests**: 591 passing (100%)
+- **Test Categories**: All passing
+- **Integration Tests**: All passing
+- **Security Tests**: 10 consolidated comprehensive tests
+- **Examples**: 68/68 working
+- **Code Coverage**: 100%
 
 ## ⚠️ Known Issues
 

kailash-0.2.0.dist-info/RECORD

@@ -0,0 +1,125 @@
+kailash/__init__.py,sha256=18nnQJjpf6wotVZ4nNepy5fR8UVttlbAktoQxTepsgk,902
+kailash/__main__.py,sha256=vr7TVE5o16V6LsTmRFKG6RDKUXHpIWYdZ6Dok2HkHnI,198
+kailash/access_control.py,sha256=zLJ6vrBQj9VDO4SP9Mfci9OOu8II5tYq4ERSmWhycg8,25600
+kailash/manifest.py,sha256=8H4ObT3qvdV0FQDXYUF49ppbmOvnK1PmmpdC6h5npn8,24892
+kailash/sdk_exceptions.py,sha256=_l0_xPjkXeFy_4jDW46gjHw_Rj_TndZ9X7NtnU9a298,10469
+kailash/security.py,sha256=jKBMtVLZ4xjbR7vh8aVW4Fcnp-NGflWIakML9zSL_zE,26585
+kailash/api/__init__.py,sha256=9Ofp4qTZCry_hovrtSjPjqyZbrccoPqyz9za_TfSHVg,445
+kailash/api/__main__.py,sha256=79v7N6eCFQ2Otcv66wAv2iM2hD6mwJ__pNiR9yy_qd4,120
+kailash/api/auth.py,sha256=UTGnslYwQxRsz0-kzLiu_pn0QjUrjwDU1EFVCHv15DI,20167
+kailash/api/custom_nodes.py,sha256=e4xqdm4i8bGMGyt3H3Tv7cXSALdgFFyqRL031IDmI9M,10690
+kailash/api/custom_nodes_secure.py,sha256=GAyH2WTvUnvTfdSa6IWKz5d1DW_gbaSQAWTFYiu4k2M,13258
+kailash/api/database.py,sha256=tBslJjpM6cHdicnQGnGXUuc-V6Qkm6UrEfpFP8WwtsU,19477
+kailash/api/gateway.py,sha256=rp0Doz7HaEgLFXRqZvzMk6EfK-M6HmMHcSAJSv28FL8,12576
+kailash/api/mcp_integration.py,sha256=Pvm65Nb1g4-QGKqweeRE-hMJe0HvqhljHB-UTtItnVc,14541
+kailash/api/studio.py,sha256=HNauboOnWTHNcxyulgng4E8MRiZJGqd80u5d8SxPtXU,35056
+kailash/api/studio_secure.py,sha256=sUqvsaTF7P-d2riviuvfFc_sujhjAnnhGcdhqi0H8Ls,32191
+kailash/api/workflow_api.py,sha256=8e4YSeeTQQT_9GJ_5-kWQFhL8v5-qqVWFv3ToREzBXE,13177
+kailash/cli/__init__.py,sha256=kJaqsBp3fRmagJhqA6LMwMbEa_Vkz93hIPH3W5Mn5r0,97
+kailash/cli/commands.py,sha256=K5slsaoYSw7ZpVgePvobN6K4w9_dXJugBTIY0aifKik,18236
+kailash/mcp/__init__.py,sha256=ZEhYIsPcy3sgywvdcr4w2FBjtqorOGXxHCngxK4sy9k,1804
+kailash/mcp/__main__.py,sha256=ohgrksZZ8Z5IDZToH12IUVtW3dl5NtQ63UmprNzGFZ0,215
+kailash/mcp/ai_registry_server.py,sha256=mOVNyQdtiWIalWzXFILl6rt0TfnbJ4RD5ZiADjT3kdk,28155
+kailash/mcp/client.py,sha256=X914ddaAY7NdOxIin-5lLQKDZOLT86u12q0fxXgzGFk,16121
+kailash/mcp/client_new.py,sha256=I9a68gSMWaBv7WRgvDRvHAfm7fdMO_0sbJL0eM9b3gw,10322
+kailash/mcp/server.py,sha256=ESwOulBkEjHJp22lzmCQt33YCz2CQmMFZzhPL0AV4ac,8250
+kailash/mcp/server_new.py,sha256=97Tugk_mMheDIrQ43o_EDui9yYNYBpMONbLd7bYoYiI,10946
+kailash/mcp/servers/__init__.py,sha256=Ajho8j0chg36_DlMsyP6DLsvODgGesOvO0f95BgLxro,325
+kailash/mcp/servers/ai_registry.py,sha256=NLqhsOTD6L8HFOprY6IwaYD-kkgdZD3eg_sIuUPiAhY,10003
+kailash/nodes/__init__.py,sha256=MO2N1k-lq68CuQvsWiYV2GQG0T15X41E1aRkLFL46kU,650
+kailash/nodes/base.py,sha256=k8sKGsMriENzjg0cUtBZ2rUNuD6cvMNZX-DUfdZXxNg,38189
+kailash/nodes/base_async.py,sha256=t9Hf3F30q6CMDfgd2BFkXYIJMEGdEir8xdWCl9euqAs,6622
+kailash/nodes/base_cycle_aware.py,sha256=NJh-8zOfdgBzAK_3faMl9i2aqCp3f4RG1aQ-IJbSSxo,13293
+kailash/nodes/base_with_acl.py,sha256=aeIhLX3B17twYe_B-tba6e47bj7tZ9CstnlCana0aps,11868
+kailash/nodes/mixins.py,sha256=wIG0No-nUSnk6EBnrW4vQt6m_nDVQHhcR2UOHbIyWRE,12116
+kailash/nodes/ai/__init__.py,sha256=rslxIS8jlovshiNgWqVzQjD_kfT_3h3Ct03sk-iRe6U,2202
+kailash/nodes/ai/a2a.py,sha256=U1nDjWkSxlN98b1EwRN-74HtuONHdOoVc-jYEnpQA80,69303
+kailash/nodes/ai/agents.py,sha256=yygZw8eJPt7iuRm4jZR-I2wtfIVrIH8OxoorgZ2HNrw,20379
+kailash/nodes/ai/ai_providers.py,sha256=rtFOvsyUlcoD0voeiCHyBR7ELcRMfJa5T2T7wFyB5js,53026
+kailash/nodes/ai/embedding_generator.py,sha256=UZagRpoybTlV_LMCt0HMUuc1TYFh5yLfs38mqdLItEI,31846
+kailash/nodes/ai/intelligent_agent_orchestrator.py,sha256=8rlP-xOmqE5Y6imRqrXYvLyMq11uF6uKVG4S7seH8HE,80329
+kailash/nodes/ai/iterative_llm_agent.py,sha256=pUPIPt5TcvfCmw9Tw8fp3gQ6AfrLNAEIH4eRmA_CGOE,52912
+kailash/nodes/ai/llm_agent.py,sha256=huU3GwJVOukn0qyJc6T7Nh2v-y-JvJsK-53bCUAZAg0,60780
+kailash/nodes/ai/models.py,sha256=t90NvEIEJJxdBXwW0DhKACQG1Um-sJPm-lBdPBt8-ZA,16399
+kailash/nodes/ai/self_organizing.py,sha256=NCUoq8y3aYZOJNToZhwgl0ExsE9vQaWN0CWAAWR4U7E,60584
+kailash/nodes/api/__init__.py,sha256=1yFcWVYyc-bsilknBT5aAGV7jcp-Ysu_afRilNJlD0A,1529
+kailash/nodes/api/auth.py,sha256=cpHUIZ6-YFo3jkW0K4-eBP38EZCl7Lrfibg5XTZaPWo,19427
+kailash/nodes/api/graphql.py,sha256=PH1ccwbw-fsBfKHl8L_whkZSRMgGAPKM7kkLTmwci5s,16994
+kailash/nodes/api/http.py,sha256=XTkHmmVnGyvIqpNhmjUsRNuk-qYzvWdyF89cg5zHxI8,38396
+kailash/nodes/api/rate_limiting.py,sha256=f-cY_ee5juWHyKT3FqtaTk-SjEgMWX2DxU10Y41DZG4,19728
+kailash/nodes/api/rest.py,sha256=yRLcNuIGVq5Nc1z759tc3Nqt3c2d7UnMqE7lZ8tVKMM,43357
+kailash/nodes/code/__init__.py,sha256=L3QBfnITPb6v-Wbq2ezNWt8xDlC4uGaTgrkqIJ9vGKU,1191
+kailash/nodes/code/python.py,sha256=hUOdS2_dWEcLWkH5m_VeFgJ8tajY0FjJLmDQfHYbbRs,38775
+kailash/nodes/data/__init__.py,sha256=dIPx7Dfk3ZQ_SZvU4qYhAtYMTDCj4DeeXOSqMMW92mI,4107
+kailash/nodes/data/readers.py,sha256=zVAXHAX8yZp5fomlnjc8eXODjjiO8oaxeRWrg7uRk6s,19375
+kailash/nodes/data/retrieval.py,sha256=ANQXk0h5QI_NX_VdgABJEHbKWI3wtiRXCNgoap27M04,7516
+kailash/nodes/data/sharepoint_graph.py,sha256=UIyy8Q-9bGTzj-hjcxne8DkBJvr6Eig1HgY1JqGZqss,22437
+kailash/nodes/data/sources.py,sha256=MaXFPSDg4VN7TN5iNMZxwhxgj6nNpH43tQYmkxhHxjE,3638
+kailash/nodes/data/sql.py,sha256=agu-ZCdHAJKsJI1GCnNrGv7a5WhudpPGYz650vuCUE0,12860
+kailash/nodes/data/streaming.py,sha256=OAME3quVU9NbQFMBM6X-Yiri8Q5WGlEi91U4oGs78Fw,35223
+kailash/nodes/data/vector_db.py,sha256=rywRU65g7ou9v1QPSZmC5esnqC-O0DezGOJS37wKdJs,30556
+kailash/nodes/data/writers.py,sha256=07gDN44i3k0nRv1qRVJYMWmvhyJxcQ4OiDPZ9dzfDIc,17543
+kailash/nodes/logic/__init__.py,sha256=JKGFXwBDfY3s1MWQkx3ivdvCMm3b3HIXCn-wH9uMoG4,603
+kailash/nodes/logic/async_operations.py,sha256=WLV05FG3u02tuHNFbce-aYhiTL0s45fOrGQcvog3mLU,27512
+kailash/nodes/logic/convergence.py,sha256=TrL8nUCqdUp4UxJwjuI-6BdStLcZbb_nP0xgYBhZnmI,24207
+kailash/nodes/logic/loop.py,sha256=lPlLmwz6iMtY89xNvwx7Icvx75sHE6DzurkNPu0G2Zg,5775
+kailash/nodes/logic/operations.py,sha256=zz2Hn4eUM52EkmqTTjb2ujSs1YfG5dSyPga39rZ-dEs,28179
+kailash/nodes/logic/workflow.py,sha256=xo5IS_dB3bz4ApaCOa0LZXkCoornCcBspQs2laA-eBQ,17178
+kailash/nodes/mixins/__init__.py,sha256=AUYcxnBTLZCc_RHFsfcwLYa88yW3pyQHJqfMdcZV-pE,263
+kailash/nodes/mixins/mcp.py,sha256=kE3qhqHlyfUquPyk13u73zfj9oYWuhfrsjWo6q1xbIM,6892
+kailash/nodes/transform/__init__.py,sha256=sIUk7XMEl3x_XKNiRIyVtHmbLRUa0jHj1fEuUyELT_s,584
+kailash/nodes/transform/chunkers.py,sha256=qh2wYq6bdo5qGoDRLrowDrpl4VinRO4hDOj05DOr3RY,2580
+kailash/nodes/transform/formatters.py,sha256=02T87cQ4nVJoUKV9spEBzKa1YxtbV_KurngbhnfkVao,3078
+kailash/nodes/transform/processors.py,sha256=BZjDigpHD5pFxyZ0sty7-jpdEmD11euQip9N3U4Uzlw,18490
+kailash/runtime/__init__.py,sha256=CvU-qBMESYYISqFOlYlLsYJrXJu0Gqr4x6yr4Ob_Rng,278
+kailash/runtime/access_controlled.py,sha256=hEpLv9hwaaJoD03YTkUnr4rWEatFvgRrhu4sa1RTUU4,17274
+kailash/runtime/async_local.py,sha256=h8NrwgXOEX-pgozPS1_TPLCrWeSorf0AqridKX1yI2w,12264
+kailash/runtime/docker.py,sha256=U0nU4fGTLA59H25mBDFC6EkTXry-5bwXkWUgRw1qBqc,23559
+kailash/runtime/local.py,sha256=HCMOkezJ9L3sTWO1x4dAnLMGroaFWwm42MvU-9PCPZs,19001
+kailash/runtime/parallel.py,sha256=VPVSBglVqdnMyyHMgThDedbghK47f6-2Jx7434BAlz4,21129
+kailash/runtime/parallel_cyclic.py,sha256=vAlg_XvdMrrBuDbdhXhI88FCPYgIJ_t--zjKi1kJB1A,19942
+kailash/runtime/runner.py,sha256=wzTiC8hHoy3dca5NRImaw2qfjH1bkUJR2UaFwCkTV6Y,3246
+kailash/runtime/testing.py,sha256=UJdLD7Eh45sa3oIWy6Pe0LA6yf9NcY_9r8YXWUwSuEQ,11578
+kailash/tracking/__init__.py,sha256=nhyecV24JuB_D-veJ3qw7h4oO8Sbdmyb6RvPS6VQktU,305
+kailash/tracking/manager.py,sha256=C7DEMLJN6oQwKnISHqwRbDuGdYs0_j0ATEE3FJjF8eA,28135
+kailash/tracking/metrics_collector.py,sha256=8CvNK3lUIN7BfGy0Re-2WrNKM3J0vx8vjfd-uyvaJJs,11820
+kailash/tracking/models.py,sha256=iMbD60YYkGUik6-cDd_jxG6uiIttS7iR1ALYRug_FDY,18113
+kailash/tracking/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kailash/tracking/storage/base.py,sha256=bw4WWoG40G8zJCS0zVQ18-BiBYbt3fnZPx64xq0BY0c,2468
+kailash/tracking/storage/database.py,sha256=3pHaohN_tuP3bfV2gCD8vOdqJSZhuKlGRjigWVme0FQ,20022
+kailash/tracking/storage/filesystem.py,sha256=7Cmpd1CEWhtQu7Buf71d2Nda0r1btJEa7FuilctDP5w,19891
+kailash/utils/__init__.py,sha256=pFKhHJxU_kyFE9aGT5recw5E-3nbfVF5pMHepBJWB2E,253
+kailash/utils/export.py,sha256=LIahj_qIM0vaC5rFnV_iVGaL92jRp1WkYmi8pEgf6yE,31964
+kailash/utils/templates.py,sha256=WBZMd8-HoGB47nhJTSwxEkJi9etfNppOTiwtlZe2DFI,22049
+kailash/visualization/__init__.py,sha256=6bvgE_Rt8z3Rf4kSvdWvZNaTYvbofRHc_QbGlC0xDYE,1880
+kailash/visualization/api.py,sha256=jKjfxuufSsXZEsEWIu6_FF7XHQsjjO2d5MJfO0F8S20,28890
+kailash/visualization/dashboard.py,sha256=euAyqTu5QWwcUOhLBcdYrKnJdFVX_pQThlNLp-yYbaA,32874
+kailash/visualization/performance.py,sha256=qW4sI8ios8__j5-qXUhN7Pa3mE-9E3JTEBkFkt7fSY8,28053
+kailash/visualization/reports.py,sha256=FKERee_SUm12P3QEBwm4Up_WZYcgXPJfx_0ZAzcUNug,52671
+kailash/workflow/__init__.py,sha256=x-yL8h6tsXq5gZj_fVYKJhyYJOEMFbaVXTNIomE-CDo,1011
+kailash/workflow/builder.py,sha256=zoNQT2LUym1ykkoVz5RK4O2aqsmZWGNXHkAnCi8xyUg,7683
+kailash/workflow/convergence.py,sha256=OFoQvnVfFjjhIjncz_16uG8koKVLQC7QhfLP4G7mmH8,10039
+kailash/workflow/cycle_analyzer.py,sha256=iarNvUysLWWOZuLt01Pnk6lkKgVjAtUPUMeYDe_rafs,31616
+kailash/workflow/cycle_builder.py,sha256=4w5X0417d5xP-LxAYNGNY50dn12N5S5nsLdivT0XbsM,21190
+kailash/workflow/cycle_config.py,sha256=QOG-JHfD7PfVrSCH1ahAfC0Qj2cIgDcSCR53TGcY4dw,28188
+kailash/workflow/cycle_debugger.py,sha256=Zu0lkvrfzP8vQZkD6Q5UJqwwkaBLN-G37yIrxuz0PBs,31024
+kailash/workflow/cycle_exceptions.py,sha256=LBHqRvMqEBvAOdU1bKiGXXxCBxJiNmHuCGYTl7k9udg,21744
+kailash/workflow/cycle_profiler.py,sha256=gWH02JIZSFydqMHT_ijZbo3bo2SMEk7G9hHJTbjIHOw,28204
+kailash/workflow/cycle_state.py,sha256=M7f60R8idkHpgNhziutiZV3TPV-cSCz5K_VChHfkj1o,10834
+kailash/workflow/cyclic_runner.py,sha256=VUPU-OMiZB_hBGBtfFwvMAVgzAONNt62C5HuUeNXO4w,37222
+kailash/workflow/graph.py,sha256=D0FyHlHAg1YVpiJrE-6yl5Tkj1uqk1SgT5ygObuSMLQ,51514
+kailash/workflow/mermaid_visualizer.py,sha256=PU_uVeYqR1m59z-qhbQOJHztf0um3FYw9jpF3j22QYA,22351
+kailash/workflow/migration.py,sha256=WGSR6MVxo1NBF9reKRiDQR17ChyokjcSzC-Tp8jz97Y,31725
+kailash/workflow/mock_registry.py,sha256=oweiPQ-mBuDdzTUbo3qZAW6OaBKNqST_1vX32xMtcL4,1704
+kailash/workflow/runner.py,sha256=QATm4y7botMoOFltcHe8CreeUlobJX0M5nLHQ9usRgo,10839
+kailash/workflow/safety.py,sha256=pWXpl1ED76HejNoTn-M5fY4hVB-_-WBWP2_2uo4WGd0,11364
+kailash/workflow/state.py,sha256=3vZkptVfPYqN-Q9aFwO2sUpmy-l1h5vIMVwh67uTwE4,7722
+kailash/workflow/templates.py,sha256=A8sHsFT6zsj20cAK8pnf8IthXMAVzydAm8QnU4HBRfI,24750
+kailash/workflow/validation.py,sha256=50tt7LCNvU3zqWYGFeumtqv6qwR5PftKt45-cBm8QPE,32024
+kailash/workflow/visualization.py,sha256=gSMT-jaSzQBufV4mDArWVPJj5bpNIxTa_NE796Rm8I8,19536
+kailash-0.2.0.dist-info/licenses/LICENSE,sha256=Axe6g7bTrJkToK9h9j2SpRUKKNaDZDCo2lQ2zPxCE6s,1065
+kailash-0.2.0.dist-info/METADATA,sha256=SMk5X-J_SYfKnlDizdsIVIVsyTafI_pDNy6z5XmIcTo,53406
+kailash-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kailash-0.2.0.dist-info/entry_points.txt,sha256=M_q3b8PG5W4XbhSgESzIJjh3_4OBKtZFYFsOdkr2vO4,45
+kailash-0.2.0.dist-info/top_level.txt,sha256=z7GzH2mxl66498pVf5HKwo5wwfPtt9Aq95uZUpH6JV0,8
+kailash-0.2.0.dist-info/RECORD,,

kailash/nodes/mcp/__init__.py

@@ -1,11 +0,0 @@
-"""Model Context Protocol (MCP) nodes for the Kailash SDK."""
-
-from .client import MCPClient
-from .resource import MCPResource
-from .server import MCPServer
-
-__all__ = [
-    "MCPClient",
-    "MCPServer",
-    "MCPResource",
-]