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

demos/network/heterogeneous_network_example.py

@@ -0,0 +1,216 @@
+"""
+Example of heterogeneous agent network with Autogen and Langchain agents.
+"""
+
+import os
+import asyncio
+from typing import Dict, Any
+import openai
+from agent_mcp.enhanced_mcp_agent import EnhancedMCPAgent
+from agent_mcp.langchain_mcp_adapter import LangchainMCPAdapter
+from agent_mcp.mcp_transport import HTTPTransport
+
+# Langchain imports
+from langchain_openai import ChatOpenAI
+from langchain_community.utilities.duckduckgo_search import DuckDuckGoSearchAPIWrapper
+from langchain_community.tools import Tool
+from langchain.agents import AgentExecutor, OpenAIFunctionsAgent
+from langchain.schema.messages import SystemMessage
+
+# Check for OpenAI API key
+api_key = os.getenv("OPENAI_API_KEY")
+if not api_key:
+    raise ValueError("Please set the OPENAI_API_KEY environment variable")
+
+openai.api_key = api_key
+
+async def setup_langchain_agent():
+    """Setup a Langchain agent with search capabilities"""
+    # Create Langchain tools
+    search = DuckDuckGoSearchAPIWrapper()
+    search_tool = Tool(
+        name="duckduckgo_search",
+        description="Search the web using DuckDuckGo",
+        func=search.run
+    )
+    tools = [search_tool]
+    
+    # Create Langchain model and agent
+    llm = ChatOpenAI(temperature=0)
+    agent = OpenAIFunctionsAgent.from_llm_and_tools(
+        llm=llm,
+        tools=tools,
+        system_message=SystemMessage(content=(
+            "You are a research assistant that helps find and analyze information."
+        ))
+    )
+    
+    # Create the agent executor
+    agent_executor = AgentExecutor.from_agent_and_tools(
+        agent=agent,
+        tools=tools,
+        verbose=True,
+        handle_parsing_errors=True
+    )
+    
+    return agent, agent_executor
+
+async def check_task_completion(coordinator, task):
+    """Check if all tasks are completed and generate final summary"""
+    all_completed = True
+    all_results = {}
+    
+    for step in task["steps"]:
+        task_id = step["task_id"]
+        if task_id not in coordinator.task_results or coordinator.task_results[task_id] is None:
+            all_completed = False
+            break
+        all_results[task_id] = coordinator.task_results[task_id]
+    
+    if all_completed:
+        print("\n=== All tasks completed! ===")
+        print("\nTask Results:")
+        for task_id, result in all_results.items():
+            print(f"\n{task_id}:")
+            print(result)
+        
+        # Generate final summary using the coordinator
+        summary_task = {
+            "task_id": "final_summary",
+            "description": "Create a comprehensive summary of the quantum computing research. First summarize the initial research findings, then analyze the key insights and implications for the future of quantum computing.",
+            "previous_results": all_results,
+            "reply_to": "http://localhost:8000"
+        }
+        
+        await coordinator.assign_task("http://localhost:8001", summary_task)
+        return True
+        
+    return False
+
+async def main():
+    # Create transport layers
+    coordinator_transport = HTTPTransport(host="localhost", port=8000)
+    autogen_transport = HTTPTransport(host="localhost", port=8001)
+    langchain_transport = HTTPTransport(host="localhost", port=8002)
+    
+    # Create coordinator agent (Autogen-based)
+    coordinator = EnhancedMCPAgent(
+        name="Coordinator",
+        transport=coordinator_transport,
+        server_mode=True,
+        system_message="You coordinate tasks between different agents",
+        llm_config={
+            "config_list": [{
+                "model": "gpt-3.5-turbo",
+                "api_key": api_key
+            }]
+        }
+    )
+    
+    # Create Autogen worker agent
+    autogen_worker = EnhancedMCPAgent(
+        name="AutogenWorker",
+        transport=autogen_transport,
+        client_mode=True,
+        system_message="I help with text analysis and summarization",
+        llm_config={
+            "config_list": [{
+                "model": "gpt-3.5-turbo",
+                "api_key": api_key
+            }]
+        }
+    )
+    
+    # Create and setup Langchain agent
+    langchain_agent, agent_executor = await setup_langchain_agent()
+    
+    # Create Langchain worker agent with adapter
+    langchain_worker = LangchainMCPAdapter(
+        name="LangchainWorker",
+        transport=langchain_transport,
+        client_mode=True,
+        langchain_agent=langchain_agent,
+        agent_executor=agent_executor
+    )
+    
+    # Start the coordinator server
+    print("Starting coordinator server...")
+    coordinator.run()
+    
+    # Give the server a moment to start
+    await asyncio.sleep(2)
+    
+    # Start workers first
+    print("Starting workers...")
+    autogen_worker.run()
+    langchain_worker.run()
+    
+    # Give workers a moment to start
+    await asyncio.sleep(2)
+    
+    # Connect workers to coordinator
+    print("Connecting workers to coordinator...")
+    await autogen_worker.connect_to_server("http://localhost:8000")
+    await langchain_worker.connect_to_server("http://localhost:8000")
+    
+    # Example collaborative task
+    task = {
+        "task_id": "research_task_1",
+        "type": "collaborative_task",
+        "description": "Research the latest developments in quantum computing and prepare a summary",
+        "steps": [
+            {
+                "agent": "LangchainWorker",
+                "task_id": "research_task_1_LangchainWorker",
+                "description": "Search for recent quantum computing breakthroughs in 2024",
+                "url": "http://localhost:8002"
+            },
+            {
+                "agent": "AutogenWorker",
+                "task_id": "research_task_1_AutogenWorker",
+                "description": "Analyze and summarize the findings",
+                "url": "http://localhost:8001",
+                "depends_on": ["research_task_1_LangchainWorker"]
+            }
+        ]
+    }
+    
+    print("Assigning tasks to agents...")
+    
+    # Store task dependencies
+    coordinator.task_dependencies = {}
+    for step in task["steps"]:
+        task_id = step["task_id"]
+        coordinator.task_dependencies[task_id] = {
+            "url": step["url"],
+            "depends_on": [dep for dep in step.get("depends_on", [])]
+        }
+    
+    print(f"Task dependencies: {coordinator.task_dependencies}")
+    
+    # Assign tasks to agents
+    for step in task["steps"]:
+        await coordinator.assign_task(step["url"], {
+            "task_id": step["task_id"],
+            "description": step["description"],
+            "reply_to": "http://localhost:8000"
+        })
+    
+    # Keep checking for task completion
+    print("Tasks assigned. Waiting for results...")
+    try:
+        while True:
+            if await check_task_completion(coordinator, task):
+                print("\nWaiting for final summary...")
+                await asyncio.sleep(5)  # Wait for final summary
+                if "final_summary" in coordinator.task_results:
+                    print("\n=== Final Summary ===")
+                    print(coordinator.task_results["final_summary"])
+                    print("\nAll tasks completed successfully. Shutting down...")
+                    break
+            await asyncio.sleep(1)
+    except KeyboardInterrupt:
+        print("Shutting down...")
+
+if __name__ == "__main__":
+    asyncio.run(main())

