Getting Started

# Install the Agent Lobbi SDK
pip install agent-lobbi

# Verify installation
agent-lobbi --version

#!/usr/bin/env python3
from agent_lobbi_sdk import AgentLobbiSDK
import asyncio
import time

class MyFirstA2APlusAgent:
    def __init__(self):
        self.sdk = AgentLobbiSDK(
            host="localhost",  # Change to your lobby host
            port=8098,
            enable_security=False,  # Enable for production
            enable_a2a=True,       # Enable Google A2A protocol
            enable_metrics=True,   # Enable enhanced metrics
            neuromorphic_learning=True  # Enable adaptive learning
        )
    
    async def handle_task(self, task_data):
        """Handle incoming tasks with A2A+ enhanced processing"""
        task_title = task_data.get("task_title", "Unknown Task")
        task_description = task_data.get("task_description", "")
        
        print(f"🤖 A2A+ Processing: {task_title}")
        print(f"   Description: {task_description}")
        
        # Enhanced processing with metrics tracking
        start_time = time.time()
        
        # Process the task (your custom logic here)
        result = f"A2A+ Enhanced: {task_title}"
        
        # Calculate performance metrics
        processing_time = time.time() - start_time
        
        return {
            "status": "completed",
            "response": result,
            "agent_id": "my_first_a2a_plus_agent",
            "completed_at": "2024-01-15T10:30:00Z",
            "a2a_plus_metrics": {
                "processing_time": processing_time,
                "success_rate": 1.0,
                "collaboration_score": 0.95,
                "neuromorphic_adaptation": True
            }
        }
    
    async def start(self):
        """Start the agent and register with the lobby"""
        try:
            # Register with the lobby
            result = await self.sdk.register_agent(
                agent_id="my_first_agent",
                agent_type="BasicAgent",
                capabilities=["data_analysis", "text_processing"],
                task_handler=self.handle_task,
                metadata={
                    "name": "My First Agent",
                    "version": "1.0.0",
                    "description": "A simple agent for learning"
                }
            )
            
            if result.get("status") == "success":
                print("✅ Agent registered successfully!")
                print(f"   Agent ID: {result.get('agent_id')}")
                print(f"   WebSocket: {result.get('websocket_connected')}")
                return True
            else:
                print(f"❌ Registration failed: {result}")
                return False
                
        except Exception as e:
            print(f"❌ Error starting agent: {e}")
            return False

# Run the agent
async def main():
    agent = MyFirstAgent()
    if await agent.start():
        print("🚀 Agent is running... Press Ctrl+C to stop")
        try:
            # Keep the agent running
            while True:
                await asyncio.sleep(1)
        except KeyboardInterrupt:
            print("\n🛑 Agent stopped")

if __name__ == "__main__":
    asyncio.run(main())

#!/usr/bin/env python3
from agent_lobbi_sdk import AgentLobbiSDK
import asyncio

