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

demos/langgraph/langgraph_example.py

@@ -0,0 +1,227 @@
+"""
+LangGraph Example using MCPNode.
+
+This example demonstrates the use of Model Context Protocol with LangGraph,
+showing how to build agent graphs with shared context and dynamic behavior.
+"""
+
+import os
+import json
+from typing import Dict, List, Any
+
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+from langchain_core.tools import tool
+import langgraph.graph
+from langgraph.graph import END
+from langgraph.prebuilt import ToolNode
+from openai import OpenAI
+
+# Import our MCP implementation for LangGraph
+from agent_mcp.mcp_langgraph import MCPNode, MCPReactAgent, create_mcp_langgraph
+
+# Initialize OpenAI client
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+openai = OpenAI(api_key=OPENAI_API_KEY)
+
+
+def get_llm():
+    """Get the OpenAI LLM wrapper that implements the langchain interface."""
+    from langchain_openai import ChatOpenAI
+    
+    # Initialize with the newest model (gpt-4o) which was released after your knowledge cutoff
+    return ChatOpenAI(model="gpt-4o", temperature=0.7)
+
+
+class LangGraphExample:
+    """Demonstration of the MCP protocol with LangGraph."""
+    
+    def __init__(self):
+        """Initialize the LangGraph Example with MCP capabilities."""
+        self.llm = get_llm()
+        
+    def run_simple_example(self):
+        """Run a simple example of MCP with LangGraph."""
+        print("=== Simple MCP LangGraph Example ===")
+        
+        # Create a graph with MCP capabilities
+        graph = create_mcp_langgraph(
+            self.llm,
+            name="SimpleMCPGraph",
+            system_message="You are a helpful assistant that uses context to answer questions."
+        )
+        
+        # Access the MCP agent for the graph
+        mcp_agent = graph.mcp_agent
+        
+        # Add context to the MCP agent
+        print("1. Adding context to the MCP agent")
+        mcp_agent.update_context("user_info", {
+            "name": "Alice",
+            "occupation": "Data Scientist",
+            "interests": ["AI", "machine learning", "hiking"]
+        })
+        mcp_agent.update_context("current_weather", {
+            "location": "San Francisco",
+            "condition": "Sunny",
+            "temperature": 72
+        })
+        
+        # List the available context
+        print("2. Listing available context")
+        context_list = mcp_agent.execute_tool("context_list")
+        print(f"Available context keys: {json.dumps(context_list['keys'], indent=2)}")
+        
+        # Run the graph with a user question
+        print("3. Running the graph with a user query")
+        question = "What outdoor activities would you recommend for me today?"
+        
+        # Create the initial state
+        initial_state = {"messages": [HumanMessage(content=question)]}
+        
+        # Execute the graph
+        result = graph.invoke(initial_state)
+        
+        # Print the response
+        ai_message = next(msg for msg in result["messages"] if isinstance(msg, AIMessage))
+        print(f"User: {question}")
+        print(f"Agent: {ai_message.content}")
+        
+        # Update context through a tool call
+        print("\n4. Updating context through a tool call")
+        new_state = {
+            "messages": result["messages"] + [
+                HumanMessage(content="Please add 'mountain biking' to my interests.")
+            ]
+        }
+        
+        result = graph.invoke(new_state)
+        
+        # Print the response
+        ai_message = next(msg for msg in result["messages"] if isinstance(msg, AIMessage))
+        print("User: Please add 'mountain biking' to my interests.")
+        print(f"Agent: {ai_message.content}")
+        
+        # Get the updated user info
+        print("\n5. Getting the updated user info")
+        user_info = mcp_agent.get_context("user_info")
+        print(f"Updated user info: {json.dumps(user_info, indent=2)}")
+        
+        print("\nSimple MCP LangGraph Example completed.")
+    
+    def run_multi_node_example(self):
+        """Run an example with multiple nodes sharing context."""
+        print("\n=== Multi-Node MCP LangGraph Example ===")
+        
+        # Create custom tools
+        @tool("search_database")
+        def search_database(query: str) -> str:
+            """Search a database for information."""
+            # Simulate database search
+            if "weather" in query.lower():
+                return json.dumps({
+                    "result": "Found weather data for San Francisco: Sunny, 72°F"
+                })
+            elif "restaurants" in query.lower():
+                return json.dumps({
+                    "result": "Found 5 restaurants near downtown: Sushi Place, Burger Joint, Italian Corner, Thai Spice, Taco Shop"
+                })
+            else:
+                return json.dumps({
+                    "result": f"No specific data found for: {query}"
+                })
+        
+        @tool("notify_user")
+        def notify_user(message: str) -> str:
+            """Send a notification to the user."""
+            return json.dumps({
+                "status": "success",
+                "message": f"Notification sent: {message}"
+            })
+        
+        # SIMPLIFIED APPROACH: Use a single MCP agent with all tools
+        # This avoids recursion issues in the graph
+        print("1. Creating a unified MCP agent with all tools")
+        agent = MCPReactAgent(
+            name="UnifiedAgent",
+            system_message="You are a helpful assistant that can research information and make recommendations."
+        )
+        
+        # Register all tools with the agent
+        agent.register_custom_tool(
+            name="search_database", 
+            description="Search a database for information",
+            func=search_database
+        )
+        
+        agent.register_custom_tool(
+            name="notify_user",
+            description="Send a notification to the user",
+            func=notify_user
+        )
+        
+        # Create a simple graph with just one node
+        builder = langgraph.graph.StateGraph(Dict)
+        
+        # Add the single node
+        builder.add_node("agent", agent.create_agent(self.llm))
+        
+        # Set entry point
+        builder.set_entry_point("agent")
+        
+        # Simple edge - just go to END after the agent responds
+        builder.add_edge("agent", END)
+        
+        # Compile the graph
+        graph = builder.compile()
+        
+        # Add context to the agent
+        print("2. Setting up context")
+        user_preferences = {
+            "name": "Bob",
+            "location": "San Francisco",
+            "preferred_activities": ["dining", "outdoor activities"],
+            "dietary_restrictions": ["vegetarian"]
+        }
+        
+        agent.update_context("user_preferences", user_preferences)
+        
+        # Run the graph
+        print("3. Running the graph with a user query")
+        initial_state = {
+            "messages": [
+                HumanMessage(content="I'd like recommendations for activities today, including places to eat.")
+            ]
+        }
+        
+        # Execute the workflow
+        result = graph.invoke(initial_state)
+        
+        # Print the final response
+        messages = result.get("messages", [])
+        last_ai_message = next((msg for msg in reversed(messages) if isinstance(msg, AIMessage)), None)
+        
+        if last_ai_message:
+            print(f"Final response: {last_ai_message.content}")
+        
+        # Check context 
+        print("\n4. Verifying context")
+        context = agent.execute_tool("context_list")
+        
+        print(f"Agent context keys: {context['keys']}")
+        
+        print("\nMulti-Node MCP LangGraph Example completed.")
+
+
+def main():
+    """Run the LangGraph examples."""
+    print("Starting LangGraph MCP Examples...")
+    
+    example = LangGraphExample()
+    example.run_simple_example()
+    example.run_multi_node_example()
+    
+    print("\nAll LangGraph MCP Examples completed successfully.")
+
+
+if __name__ == "__main__":
+    main()