demos/network/multi_framework_example.py

@@ -0,0 +1,199 @@
+"""
+Example of using multiple agent frameworks together in a collaborative task.
+
+This example demonstrates how agents from Autogen, Langchain, CrewAI, and LangGraph
+can work together seamlessly through the MCP framework.
+"""
+
+import os
+import asyncio
+import openai
+from crewai import Agent as CrewAgent
+from langchain.tools import Tool
+from agent_mcp.enhanced_mcp_agent import EnhancedMCPAgent
+from agent_mcp.langchain_mcp_adapter import LangchainMCPAdapter
+from agent_mcp.crewai_mcp_adapter import CrewAIMCPAdapter
+from agent_mcp.langgraph_mcp_adapter import LangGraphMCPAdapter
+from agent_mcp.heterogeneous_group_chat import HeterogeneousGroupChat
+from agent_mcp.mcp_transport import HTTPTransport
+
+# Standard imports for Langchain
+from langchain_openai import ChatOpenAI
+from langchain_community.utilities.duckduckgo_search import DuckDuckGoSearchAPIWrapper
+from langchain.agents import AgentExecutor, OpenAIFunctionsAgent
+from langchain.schema.messages import SystemMessage
+
+# Check for OpenAI API key
+api_key = os.getenv("OPENAI_API_KEY")
+if not api_key:
+    raise ValueError("Please set the OPENAI_API_KEY environment variable")
+
+openai.api_key = api_key
+
+async def setup_langchain_agent():
+    """Setup a Langchain agent with search capabilities"""
+    search = DuckDuckGoSearchAPIWrapper()
+    search_tool = Tool(
+        name="duckduckgo_search",
+        description="Search the web using DuckDuckGo",
+        func=search.run
+    )
+    tools = [search_tool]
+    
+    llm = ChatOpenAI(temperature=0)
+    agent = OpenAIFunctionsAgent.from_llm_and_tools(
+        llm=llm,
+        tools=tools,
+        system_message=SystemMessage(content=(
+            "You are a research assistant that helps find information."
+        ))
+    )
+    
+    agent_executor = AgentExecutor.from_agent_and_tools(
+        agent=agent,
+        tools=tools,
+        verbose=True,
+        handle_parsing_errors=True
+    )
+    
+    return agent, agent_executor
+
+def setup_crewai_agent():
+    """Setup a CrewAI agent for analysis"""
+    return CrewAgent(
+        role="Data Analyst",
+        goal="Analyze and extract insights from research data",
+        backstory="You are an expert data analyst with experience in scientific research",
+        allow_delegation=False
+    )
+
+def setup_summary_tools():
+    """Setup tools for summarization"""
+    llm = ChatOpenAI(temperature=0)
+    
+    # Create a summarization tool
+    async def summarize(input: str) -> str:
+        """Summarize text in a clear and concise way"""
+        response = await llm.ainvoke(
+            "Summarize the following in a clear and concise way: " + input
+        )
+        return response.content
+        
+    summarize_tool = Tool(
+        name="summarize",
+        description="Summarize text in a clear and concise way",
+        func=summarize
+    )
+    
+    return [summarize_tool]
+
+async def create_worker_agents():
+    """Create agents from different frameworks"""
+    # Autogen worker for task coordination
+    autogen_worker = EnhancedMCPAgent(
+        name="AutogenWorker",
+        transport=HTTPTransport(host="localhost", port=8001),
+        client_mode=True,
+        system_message="I help coordinate tasks and integrate results",
+        llm_config={
+            "config_list": [{
+                "model": "gpt-3.5-turbo",
+                "api_key": api_key
+            }]
+        }
+    )
+    
+    # Langchain worker for research
+    langchain_agent, agent_executor = await setup_langchain_agent()
+    langchain_worker = LangchainMCPAdapter(
+        name="LangchainWorker",
+        transport=HTTPTransport(host="localhost", port=8002),
+        client_mode=True,
+        langchain_agent=langchain_agent,
+        agent_executor=agent_executor
+    )
+    
+    # CrewAI worker for analysis
+    crewai_agent = setup_crewai_agent()
+    crewai_worker = CrewAIMCPAdapter(
+        name="CrewAIWorker",
+        transport=HTTPTransport(host="localhost", port=8003),
+        client_mode=True,
+        crewai_agent=crewai_agent
+    )
+    
+    # LangGraph worker for summarization
+    summary_tools = setup_summary_tools()
+    langgraph_worker = LangGraphMCPAdapter(
+        name="LangGraphWorker",
+        transport=HTTPTransport(host="localhost", port=8004),
+        client_mode=True,
+        tools=summary_tools
+    )
+    
+    return [
+        autogen_worker,
+        langchain_worker,
+        crewai_worker,
+        langgraph_worker
+    ]
+
+async def main():
+    # Create the group chat
+    group = HeterogeneousGroupChat(
+        name="ResearchTeam",
+        server_url="https://mcp-server-ixlfhxquwq-ew.a.run.app"
+    )
+    
+    # Create and add the coordinator
+    coordinator = group.create_coordinator(api_key)
+    
+    # Create and add all worker agents
+    workers = await create_worker_agents()
+    group.add_agents(workers)
+    
+    # Connect all agents
+    await group.connect()
+    
+    # Define a collaborative research task
+    task = {
+        "task_id": "quantum_research",
+        "type": "collaborative_task",
+        "description": "Research and analyze quantum computing developments",
+        "steps": [
+            {
+                "agent": "LangchainWorker",
+                "task_id": "research",
+                "description": "Search for recent quantum computing breakthroughs in 2024",
+                "url": "https://mcp-server-ixlfhxquwq-ew.a.run.app"
+            },
+            {
+                "agent": "CrewAIWorker",
+                "task_id": "analysis",
+                "description": "Analyze the research findings and identify key trends and implications",
+                "url": "https://mcp-server-ixlfhxquwq-ew.a.run.app",
+                "depends_on": ["research"]
+            },
+            {
+                "agent": "AutogenWorker",
+                "task_id": "integration",
+                "description": "Integrate the research and analysis into a cohesive narrative",
+                "url": "https://mcp-server-ixlfhxquwq-ew.a.run.app",
+                "depends_on": ["analysis"]
+            },
+            {
+                "agent": "LangGraphWorker",
+                "task_id": "summary",
+                "description": "Create a final executive summary of all findings",
+                "url": "https://mcp-server-ixlfhxquwq-ew.a.run.app",
+                "depends_on": ["integration"]
+            }
+        ]
+    }
+    
+    # Submit task and wait for completion
+    await group.submit_task(task)
+    await group.wait_for_completion()
+
+if __name__ == "__main__":
+    asyncio.run(main())

