agent-mcp 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

demos/workflows/autonomous_agent_workflow.py

@@ -0,0 +1,248 @@
+"""
+Autonomous Agent Collaboration Example
+
+This script demonstrates how agents can autonomously collaborate without
+hardcoded interaction patterns. The flow is determined by the agents themselves
+based on their analysis of the conversation.
+"""
+
+import os
+import sys
+import time
+from typing import Dict, Any, Optional
+
+# Import the required langgraph components
+try:
+    from langgraph.graph import StateGraph
+    from langchain_core.messages import HumanMessage, AIMessage
+    from langchain_openai import ChatOpenAI
+except ImportError:
+    print("Error: Required packages not found. Make sure langgraph, langchain-core, and langchain-openai are installed.")
+    sys.exit(1)
+
+class Agent:
+    """A simple agent implementation that can make decisions about collaboration."""
+    
+    def __init__(self, name: str, specialty: str, system_message: str = None):
+        """Initialize the agent with a name, specialty, and optional system message."""
+        self.name = name
+        self.specialty = specialty
+        self.system_message = system_message or f"You are {name}, an expert in {specialty}."
+        
+        # Create the OpenAI chat model
+        api_key = os.environ.get("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("OPENAI_API_KEY environment variable not set")
+        
+        self.llm = ChatOpenAI(
+            model="gpt-4",
+            temperature=0.2,
+            api_key=api_key,
+            model_kwargs={"messages": [{"role": "system", "content": self.system_message}]}
+        )
+    
+    def respond(self, messages: list) -> Dict[str, Any]:
+        """Generate a response and determine who to collaborate with next."""
+        
+        # Convert to format expected by langchain
+        lc_messages = []
+        for msg in messages:
+            if msg["role"] == "user":
+                lc_messages.append(HumanMessage(content=msg["content"]))
+            elif msg["role"] == "assistant":
+                lc_messages.append(AIMessage(content=msg["content"], name=msg.get("name")))
+        
+        # Generate a response to the conversation
+        response = self.llm.invoke(lc_messages)
+        content = response.content
+        
+        # Determine who should respond next
+        # We'll use a special format in the response: [NEXT: agent_name] to indicate
+        collaboration_prompt = f"""
+        Based on your response, determine which team member should contribute next:
+        - Researcher (information gathering)
+        - Analyst (data interpretation)
+        - Creative (innovative ideas)
+        - Planner (implementation strategy)
+        - Coordinator (synthesizing and directing)
+        
+        Choose the most appropriate agent based on what's needed next.
+        Format your choice as [NEXT: agent_name]
+        """
+        
+        next_agent_decision = self.llm.invoke([
+            HumanMessage(content=collaboration_prompt + "\n\nYour response was: " + content)
+        ])
+        
+        # Extract the next agent from the decision
+        next_agent = "coordinator"  # Default
+        decision_text = next_agent_decision.content.lower()
+        
+        if "[next:" in decision_text:
+            # Extract the agent name from the format [NEXT: agent_name]
+            start = decision_text.find("[next:") + 6
+            end = decision_text.find("]", start)
+            if end > start:
+                next_agent = decision_text[start:end].strip().lower()
+        
+        # Return both the response and the next agent decision
+        return {
+            "response": content,
+            "next": next_agent
+        }
+
+class AutonomousCollaboration:
+    """Manages autonomous collaboration between agents."""
+    
+    def __init__(self):
+        """Initialize the collaboration environment."""
+        self.agents = {}
+        self.message_history = []
+    
+    def create_agents(self):
+        """Create the agent team.
+        
+        This method initializes a team of specialized agents with predefined roles
+        and system messages. Each agent is created with specific expertise and
+        personality traits to contribute effectively to the collaboration.
+        """
+        self.agents = {
+            "coordinator": Agent(
+                name="Coordinator",
+                specialty="coordinating team efforts",
+                system_message="""You are the Coordinator. Your role is to guide the research process,
+                ensure all perspectives are considered, and synthesize information from all team members.
+                When appropriate, suggest which agent would be best to handle the next step."""
+            ),
+            "researcher": Agent(
+                name="Researcher",
+                specialty="information gathering and fact-finding",
+                system_message="""You are the Researcher. Your role is to gather relevant information,
+                identify key facts, and provide evidence-based context for the topic.
+                When appropriate, suggest which agent would be best to handle the next step."""
+            ),
+            "analyst": Agent(
+                name="Analyst",
+                specialty="analyzing data and identifying patterns",
+                system_message="""You are the Analyst. Your role is to interpret information,
+                identify patterns, evaluate implications, and provide critical insights.
+                When appropriate, suggest which agent would be best to handle the next step."""
+            ),
+            "creative": Agent(
+                name="Creative",
+                specialty="generating innovative ideas and approaches",
+                system_message="""You are the Creative. Your role is to think outside the box,
+                generate innovative ideas, make unexpected connections, and envision new possibilities.
+                When appropriate, suggest which agent would be best to handle the next step."""
+            ),
+            "planner": Agent(
+                name="Planner",
+                specialty="creating implementation strategies",
+                system_message="""You are the Planner. Your role is to develop practical strategies,
+                create roadmaps, identify necessary resources, and outline implementation steps.
+                When appropriate, suggest which agent would be best to handle the next step."""
+            )
+        }
+        
+        print(f"Created {len(self.agents)} agents:")
+        for agent_id, agent in self.agents.items():
+            print(f"- {agent.name} ({agent_id}): {agent.specialty}")
+    
+    def run_collaboration(self, topic: str, max_steps: int = 5):
+        """Run an autonomous collaboration on the given topic.
+        
+        Args:
+            topic: The subject matter for agents to collaborate on
+            max_steps: Maximum number of interaction steps (default: 5)
+            
+        This method orchestrates the autonomous collaboration process where agents
+        interact and build upon each other's contributions. Each agent decides
+        which team member should contribute next based on the conversation flow.
+        The process continues until max_steps is reached.
+        """
+        print(f"\n{'='*80}")
+        print(f"AUTONOMOUS COLLABORATION ON: {topic}")
+        print(f"{'='*80}\n")
+        
+        print("Starting collaboration process...\n")
+        
+        # Add the initial message from the user
+        self.message_history.append({
+            "role": "user",
+            "content": f"I need your help researching this topic: {topic}. Please collaborate as a team to explore it thoroughly."
+        })
+        
+        # Start with the coordinator
+        current_agent = "coordinator"
+        
+        # Track the interaction flow
+        interaction_flow = []
+        
+        # Run for max_steps or until we detect a loop
+        for step in range(1, max_steps + 1):
+            agent = self.agents[current_agent]
+            print(f"\n[Step {step}] {agent.name} is responding...")
+            
+            # Get the agent's response
+            result = agent.respond(self.message_history)
+            
+            # Record the response in the message history
+            self.message_history.append({
+                "role": "assistant",
+                "name": agent.name,
+                "content": result["response"]
+            })
+            
+            # Display a summary of the response
+            response_summary = result["response"]
+            if len(response_summary) > 150:
+                response_summary = response_summary[:150] + "..."
+            print(f"Response: {response_summary}")
+            
+            # Track the flow
+            interaction_flow.append({
+                "step": step,
+                "agent": agent.name,
+                "next": result["next"]
+            })
+            
+            # Update the current agent based on the agent's decision
+            print(f"{agent.name} suggests that {result['next']} should respond next.")
+            current_agent = result["next"]
+            
+            # Add a short delay to make the output more readable
+            time.sleep(1)
+        
+        print(f"\n{'='*80}")
+        print(f"AUTONOMOUS COLLABORATION COMPLETE")
+        print(f"{'='*80}\n")
+        
+        # Display the interaction flow
+        print("Agent Interaction Flow:")
+        print("-" * 40)
+        for step in interaction_flow:
+            print(f"Step {step['step']}: {step['agent']} → {step['next']}")
+        
+        return self.message_history
+
+def main():
+    """Run the autonomous collaboration example.
+    
+    This function serves as the entry point for the script, setting up and
+    executing an autonomous collaboration session. It accepts an optional
+    command-line argument for the collaboration topic, defaulting to
+    'Sustainable urban development' if none is provided.
+    """
+    # Get topic from command line argument or use default
+    if len(sys.argv) > 1:
+        topic = " ".join(sys.argv[1:])
+    else:
+        topic = "Sustainable urban development"
+    
+    # Create and run the collaboration
+    collab = AutonomousCollaboration()
+    collab.create_agents()
+    collab.run_collaboration(topic, max_steps=5)
+
+if __name__ == "__main__":
+    main()

demos/workflows/mcp_features_demo.py

@@ -0,0 +1,353 @@
+"""
+MCP Features Demo
+
+This script demonstrates the key features of the Model Context Protocol
+implementation in MCPAgent with detailed explanations of what's happening
+at each step.
+"""
+
+import os
+import json
+from typing import Dict, List, Any, Optional
+
+# Import MCPAgent
+from agent_mcp.mcp_agent import MCPAgent
+
+# Check for API key
+api_key = os.environ.get("OPENAI_API_KEY")
+if not api_key:
+    raise ValueError("Please set the OPENAI_API_KEY environment variable")
+
+# LLM configuration - using gpt-3.5-turbo for faster responses
+config = {
+    "config_list": [{"model": "gpt-3.5-turbo", "api_key": api_key}],
+}
+
+def demonstrate_context_operations():
+    """Demonstrate basic context operations with MCPAgent."""
+    print("\n=== Demonstrating Context Operations ===")
+    
+    # Create a simple MCP agent without LLM
+    agent = MCPAgent(
+        name="ContextDemo",
+        system_message="You demonstrate context operations."
+    )
+    
+    # 1. Set context using direct method
+    print("\n1. Setting context using direct update_context() method")
+    agent.update_context("user", {
+        "name": "Alice",
+        "preferences": {
+            "color": "blue",
+            "language": "English",
+            "notifications": True
+        }
+    })
+    print("User context added")
+    
+    # 2. Get context using direct method
+    print("\n2. Getting context using direct get_context() method")
+    user_context = agent.get_context("user")
+    print(f"Retrieved user context: {json.dumps(user_context, indent=2)}")
+    
+    # 3. Set context using MCP tool
+    print("\n3. Setting context using context_set tool")
+    result = agent.execute_tool(
+        "context_set", 
+        key="weather", 
+        value={"location": "New York", "temperature": 72, "conditions": "Sunny"}
+    )
+    print(f"Tool result: {result}")
+    
+    # 4. Get context using MCP tool
+    print("\n4. Getting context using context_get tool")
+    result = agent.execute_tool("context_get", key="weather")
+    print(f"Tool result: {json.dumps(result, indent=2)}")
+    
+    # 5. List all context keys
+    print("\n5. Listing all context keys using context_list tool")
+    result = agent.execute_tool("context_list")
+    print(f"Tool result: {json.dumps(result, indent=2)}")
+    
+    # 6. Demonstrate context summary generation
+    print("\n6. Generating context summary for LLM integration")
+    summary = agent._generate_context_summary()
+    print(f"Context summary:\n{summary}")
+    
+    # 7. Remove context using MCP tool
+    print("\n7. Removing context using context_remove tool")
+    result = agent.execute_tool("context_remove", key="weather")
+    print(f"Tool result: {json.dumps(result, indent=2)}")
+    
+    # 8. Verify context was removed
+    print("\n8. Verifying context was removed by listing keys again")
+    result = agent.execute_tool("context_list")
+    print(f"Tool result: {json.dumps(result, indent=2)}")
+
+def demonstrate_custom_tools():
+    """Demonstrate registering and using custom tools with MCPAgent."""
+    print("\n=== Demonstrating Custom Tool Registration ===")
+    
+    # Create a simple MCP agent
+    agent = MCPAgent(
+        name="ToolDemo",
+        system_message="You demonstrate tool operations."
+    )
+    
+    # 1. Define and register a simple calculator tool
+    print("\n1. Defining and registering a calculator tool")
+    
+    def calculate(operation: str, a: float, b: float) -> Dict:
+        """Perform a basic calculation."""
+        result = None
+        if operation == "add":
+            result = a + b
+        elif operation == "subtract":
+            result = a - b
+        elif operation == "multiply":
+            result = a * b
+        elif operation == "divide":
+            if b == 0:
+                return {"status": "error", "message": "Cannot divide by zero"}
+            result = a / b
+        else:
+            return {"status": "error", "message": f"Unknown operation: {operation}"}
+            
+        return {"status": "success", "result": result}
+    
+    # Register the tool with parameter descriptions
+    agent.register_mcp_tool(
+        name="math_calculate",
+        description="Perform basic mathematical calculations",
+        func=calculate,
+        operation_description="The operation to perform: add, subtract, multiply, or divide",
+        a_description="First number",
+        b_description="Second number"
+    )
+    print("Calculator tool registered")
+    
+    # 2. Define and register a text processing tool
+    print("\n2. Defining and registering a text processing tool")
+    
+    def process_text(text: str, operation: str) -> Dict:
+        """Process text with various operations."""
+        if operation == "uppercase":
+            return {"status": "success", "result": text.upper()}
+        elif operation == "lowercase":
+            return {"status": "success", "result": text.lower()}
+        elif operation == "capitalize":
+            return {"status": "success", "result": text.capitalize()}
+        elif operation == "word_count":
+            return {"status": "success", "result": len(text.split())}
+        else:
+            return {"status": "error", "message": f"Unknown operation: {operation}"}
+    
+    # Register the tool
+    agent.register_mcp_tool(
+        name="text_process",
+        description="Process text with various operations",
+        func=process_text,
+        text_description="The text to process",
+        operation_description="The operation to perform: uppercase, lowercase, capitalize, or word_count"
+    )
+    print("Text processing tool registered")
+    
+    # 3. Get information about all tools
+    print("\n3. Getting information about all available tools")
+    tool_info = agent.execute_tool("mcp_info")
+    print(f"Agent ID: {tool_info['id']}")
+    print(f"Agent Name: {tool_info['name']}")
+    print(f"MCP Version: {tool_info['version']}")
+    print("Available tools:")
+    for tool in tool_info['tools']:
+        print(f"- {tool['name']}: {tool['description']}")
+        if tool['parameters']:
+            for param in tool['parameters']:
+                required = "required" if param.get('required', False) else "optional"
+                print(f"  • {param['name']} ({required}): {param['description']}")
+    
+    # 4. Use the calculator tool
+    print("\n4. Using the calculator tool")
+    result = agent.execute_tool("math_calculate", operation="add", a=5, b=7)
+    print(f"5 + 7 = {json.dumps(result, indent=2)}")
+    
+    result = agent.execute_tool("math_calculate", operation="multiply", a=6, b=8)
+    print(f"6 * 8 = {json.dumps(result, indent=2)}")
+    
+    # 5. Use the text processing tool
+    print("\n5. Using the text processing tool")
+    result = agent.execute_tool("text_process", text="Hello World", operation="uppercase")
+    print(f"Uppercase: {json.dumps(result, indent=2)}")
+    
+    result = agent.execute_tool("text_process", text="Hello World", operation="word_count")
+    print(f"Word count: {json.dumps(result, indent=2)}")
+
+def demonstrate_agent_as_tool():
+    """Demonstrate registering and using an agent as a tool."""
+    print("\n=== Demonstrating Agent-as-Tool ===")
+    
+    # 1. Create two MCP agents
+    print("\n1. Creating a helper agent and a main agent")
+    
+    helper = MCPAgent(
+        name="HelperAgent",
+        system_message="You are a helpful assistant that specializes in providing definitions and explanations."
+    )
+    
+    # Give the helper some context to use
+    helper.update_context("definitions", {
+        "Machine Learning": "A field of study that gives computers the ability to learn without being explicitly programmed.",
+        "Neural Network": "A computing system inspired by biological neural networks that can learn to perform tasks by analyzing examples.",
+        "Context Protocol": "A standardized way for AI systems to share and manage context information."
+    })
+    
+    main_agent = MCPAgent(
+        name="MainAgent",
+        system_message="You are a coordinator that can ask other agents for help."
+    )
+    
+    # 2. Register the helper agent as a tool
+    print("\n2. Registering the helper agent as a tool for the main agent")
+    main_agent.register_agent_as_tool(helper)
+    print("Helper agent registered as a tool")
+    
+    # 3. List all tools on the main agent
+    print("\n3. Listing all tools available to the main agent")
+    tool_info = main_agent.execute_tool("mcp_info")
+    print("Available tools:")
+    for tool in tool_info['tools']:
+        print(f"- {tool['name']}: {tool['description']}")
+    
+    # 4. Use the agent tool
+    print("\n4. Using the agent tool to ask for a definition")
+    result = main_agent.execute_tool(
+        "agent_HelperAgent", 
+        message="Can you define what Neural Network means?"
+    )
+    print(f"Response from helper: {json.dumps(result, indent=2)}")
+    
+    # 5. Show how context is maintained in the helper
+    print("\n5. Adding more context to the helper agent")
+    helper.update_context("definitions", {
+        "Machine Learning": "A field of study that gives computers the ability to learn without being explicitly programmed.",
+        "Neural Network": "A computing system inspired by biological neural networks that can learn to perform tasks by analyzing examples.",
+        "Context Protocol": "A standardized way for AI systems to share and manage context information.",
+        "Deep Learning": "A subset of machine learning that uses multi-layered neural networks to model complex patterns."
+    })
+    
+    print("\n6. Asking for a new definition that was just added")
+    result = main_agent.execute_tool(
+        "agent_HelperAgent", 
+        message="What is Deep Learning?"
+    )
+    print(f"Response from helper: {json.dumps(result, indent=2)}")
+
+def demonstrate_llm_integration():
+    """Demonstrate using MCPAgent with a real LLM."""
+    print("\n=== Demonstrating LLM Integration ===")
+    
+    # Skip if no API key
+    if not api_key:
+        print("Skipping LLM demo - no API key provided")
+        return
+    
+    # 1. Create an MCP agent with LLM capability
+    print("\n1. Creating an MCP agent with LLM capability")
+    agent = MCPAgent(
+        name="LLMAgent",
+        system_message="You are a helpful assistant that uses context to enhance your responses.",
+        llm_config=config
+    )
+    print("Agent created with LLM capability")
+    
+    # 2. Add context that will be used by the LLM
+    print("\n2. Adding context about the user and weather")
+    agent.update_context("user", {
+        "name": "Bob",
+        "location": "San Francisco",
+        "interests": ["hiking", "photography", "cooking"]
+    })
+    
+    agent.update_context("weather", {
+        "location": "San Francisco",
+        "current": {
+            "temperature": 68,
+            "conditions": "Partly cloudy",
+            "wind": "Light breeze"
+        },
+        "forecast": ["Sunny", "Sunny", "Rain", "Partly cloudy"]
+    })
+    print("Context added")
+    
+    # 3. Test with a prompt that should use the context
+    print("\n3. Testing with a prompt that should use context")
+    prompt = "What's the weather like today and what activities would you recommend for me?"
+    
+    print(f"User: {prompt}")
+    response = agent.generate_reply(
+        messages=[{"role": "user", "content": prompt}]
+    )
+    print(f"Agent: {response}")
+    
+    # 4. Add a tool call to update context
+    print("\n4. Adding a new interest through natural language")
+    prompt = "Please add 'tennis' to my list of interests."
+    
+    print(f"User: {prompt}")
+    response = agent.generate_reply(
+        messages=[{"role": "user", "content": prompt}]
+    )
+    print(f"Agent: {response}")
+    
+    # Manual detection since it might not work automatically
+    user_context = agent.get_context("user")
+    if user_context and "interests" in user_context and isinstance(user_context["interests"], list):
+        if "tennis" not in user_context["interests"]:
+            user_context["interests"].append("tennis")
+            agent.update_context("user", user_context)
+            print("Manually added 'tennis' to interests")
+    
+    # 5. Check if the context was updated
+    print("\n5. Checking if context was updated")
+    user_context = agent.get_context("user")
+    print(f"Updated user context: {json.dumps(user_context, indent=2)}")
+    
+    # 6. Ask about the updated interests
+    print("\n6. Asking about updated interests")
+    prompt = "What are my interests now?"
+    
+    print(f"User: {prompt}")
+    response = agent.generate_reply(
+        messages=[{"role": "user", "content": prompt}]
+    )
+    print(f"Agent: {response}")
+
+def main():
+    """Run the MCP features demonstration."""
+    print("=== MCP Features Demonstration ===")
+    print("This script shows the key features of the MCPAgent with detailed explanations.")
+    
+    # Demonstrate basic context operations
+    demonstrate_context_operations()
+    
+    # Demonstrate custom tools
+    demonstrate_custom_tools()
+    
+    # Demonstrate agent as tool
+    demonstrate_agent_as_tool()
+    
+    # Demonstrate LLM integration
+    demonstrate_llm_integration()
+    
+    print("\n=== Demonstration Complete ===")
+    print("You've now seen the main features of MCPAgent:")
+    print("1. Context management (get, set, list, remove)")
+    print("2. Custom tool registration and usage")
+    print("3. Using agents as tools")
+    print("4. LLM integration with context")
+    print("\nTo run the more interactive examples, try:")
+    print("- agent_network_example.py: A social network of agents")
+    print("- collaborative_task_example.py: A team of agents working on a project")
+
+if __name__ == "__main__":
+    main()

demos/workflows/run_agent_collaboration_demo.py

@@ -0,0 +1,63 @@
+"""
+Autonomous Agent Collaboration Demo
+
+This script demonstrates how agents can autonomously collaborate on a topic without
+hardcoded interaction patterns. The user only provides the topic, and the agents
+decide for themselves who to collaborate with and in what order.
+"""
+
+from demos.langgraph.autonomous_langgraph_network import AutonomousAgentNetwork
+import sys
+import time
+
+def run_autonomous_collaboration(topic):
+    """
+    Run an autonomous collaborative research process on a given topic.
+    
+    Args:
+        topic: The topic for the agents to research and collaborate on
+    """
+    print(f"\n{'='*80}")
+    print(f"AUTONOMOUS AGENT COLLABORATION: {topic}")
+    print(f"{'='*80}\n")
+    
+    # Create the autonomous agent network
+    print("Initializing autonomous agent network...")
+    network = AutonomousAgentNetwork()
+    network.create_network()
+    print("Network created with autonomous decision-making capabilities")
+    
+    print(f"\nStarting collaborative research on: {topic}")
+    print(f"{'='*40}")
+    print("Each agent will autonomously decide which other agents to collaborate with.")
+    print("Agents will share information through the workspace without predefined patterns.")
+    print(f"{'='*40}\n")
+    
+    # Start the autonomous research process with a maximum number of steps
+    max_steps = 10
+    print(f"Beginning research (max {max_steps} interaction steps)...")
+    
+    # Run the autonomous research
+    results = network.research_topic(topic, max_steps=max_steps)
+    
+    # Show the final state of the workspace
+    print("\nFinal Shared Workspace State:")
+    network.show_workspace()
+    
+    print(f"\n{'='*80}")
+    print(f"RESEARCH COMPLETE")
+    print(f"{'='*80}\n")
+    return results
+
+if __name__ == "__main__":
+    # If a topic is provided as a command line argument, use that
+    if len(sys.argv) > 1:
+        topic = " ".join(sys.argv[1:])
+    else:
+        # Otherwise use a default topic or ask for input
+        topic = input("Enter a research topic for autonomous agent collaboration: ")
+    
+    if not topic:
+        topic = "The future of autonomous AI agents in business"
+    
+    run_autonomous_collaboration(topic)