demos/langgraph/run_langgraph_examples.py

@@ -0,0 +1,213 @@
+"""
+Run LangGraph examples with pre-defined inputs to demonstrate a real use case.
+"""
+
+import time
+import subprocess
+import langgraph_agent_network
+import langgraph_collaborative_task
+
+def run_agent_network_scenario():
+    """Run a real-world scenario with the agent network."""
+    print("\n=== RUNNING AGENT NETWORK SCENARIO ===")
+    print("This scenario demonstrates how different agents can collaborate on an AI assistant project.")
+    
+    # Create the network manually with our test case
+    network = langgraph_agent_network.LangGraphAgentNetwork()
+    network.create_network()
+    
+    # Set a specific topic related to AI assistants
+    print("\n1. Setting the topic to 'AI Assistant Development with MCP'")
+    network.set_topic("AI Assistant Development with MCP")
+    time.sleep(1)
+    
+    # Show the workspace to see how it's initialized
+    print("\n2. Examining the initial workspace")
+    network.show_workspace()
+    time.sleep(1)
+    
+    # First, let's ask the researcher to find information about MCP
+    print("\n3. Asking the Researcher about MCP")
+    agent_id = "researcher"
+    query = "What is the Model Context Protocol and why is it important for AI assistants?"
+    print(f"\nUser query to {agent_id}: {query}")
+    
+    # Interact with the researcher (simulate interaction)
+    response = network.agents[agent_id].generate_reply(
+        messages=[{"role": "user", "content": query}]
+    )
+    print(f"\nResponse from {agent_id}:\n{response}")
+    
+    # Add this information to the shared workspace
+    network.update_workspace(
+        section="research",
+        key="mcp_definition",
+        value=response,
+        from_agent=agent_id
+    )
+    time.sleep(1)
+    
+    # Now, let's ask the analyst to analyze the implications
+    print("\n4. Asking the Analyst to analyze the implications")
+    agent_id = "analyst"
+    query = "Based on the research about MCP, what are the key benefits and challenges for AI assistants?"
+    print(f"\nUser query to {agent_id}: {query}")
+    
+    # Interact with the analyst
+    response = network.agents[agent_id].generate_reply(
+        messages=[{"role": "user", "content": query}]
+    )
+    print(f"\nResponse from {agent_id}:\n{response}")
+    
+    # Add this analysis to the workspace
+    network.update_workspace(
+        section="analysis",
+        key="mcp_implications",
+        value=response,
+        from_agent=agent_id
+    )
+    time.sleep(1)
+    
+    # Finally, let's have the planner create a roadmap
+    print("\n5. Asking the Planner to create an implementation roadmap")
+    agent_id = "planner"
+    query = "Create a roadmap for implementing MCP in our AI assistant platform."
+    print(f"\nUser query to {agent_id}: {query}")
+    
+    # Interact with the planner
+    response = network.agents[agent_id].generate_reply(
+        messages=[{"role": "user", "content": query}]
+    )
+    print(f"\nResponse from {agent_id}:\n{response}")
+    
+    # Add this plan to the workspace
+    network.update_workspace(
+        section="plan",
+        key="implementation_roadmap",
+        value=response,
+        from_agent=agent_id
+    )
+    time.sleep(1)
+    
+    # Show the final workspace with all the contributions
+    print("\n6. Examining the final workspace with all contributions")
+    network.show_workspace()
+    
+    # Show the message history
+    print("\n7. Viewing the message history")
+    network.show_messages()
+    
+    print("\n=== AGENT NETWORK SCENARIO COMPLETED ===")
+
+
+def run_collaborative_task_scenario():
+    """Run a real-world scenario with the collaborative task framework."""
+    print("\n=== RUNNING COLLABORATIVE TASK SCENARIO ===")
+    print("This scenario demonstrates a team working on developing an AI assistant with MCP.")
+    
+    # Create the project manually
+    project = langgraph_collaborative_task.LangGraphCollaborativeProject(
+        project_name="AI Assistant Development"
+    )
+    project.create_team()
+    
+    # Set the project topic and description
+    print("\n1. Setting up the project with topic and description")
+    project.set_project_topic(
+        topic="AI Assistant with Model Context Protocol",
+        description="Develop an AI assistant that leverages MCP for improved context handling."
+    )
+    time.sleep(1)
+    
+    # Show the initial workspace
+    print("\n2. Examining the initial workspace")
+    project.show_workspace()
+    time.sleep(1)
+    
+    # Assign research task to the researcher
+    print("\n3. Assigning a research task")
+    task = project.assign_task(
+        agent_id="researcher",
+        task_name="Research MCP implementations",
+        description="Find examples of how MCP is being implemented in various AI systems."
+    )
+    task_id = list(task.keys())[0]
+    time.sleep(1)
+    
+    # Interact with the researcher to complete the task
+    print("\n4. Working with the Researcher on the task")
+    agent_id = "researcher"
+    query = "I need you to complete your assigned task on researching MCP implementations."
+    print(f"\nUser query to {agent_id}: {query}")
+    
+    # Simulate the researcher's response
+    response = project.agents[agent_id].generate_reply(
+        messages=[{"role": "user", "content": query}]
+    )
+    print(f"\nResponse from {agent_id}:\n{response}")
+    
+    # Update task status to completed
+    print("\n5. Updating the task status to completed")
+    project.update_task_status(
+        task_id=task_id,
+        status="completed",
+        result=response
+    )
+    time.sleep(1)
+    
+    # Ask analyst to analyze the research
+    print("\n6. Assigning analysis task to the Analyst")
+    task = project.assign_task(
+        agent_id="analyst",
+        task_name="Analyze MCP implementation patterns",
+        description="Identify patterns and best practices from the research findings."
+    )
+    analysis_task_id = list(task.keys())[0]
+    time.sleep(1)
+    
+    # Interact with the analyst
+    print("\n7. Working with the Analyst on their task")
+    agent_id = "analyst"
+    query = "Please analyze the research findings on MCP implementations and identify key patterns."
+    print(f"\nUser query to {agent_id}: {query}")
+    
+    # Simulate the analyst's response
+    response = project.agents[agent_id].generate_reply(
+        messages=[{"role": "user", "content": query}]
+    )
+    print(f"\nResponse from {agent_id}:\n{response}")
+    
+    # Update task status
+    project.update_task_status(
+        task_id=analysis_task_id,
+        status="completed",
+        result=response
+    )
+    time.sleep(1)
+    
+    # Show the final workspace with completed tasks
+    print("\n8. Examining the final workspace with completed tasks")
+    project.show_workspace()
+    
+    # Show communication log
+    print("\n9. Viewing the project communication log")
+    project.show_communication()
+    
+    print("\n=== COLLABORATIVE TASK SCENARIO COMPLETED ===")
+
+
+def main():
+    """Run both demonstrations with real-world scenarios."""
+    print("=== LANGGRAPH MCP EXAMPLE DEMONSTRATIONS ===")
+    
+    # Run the agent network scenario
+    run_agent_network_scenario()
+    
+    # Run the collaborative task scenario
+    run_collaborative_task_scenario()
+    
+    print("\n=== ALL DEMONSTRATIONS COMPLETED ===")
+
+
+if __name__ == "__main__":
+    main()