demos/utils/check_imports.py

@@ -0,0 +1,49 @@
+"""
+Check Imports for MCPAgent Project.
+
+This script checks if all required dependencies for the MCPAgent project are available.
+"""
+
+import importlib
+import sys
+
+def check_import(module_name, display_name=None):
+    """Check if a module can be imported and print the result."""
+    if display_name is None:
+        display_name = module_name
+        
+    try:
+        module = importlib.import_module(module_name)
+        version = getattr(module, "__version__", "unknown version")
+        print(f"✓ {display_name} is available (version: {version})")
+        return True
+    except ImportError as e:
+        print(f"✗ {display_name} is NOT available: {e}")
+        return False
+
+def main():
+    """Check all required imports."""
+    print("=== Checking Required Dependencies ===\n")
+    
+    # Basic Python version check
+    python_version = ".".join(map(str, sys.version_info[:3]))
+    print(f"Python version: {python_version}")
+    
+    # Core dependencies
+    check_import("autogen", "AutoGen")
+    check_import("openai", "OpenAI API")
+    
+    # LangGraph dependencies
+    check_import("langchain_core", "LangChain Core")
+    check_import("langchain_openai", "LangChain OpenAI")
+    check_import("langgraph", "LangGraph")
+    
+    # Check our own modules
+    try:
+        import mcp_agent
+        print("✓ MCPAgent module is available")
+    except ImportError as e:
+        print(f"✗ MCPAgent module is NOT available: {e}")
+
+if __name__ == "__main__":
+    main()