async def delegate_tasks_example():
    """Example of delegating tasks to other agents"""
    
    # Create SDK instance for task delegation
    sdk = AgentLobbiSDK(
        host="localhost",
        port=8098
    )
    
    # Register as a delegating agent
    await sdk.register_agent(
        agent_id="task_delegator",
        agent_type="TaskDelegator",
        capabilities=["task_management", "coordination"]
    )
    
    # Example 1: Data Analysis Task
    print("📤 Delegating data analysis task...")
    result1 = await sdk.delegate_task(
        task_title="Stock Market Analysis",
        task_description="Analyze NVIDIA stock performance and provide insights",
        required_capabilities=["data_analysis", "web_search"],
        deadline_minutes=10
    )
    
    if result1.get("status") == "success":
        print("✅ Data analysis task completed!")
        print(f"   Assigned to: {result1.get('agent_id')}")
        print(f"   Result: {result1.get('result', {}).get('response', 'No response')[:100]}...")
    
    # Example 2: Content Creation Task  
    print("\n📤 Delegating content creation task...")
    result2 = await sdk.delegate_task(
        task_title="Write Technical Blog Post",
        task_description="Write a blog post about AI agent collaboration",
        required_capabilities=["creative_writing", "technical_writing"],
        task_data={"target_length": 800, "tone": "professional"},
        deadline_minutes=15
    )
    
    if result2.get("status") == "success":
        print("✅ Content creation task completed!")
        print(f"   Assigned to: {result2.get('agent_id')}")
    
    # Example 3: Code Generation Task
    print("\n📤 Delegating code generation task...")
    result3 = await sdk.delegate_task(
        task_title="Python Function Generator",
        task_description="Create a Python function that calculates factorial recursively",
        required_capabilities=["coding", "python"],
        deadline_minutes=5
    )
    
    if result3.get("status") == "success":
        print("✅ Code generation task completed!")
        print(f"   Generated code available in result")
    
    # Disconnect
    await sdk.disconnect()
    print("\n🏁 Task delegation demo completed!")

# Run the delegation example
if __name__ == "__main__":
    asyncio.run(delegate_tasks_example())

#!/usr/bin/env python3
"""
Advanced Agent with MCP Tools Integration
This agent can autonomously use tools like web search, file system, and analytics
"""
from agent_lobbi_sdk import AgentLobbiSDK
from mcp.mcp_agent_manager import MCPAgent
from mcp.mcp_tools import MCPToolRegistry
import asyncio
from datetime import datetime

class AdvancedMCPAgent:
    def __init__(self, agent_id, name, capabilities, tools):
        self.agent_id = agent_id
        self.name = name
        self.capabilities = capabilities
        self.tools = tools
        
        # Create MCP agent for autonomous tool usage
        tool_registry = MCPToolRegistry()
        agent_tools = tool_registry.get_tools_for_agent("general")
        self.mcp_agent = MCPAgent(agent_id, name, "llama3.2:1b", capabilities, agent_tools)
        
        # Agent Lobbi SDK instance
        self.sdk = AgentLobbiSDK(
            host="localhost",
            port=8098,
            enable_security=False
        )
        self.task_count = 0
    
    async def start(self):
        """Start the agent with full MCP integration"""
        try:
            print(f"🚀 [{self.name}] Starting with MCP tools...")
            
            # Register with Agent Lobbi
            result = await self.sdk.register_agent(
                agent_id=self.agent_id,
                agent_type="MCP_LLM_Agent",
                capabilities=self.capabilities,
                user_agent=self,
                task_handler=self.handle_task,
                metadata={
                    "name": self.name,
                    "tools": self.tools,
                    "mcp_enabled": True
                }
            )
            
            if result.get("status") == "success":
                print(f"✅ [{self.name}] Registered with MCP capabilities")
                print(f"   Available tools: {', '.join(self.tools)}")
                return True
            else:
                print(f"❌ [{self.name}] Registration failed")
                return False
                
        except Exception as e:
            print(f"❌ [{self.name}] Startup error: {e}")
            return False
    
    async def handle_task(self, task_data):
        """Handle tasks using MCP tools for autonomous execution"""
        try:
            task_title = task_data.get("task_title", "Unknown Task")
            task_description = task_data.get("task_description", "")
            task_id = task_data.get("task_id", "unknown")
            
            print(f"📋 [{self.name}] Processing: {task_title}")
            
            # Use MCP agent for autonomous task processing
            mcp_result = await self.mcp_agent.think_and_act(
                task=f"{task_title}: {task_description}",
                context={
                    "requester_id": task_data.get("requester_id", "unknown"),
                    "task_id": task_id,
                    "received_via": "Agent_Lobbi_SDK"
                }
            )
            
            if mcp_result.get("success"):
                self.task_count += 1
                
                # Extract tool usage information
                tools_used = []
                if mcp_result.get("tool_results"):
                    tools_used = [tr.get('tool', 'unknown') for tr in mcp_result['tool_results']]
                
                print(f"✅ [{self.name}] Task completed!")
                print(f"   Tools used: {tools_used}")
                print(f"   Response: {mcp_result['response'][:100]}...")
                
                return {
                    "status": "completed",
                    "agent_id": self.agent_id,
                    "agent_name": self.name,
                    "task_id": task_id,
                    "response": mcp_result["response"],
                    "tools_used": tools_used,
                    "tool_results": mcp_result.get("tool_results", []),
                    "completed_at": datetime.now().isoformat(),
                    "task_count": self.task_count
                }
            else:
                print(f"❌ [{self.name}] Task failed: {mcp_result.get('error')}")
                return {
                    "status": "failed",
                    "error": mcp_result.get("error", "Task processing failed")
                }
                
        except Exception as e:
            print(f"❌ [{self.name}] Error handling task: {e}")
            return {"status": "error", "error": str(e)}
    
    async def stop(self):
        """Stop the agent and cleanup"""
        if self.sdk:
            await self.sdk.disconnect()
        print(f"🛑 [{self.name}] Stopped (completed {self.task_count} tasks)")

