jarviscore-framework 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

examples/autoagent_distributed_example.py

@@ -0,0 +1,211 @@
+"""
+AutoAgent Distributed Mode Example
+
+Demonstrates AutoAgent in distributed mode, which combines:
+- P2P network layer (SWIM protocol, ZMQ messaging)
+- Workflow orchestration (step execution, dependencies)
+
+This is ideal for multi-node deployments where agents can:
+- Execute on different machines
+- Discover each other via SWIM
+- Run orchestrated workflows across the network
+
+Usage:
+    python examples/autoagent_distributed_example.py
+
+Prerequisites:
+    - .env file with LLM API key (CLAUDE_API_KEY, etc.)
+"""
+import asyncio
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from jarviscore import Mesh
+from jarviscore.profiles import AutoAgent
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# AUTOAGENT DEFINITIONS
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class DataCollectorAgent(AutoAgent):
+    """Collects and generates data."""
+    role = "collector"
+    capabilities = ["data_collection", "sampling"]
+    system_prompt = """
+    You are a data collection specialist. Generate sample datasets
+    based on specifications. Use Python's standard library only.
+    Store results in a variable named 'result' as a dictionary.
+    """
+
+
+class DataProcessorAgent(AutoAgent):
+    """Processes and transforms data."""
+    role = "processor"
+    capabilities = ["data_processing", "transformation"]
+    system_prompt = """
+    You are a data processing expert. Transform and clean datasets.
+    Apply filters, aggregations, and transformations as needed.
+    Use Python's standard library only. Store results in 'result'.
+    """
+
+
+class ReportWriterAgent(AutoAgent):
+    """Generates reports from processed data."""
+    role = "reporter"
+    capabilities = ["reporting", "documentation"]
+    system_prompt = """
+    You are a technical writer. Create clear, well-formatted reports
+    from data. Use markdown formatting. Store the report in 'result'.
+    """
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# MAIN EXAMPLE
+# ═══════════════════════════════════════════════════════════════════════════════
+
+async def main():
+    """Run AutoAgent distributed mode example."""
+    print("\n" + "="*70)
+    print("JarvisCore: AutoAgent in Distributed Mode")
+    print("="*70)
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # KEY DIFFERENCE: mode="distributed" with P2P configuration
+    # ─────────────────────────────────────────────────────────────────────────
+    mesh = Mesh(
+        mode="distributed",  # Enables P2P + Workflow Engine
+        config={
+            # P2P Network Configuration
+            'bind_host': '127.0.0.1',    # Interface to bind to
+            'bind_port': 7950,            # SWIM protocol port (ZMQ uses +1000)
+            'node_name': 'autoagent-node',
+
+            # For multi-node: uncomment to join existing cluster
+            # 'seed_nodes': '192.168.1.10:7950,192.168.1.11:7950',
+
+            # AutoAgent Configuration
+            'execution_timeout': 60,      # Max seconds per task
+            'max_repair_attempts': 2,     # Auto-repair on failure
+            'log_directory': './logs',    # Result storage
+        }
+    )
+
+    # Add agents - same as autonomous mode
+    mesh.add(DataCollectorAgent)
+    mesh.add(DataProcessorAgent)
+    mesh.add(ReportWriterAgent)
+
+    try:
+        await mesh.start()
+
+        print("\n[INFO] Mesh started in DISTRIBUTED mode")
+        print(f"  - P2P Coordinator: Active (port {mesh.config.get('bind_port', 7950)})")
+        print(f"  - Workflow Engine: Active")
+        print(f"  - Agents: {len(mesh.agents)}")
+
+        # ─────────────────────────────────────────────────────────────────────
+        # WORKFLOW EXECUTION - Same API as autonomous mode
+        # ─────────────────────────────────────────────────────────────────────
+        print("\n" + "-"*70)
+        print("Executing Pipeline: Collect → Process → Report")
+        print("-"*70)
+
+        results = await mesh.workflow("distributed-pipeline", [
+            {
+                "id": "collect",
+                "agent": "collector",
+                "task": "Generate a dataset of 10 products with name, price, and category"
+            },
+            {
+                "id": "process",
+                "agent": "processor",
+                "task": "Calculate total value, average price, and count by category",
+                "depends_on": ["collect"]
+            },
+            {
+                "id": "report",
+                "agent": "reporter",
+                "task": "Create a summary report with the statistics",
+                "depends_on": ["process"]
+            }
+        ])
+
+        # Display results
+        print("\n" + "="*70)
+        print("RESULTS")
+        print("="*70)
+
+        for i, result in enumerate(results):
+            step_names = ["Data Collection", "Data Processing", "Report Generation"]
+            print(f"\n{step_names[i]}:")
+            print(f"  Status: {result['status']}")
+            if result['status'] == 'success':
+                output = str(result.get('output', ''))[:200]
+                print(f"  Output: {output}...")
+            else:
+                print(f"  Error: {result.get('error')}")
+
+        # Summary
+        successes = sum(1 for r in results if r['status'] == 'success')
+        print(f"\n{'='*70}")
+        print(f"Pipeline Complete: {successes}/{len(results)} steps successful")
+        print(f"{'='*70}")
+
+        await mesh.stop()
+
+    except Exception as e:
+        print(f"\nError: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# MULTI-NODE EXAMPLE (Reference)
+# ═══════════════════════════════════════════════════════════════════════════════
+
+async def multi_node_example():
+    """
+    Example: Running agents across multiple machines.
+
+    Node 1 (seed node):
+        mesh = Mesh(mode="distributed", config={
+            'bind_host': '0.0.0.0',
+            'bind_port': 7950,
+            'node_name': 'node-1',
+        })
+        mesh.add(DataCollectorAgent)
+        await mesh.start()
+        await mesh.serve_forever()  # Keep running
+
+    Node 2 (joins cluster):
+        mesh = Mesh(mode="distributed", config={
+            'bind_host': '0.0.0.0',
+            'bind_port': 7950,
+            'node_name': 'node-2',
+            'seed_nodes': '192.168.1.10:7950',  # Node 1's address
+        })
+        mesh.add(DataProcessorAgent)
+        await mesh.start()
+        await mesh.serve_forever()
+
+    Node 3 (joins cluster):
+        mesh = Mesh(mode="distributed", config={
+            'bind_host': '0.0.0.0',
+            'bind_port': 7950,
+            'node_name': 'node-3',
+            'seed_nodes': '192.168.1.10:7950',
+        })
+        mesh.add(ReportWriterAgent)
+        await mesh.start()
+        await mesh.serve_forever()
+
+    Any node can now execute workflows that span all three!
+    """
+    pass
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/custom_profile_decorator.py

@@ -0,0 +1,134 @@
+"""
+Custom Profile Example: Using @jarvis_agent Decorator
+
+This example shows how to use the @jarvis_agent decorator to convert
+any Python class into a JarvisCore agent without modifying the class.
+
+Use Case: You have existing Python classes/agents and want JarvisCore
+to handle orchestration (data handoff, dependencies, shared memory).
+"""
+import asyncio
+from jarviscore import Mesh, jarvis_agent, JarvisContext
+
+
+# Example 1: Simple decorator (no context needed)
+@jarvis_agent(role="processor", capabilities=["data_processing"])
+class DataProcessor:
+    """Simple data processor - doubles input values."""
+
+    def run(self, data):
+        """Process data by doubling values."""
+        if isinstance(data, list):
+            return {"processed": [x * 2 for x in data]}
+        return {"processed": data * 2}
+
+
+# Example 2: Decorator with context access
+@jarvis_agent(role="aggregator", capabilities=["aggregation"])
+class Aggregator:
+    """Aggregates results from previous steps using JarvisContext."""
+
+    def run(self, task, ctx: JarvisContext):
+        """
+        Access previous step results via ctx.previous().
+
+        Args:
+            task: The task description
+            ctx: JarvisContext with memory and dependency access
+        """
+        # Get output from a specific previous step
+        processed = ctx.previous("step1")
+
+        if processed:
+            data = processed.get("processed", [])
+            return {
+                "sum": sum(data) if isinstance(data, list) else data,
+                "count": len(data) if isinstance(data, list) else 1,
+                "source_step": "step1"
+            }
+
+        return {"error": "No previous data found"}
+
+
+# Example 3: Decorator with custom execute method
+@jarvis_agent(role="validator", capabilities=["validation"], execute_method="validate")
+class DataValidator:
+    """Validates data using a custom method name."""
+
+    def validate(self, data):
+        """Custom execute method - validates input data."""
+        if isinstance(data, list):
+            return {
+                "valid": all(isinstance(x, (int, float)) for x in data),
+                "count": len(data),
+                "type": "list"
+            }
+        return {
+            "valid": isinstance(data, (int, float)),
+            "type": type(data).__name__
+        }
+
+
+async def main():
+    """Run a multi-step workflow with custom profile agents."""
+    print("=" * 60)
+    print("  Custom Profile Example: @jarvis_agent Decorator")
+    print("=" * 60)
+
+    # Create mesh in autonomous mode
+    mesh = Mesh(mode="autonomous")
+
+    # Add our decorated agents
+    mesh.add(DataProcessor)
+    mesh.add(Aggregator)
+    mesh.add(DataValidator)
+
+    # Start the mesh
+    await mesh.start()
+
+    try:
+        # Execute a multi-step workflow
+        print("\nExecuting workflow with 3 steps...\n")
+
+        results = await mesh.workflow("custom-profile-demo", [
+            {
+                "id": "step1",
+                "agent": "processor",
+                "task": "Process input data",
+                "params": {"data": [1, 2, 3, 4, 5]}
+            },
+            {
+                "id": "step2",
+                "agent": "aggregator",
+                "task": "Aggregate processed results",
+                "depends_on": ["step1"]  # Wait for step1
+            },
+            {
+                "id": "step3",
+                "agent": "validator",
+                "task": "Validate original data",
+                "params": {"data": [1, 2, 3, 4, 5]}
+            }
+        ])
+
+        # Print results
+        print("Results:")
+        print("-" * 40)
+
+        for i, result in enumerate(results):
+            step_name = ["Processor", "Aggregator", "Validator"][i]
+            print(f"\n{step_name} (step{i+1}):")
+            print(f"  Status: {result.get('status')}")
+            print(f"  Output: {result.get('output')}")
+
+        print("\n" + "=" * 60)
+        print("  Workflow completed successfully!")
+        print("=" * 60)
+
+    finally:
+        # Stop the mesh
+        await mesh.stop()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/custom_profile_wrap.py

@@ -0,0 +1,168 @@
+"""
+Custom Profile Example: Using wrap() Function
+
+This example shows how to use the wrap() function to convert
+an existing instance into a JarvisCore agent.
+
+Use Case: You have an already-instantiated object (like a LangChain
+agent, CrewAI agent, or any configured instance) and want to use it
+with JarvisCore orchestration.
+"""
+import asyncio
+from jarviscore import Mesh, wrap, JarvisContext
+
+
+# Simulate an existing "LangChain-like" agent
+class ExternalLLMAgent:
+    """
+    Simulates an external LLM agent (like LangChain).
+    In real usage, this would be your actual LangChain/CrewAI agent.
+    """
+
+    def __init__(self, model_name: str, temperature: float = 0.7):
+        self.model_name = model_name
+        self.temperature = temperature
+        print(f"  Initialized ExternalLLMAgent with {model_name}")
+
+    def invoke(self, query: str) -> dict:
+        """LangChain-style invoke method."""
+        # Simulate LLM response
+        return {
+            "answer": f"Response to '{query}' from {self.model_name}",
+            "model": self.model_name,
+            "tokens_used": len(query.split()) * 10
+        }
+
+
+# Simulate a data processing service
+class DataService:
+    """Simulates an external data processing service."""
+
+    def __init__(self, api_url: str):
+        self.api_url = api_url
+        print(f"  Initialized DataService with {api_url}")
+
+    def run(self, data):
+        """Process data through the service."""
+        if isinstance(data, list):
+            return {
+                "transformed": [x ** 2 for x in data],
+                "source": self.api_url
+            }
+        return {"transformed": data ** 2, "source": self.api_url}
+
+
+# Simulate an agent that needs context
+class ContextAwareProcessor:
+    """Agent that uses JarvisContext to access previous results."""
+
+    def run(self, task, ctx: JarvisContext):
+        """Process with context access."""
+        # Get all previous results
+        all_previous = ctx.all_previous()
+
+        summary = {
+            "task": task,
+            "previous_steps": list(all_previous.keys()),
+            "combined_data": {}
+        }
+
+        for step_id, output in all_previous.items():
+            if isinstance(output, dict):
+                summary["combined_data"][step_id] = output
+
+        return summary
+
+
+async def main():
+    """Demonstrate wrapping existing instances."""
+    print("=" * 60)
+    print("  Custom Profile Example: wrap() Function")
+    print("=" * 60)
+
+    # Create instances of "external" agents
+    print("\nCreating external agent instances...")
+    llm_agent = ExternalLLMAgent(model_name="gpt-4-turbo", temperature=0.3)
+    data_service = DataService(api_url="https://api.example.com/process")
+    context_processor = ContextAwareProcessor()
+
+    # Wrap them for JarvisCore
+    print("\nWrapping instances for JarvisCore...")
+
+    wrapped_llm = wrap(
+        llm_agent,
+        role="llm_assistant",
+        capabilities=["chat", "qa"],
+        execute_method="invoke"  # LangChain uses "invoke"
+    )
+
+    wrapped_data = wrap(
+        data_service,
+        role="data_processor",
+        capabilities=["data_processing", "transformation"]
+        # execute_method auto-detected as "run"
+    )
+
+    wrapped_context = wrap(
+        context_processor,
+        role="context_aggregator",
+        capabilities=["aggregation", "summary"]
+    )
+
+    # Create mesh and add wrapped agents
+    mesh = Mesh(mode="autonomous")
+    mesh.add(wrapped_llm)
+    mesh.add(wrapped_data)
+    mesh.add(wrapped_context)
+
+    await mesh.start()
+
+    try:
+        print("\nExecuting workflow with wrapped agents...\n")
+
+        results = await mesh.workflow("wrap-demo", [
+            {
+                "id": "llm_step",
+                "agent": "llm_assistant",
+                "task": "What is the capital of France?",
+                "params": {"query": "What is the capital of France?"}
+            },
+            {
+                "id": "data_step",
+                "agent": "data_processor",
+                "task": "Transform numbers",
+                "params": {"data": [1, 2, 3, 4, 5]}
+            },
+            {
+                "id": "summary_step",
+                "agent": "context_aggregator",
+                "task": "Summarize all results",
+                "depends_on": ["llm_step", "data_step"]
+            }
+        ])
+
+        # Print results
+        print("Results:")
+        print("-" * 40)
+
+        step_names = ["LLM Assistant", "Data Processor", "Context Aggregator"]
+        for i, result in enumerate(results):
+            print(f"\n{step_names[i]}:")
+            print(f"  Status: {result.get('status')}")
+            output = result.get('output', {})
+            if isinstance(output, dict):
+                for key, value in output.items():
+                    print(f"  {key}: {value}")
+            else:
+                print(f"  Output: {output}")
+
+        print("\n" + "=" * 60)
+        print("  Workflow with wrapped instances completed!")
+        print("=" * 60)
+
+    finally:
+        await mesh.stop()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())