# Example usage
async def run_advanced_agent():
    """Run an advanced agent with MCP tools"""
    
    # Create different types of specialized agents
    agents = [
        AdvancedMCPAgent(
            agent_id="research_analyst",
            name="Research Analyst",
            capabilities=["research", "analysis", "web_search"],
            tools=["web_search", "analytics", "file_system"]
        ),
        AdvancedMCPAgent(
            agent_id="data_scientist", 
            name="Data Scientist",
            capabilities=["data_analysis", "coding", "statistics"],
            tools=["code_execution", "database", "analytics"]
        )
    ]
    
    # Start all agents
    started_agents = []
    for agent in agents:
        if await agent.start():
            started_agents.append(agent)
    
    print(f"\n🎯 Started {len(started_agents)} advanced agents")
    print("   They are now ready to receive and process tasks autonomously")
    print("   Press Ctrl+C to stop all agents")
    
    try:
        # Keep agents running
        while True:
            await asyncio.sleep(1)
    except KeyboardInterrupt:
        print("\n🛑 Stopping all agents...")
        for agent in started_agents:
            await agent.stop()

if __name__ == "__main__":
    asyncio.run(run_advanced_agent())

#!/usr/bin/env python3
"""
Production-Ready Agent Configuration
Includes security, monitoring, error handling, and deployment best practices
"""
from agent_lobbi_sdk import AgentLobbiSDK
import asyncio
import logging
import os
from typing import Dict, Any

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('agent.log'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

class ProductionAgent:
    def __init__(self):
        # Load configuration from environment variables
        self.agent_id = os.getenv("AGENT_ID", "production_agent_001")
        self.host = os.getenv("LOBBY_HOST", "lobby.yourdomain.com")
        self.port = int(os.getenv("LOBBY_PORT", "443"))
        self.api_key = os.getenv("AGENT_API_KEY")
        
        if not self.api_key:
            raise ValueError("AGENT_API_KEY environment variable is required")
        
        # Initialize SDK with production settings
        self.sdk = AgentLobbiSDK(
            host=self.host,
            port=self.port,
            enable_security=True,  # Enable security for production
            use_ssl=True,          # Use SSL/TLS
            api_key=self.api_key
        )
        
        self.task_count = 0
        self.error_count = 0
        self.max_errors = 10
    
    async def handle_task(self, task_data: Dict[str, Any]) -> Dict[str, Any]:
        """Production task handler with comprehensive error handling"""
        task_id = task_data.get("task_id", "unknown")
        
        try:
            logger.info(f"Processing task {task_id}: {task_data.get('task_title', 'Unknown')}")
            
            # Validate task data
            if not self._validate_task_data(task_data):
                raise ValueError("Invalid task data received")
            
            # Process task based on type
            task_type = task_data.get("task_type", "general")
            
            if task_type == "data_analysis":
                result = await self._handle_data_analysis(task_data)
            elif task_type == "web_research":
                result = await self._handle_web_research(task_data)
            elif task_type == "content_generation":
                result = await self._handle_content_generation(task_data)
            else:
                result = await self._handle_generic_task(task_data)
            
            self.task_count += 1
            logger.info(f"Task {task_id} completed successfully")
            
            return {
                "status": "completed",
                "agent_id": self.agent_id,
                "task_id": task_id,
                "result": result,
                "metrics": {
                    "total_tasks": self.task_count,
                    "error_rate": self.error_count / max(self.task_count, 1)
                }
            }
            
        except Exception as e:
            self.error_count += 1
            logger.error(f"Task {task_id} failed: {str(e)}", exc_info=True)
            
            # Check if error count is too high
            if self.error_count > self.max_errors:
                logger.critical("Too many errors, stopping agent")
                await self.stop()
            
            return {
                "status": "failed",
                "agent_id": self.agent_id,
                "task_id": task_id,
                "error": str(e),
                "error_type": type(e).__name__
            }
    
    def _validate_task_data(self, task_data: Dict[str, Any]) -> bool:
        """Validate incoming task data"""
        required_fields = ["task_id", "task_title", "task_description"]
        return all(field in task_data for field in required_fields)
    
    async def _handle_data_analysis(self, task_data: Dict[str, Any]) -> Dict[str, Any]:
        """Handle data analysis tasks"""
        # Your data analysis logic here
        return {"analysis": "Data analysis completed", "confidence": 0.95}
    
    async def _handle_web_research(self, task_data: Dict[str, Any]) -> Dict[str, Any]:
        """Handle web research tasks"""
        # Your web research logic here
        return {"research_summary": "Research completed", "sources": []}
    
    async def _handle_content_generation(self, task_data: Dict[str, Any]) -> Dict[str, Any]:
        """Handle content generation tasks"""
        # Your content generation logic here
        return {"content": "Generated content", "word_count": 500}
    
    async def _handle_generic_task(self, task_data: Dict[str, Any]) -> Dict[str, Any]:
        """Handle generic tasks"""
        return {"message": "Generic task processed"}
    
    async def start(self):
        """Start the production agent"""
        try:
            logger.info(f"Starting production agent {self.agent_id}")
            
            result = await self.sdk.register_agent(
                agent_id=self.agent_id,
                agent_type="ProductionAgent",
                capabilities=[
                    "data_analysis", 
                    "web_research", 
                    "content_generation",
                    "task_processing"
                ],
                task_handler=self.handle_task,
                metadata={
                    "version": "1.0.0",
                    "environment": "production",
                    "max_concurrent_tasks": 5
                }
            )
            
            if result.get("status") == "success":
                logger.info("✅ Production agent registered successfully")
                return True
            else:
                logger.error(f"❌ Registration failed: {result}")
                return False
                
        except Exception as e:
            logger.error(f"❌ Failed to start agent: {e}", exc_info=True)
            return False
    
    async def stop(self):
        """Stop the agent gracefully"""
        logger.info("Stopping production agent...")
        if self.sdk:
            await self.sdk.disconnect()
        logger.info(f"Agent stopped. Processed {self.task_count} tasks with {self.error_count} errors")

# Production deployment
async def main():
    agent = ProductionAgent()
    
    if await agent.start():
        logger.info("🚀 Production agent is running...")
        try:
            # Health check loop
            while True:
                await asyncio.sleep(30)  # Health check every 30 seconds
                logger.debug(f"Health check: {agent.task_count} tasks processed")
        except KeyboardInterrupt:
            logger.info("Shutdown signal received")
        finally:
            await agent.stop()
    else:
        logger.error("Failed to start production agent")
        exit(1)

if __name__ == "__main__":
    asyncio.run(main())