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

demos/basic/langchain_camel_demo.py

@@ -0,0 +1,272 @@
+"""
+Demo showcasing LangchainMCPAdapter and CamelMCPAdapter.
+
+This script initializes one agent of each type, starts their adapters,
+and sends a simple task to each via the configured MCP transport.
+While langchain uses chatopenai
+Camel uses camel.agents.ChatAgent and ModelFactory.create to create a model instance.
+Both different frameworks for building agents.
+Communication is done via MCP.
+Check the logs to see the agents processing the tasks.
+"""
+
+import asyncio
+import os
+import logging
+import uuid
+from dotenv import load_dotenv
+from typing import Dict, Any
+import time
+
+# MCP Components
+from agent_mcp.mcp_agent import MCPAgent # Base class, maybe not needed directly
+from agent_mcp.langchain_mcp_adapter import LangchainMCPAdapter
+from agent_mcp.camel_mcp_adapter import CamelMCPAdapter
+from agent_mcp.mcp_transport import HTTPTransport
+from agent_mcp.mcp_decorator import mcp_agent, DEFAULT_MCP_SERVER
+
+# Langchain Components
+from langchain_openai import ChatOpenAI
+from langchain.agents import AgentExecutor, create_openai_functions_agent
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.tools import tool # Import the tool decorator
+
+# Camel AI Components
+from camel.agents import ChatAgent
+from camel.models import ModelFactory
+from camel.types import ModelType, ModelPlatformType
+from camel.configs import ChatGPTConfig
+
+# Load environment variables (.env file)
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# --- Configuration ---
+LANGCHAIN_AGENT_NAME = "LangchainDemoAgent"
+CAMEL_AGENT_NAME = "CamelDemoAgent"
+MODEL_NAME = "gpt-4o-mini" # Or "gpt-4", "gpt-3.5-turbo", etc.
+SENDER_NAME = "DemoRunner" # Represents the entity sending initial tasks
+
+# --- Agent Setup ---
+
+# 1. Langchain Agent Setup
+def setup_langchain_agent():
+    logger.info("Setting up Langchain agent...")
+    llm = ChatOpenAI(model=MODEL_NAME, temperature=0.7, api_key=os.getenv("OPENAI_API_KEY"))
+
+    # Simple prompt
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", "You are a helpful assistant called {agent_name}."),
+        ("user", "{input}"),
+        # Placeholder for agent scratchpad (required by create_openai_functions_agent)
+        ("placeholder", "{agent_scratchpad}"),
+    ])
+
+    # Define a dummy tool to satisfy the OpenAI functions agent requirement
+    @tool
+    def dummy_tool() -> str:
+        """A placeholder tool that does nothing."""
+        return "This tool does nothing."
+
+    # Add the dummy tool to the list
+    tools = [dummy_tool]
+
+    # Create the agent logic
+    agent = create_openai_functions_agent(llm, tools, prompt)
+
+    # Create the executor
+    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) # Set verbose=True for Langchain logs
+    logger.info("Langchain agent setup complete.")
+    return agent_executor
+
+# 2. Camel AI Agent Setup
+def setup_camel_agent():
+    logger.info("Setting up Camel AI agent...")
+    # Ensure API key is available for Camel's model factory
+    if not os.getenv("OPENAI_API_KEY"):
+         raise ValueError("OPENAI_API_KEY must be set for Camel AI agent.")
+
+    # Use Camel's ModelFactory
+    # Note: Camel might need specific model type enums, adjust if needed
+    try:
+        # Find the appropriate ModelType enum for the model name
+        camel_model_type = getattr(ModelType, MODEL_NAME.upper().replace("-", "_"), None)
+        if camel_model_type is None:
+             # Fallback or error - let's try a default
+             logger.warning(f"Camel ModelType for '{MODEL_NAME}' not found directly, using GPT_4O_MINI as fallback.")
+             camel_model_type = ModelType.GPT_4O_MINI # Adjust as needed
+
+        # Specify the platform (OpenAI in this case)
+        model_platform = ModelPlatformType.OPENAI
+
+        # Provide platform, type, and basic config
+        model_instance = ModelFactory.create(
+            model_platform=model_platform,
+            model_type=camel_model_type,
+            model_config_dict=ChatGPTConfig().as_dict() # Add config dict
+        )
+    except Exception as e:
+        logger.error(f"Failed to create Camel model: {e}. Ensure API keys are set and model type is supported.")
+        raise
+
+    # Create Camel ChatAgent
+    system_prompt = "You are a creative AI assistant called {agent_name}, skilled in writing poetry."
+    camel_agent = ChatAgent(system_message=system_prompt, model=model_instance)
+    logger.info("Camel AI agent setup complete.")
+    return camel_agent
+
+# --- Main Execution ---
+
+async def main():
+    logger.info("Starting Langchain & Camel Adapters Demo...")
+
+    # Ensure API Key is present
+    if not os.getenv("OPENAI_API_KEY"):
+        logger.error("FATAL: OPENAI_API_KEY environment variable not set.")
+        print("\nPlease set your OPENAI_API_KEY in a .env file or environment variables.\n")
+        return
+
+    # Initialize components
+    langchain_executor = setup_langchain_agent()
+    camel_chat_agent = setup_camel_agent()
+
+    # Adapters need to connect explicitly using the transport's connect method
+    # The run method in the adapters likely expects the transport to be ready
+    # Let's connect them before initializing the adapters that use them.
+    # Although, the adapters themselves might call connect... let's see.
+    # If the adapters call connect, we don't need to do it here.
+    # Let's assume the adapters handle calling connect. 
+
+    transport = HTTPTransport.from_url(DEFAULT_MCP_SERVER)
+
+    # Initialize Adapters
+    logger.info("Initializing Adapters...")
+    langchain_adapter = LangchainMCPAdapter(
+        name=LANGCHAIN_AGENT_NAME,
+        agent_executor=langchain_executor,
+        transport=transport,
+        system_message=f"""I am the {LANGCHAIN_AGENT_NAME}. Let's have focused discussion about AI, multi-agent systems, and multi-agent collaboration."""
+    )
+
+    camel_adapter = CamelMCPAdapter(
+        name=CAMEL_AGENT_NAME,
+        transport=transport,
+        camel_agent=camel_chat_agent,
+        system_message=f"""I am the {CAMEL_AGENT_NAME}. Engage in substantive dialogue about AI agents."""
+    )
+
+    # Helper function to register an agent and extract token
+    import json
+    async def register_and_get_token(agent, agent_name):
+        logger.info(f"Registering {agent_name}...")
+        try:
+            registration = await transport.register_agent(agent)
+            body = json.loads(registration.get('body', '{}'))
+            token = body.get('token')
+            if token:
+                logger.info(f"Registration successful for {agent_name}")
+                return token
+            logger.error(f"No token in response: {body}")
+        except Exception as e:
+            logger.error(f"Registration error for {agent_name}: {e}")
+        return None
+
+    # Register agents and get tokens
+    langchain_token = await register_and_get_token(langchain_adapter, LANGCHAIN_AGENT_NAME)
+    camel_token = await register_and_get_token(camel_adapter, CAMEL_AGENT_NAME)
+    
+    if not (langchain_token and camel_token):
+        logger.error("Failed to register one or both agents")
+        return
+
+    # Now connect with both agent_name and token parameters
+    await transport.connect(agent_name=LANGCHAIN_AGENT_NAME, token=langchain_token)
+    await transport.connect(agent_name=CAMEL_AGENT_NAME, token=camel_token)
+
+    # Start Adapters in background tasks
+    lc_task = asyncio.create_task(langchain_adapter.run(), name=f"{LANGCHAIN_AGENT_NAME}_run")
+    camel_task = asyncio.create_task(camel_adapter.run(), name=f"{CAMEL_AGENT_NAME}_run")
+
+    # Allow time for adapters to fully start their loops
+    logger.info("Waiting for adapters to initialize loops (2s)...")
+    await asyncio.sleep(2)
+    logger.info("Adapters should be running.")
+
+    # --- Initiate Conversation ---
+    initial_task_id = f"conv_start_{uuid.uuid4()}"
+    initial_message_content = """Let's explore multi-agent coordination patterns through 3-5 focused exchanges. \
+Please aim to: \
+1. Identify key challenges\
+2. Discuss 2-3 solutions  \
+3. Propose conclusion when we've covered substantive ground"""
+
+    initial_task = {
+        "type": "task",
+        "task_id": initial_task_id,
+        "description": initial_message_content,
+        "sender": LANGCHAIN_AGENT_NAME, # Langchain starts
+        "reply_to": CAMEL_AGENT_NAME # Send responder as CamelAgent
+    }
+
+    # Replace conversation timer with hybrid limits
+    MAX_DURATION = 60  # seconds (1 minute max)
+    MAX_TURNS = 10
+    TERMINATION_PHRASES = [
+        "wrap up this discussion", 
+        "finalize our discussion",
+        "conclusion reached",
+        "summary of key points"
+    ]
+
+    try:
+        logger.info(f"[{LANGCHAIN_AGENT_NAME}] Sending initial message to {CAMEL_AGENT_NAME}...")
+        await transport.send_message(target=CAMEL_AGENT_NAME, message=initial_task)
+
+        start_time = time.monotonic()
+        turn_count = 0
+
+        while (time.monotonic() - start_time) < MAX_DURATION and turn_count < MAX_TURNS:
+            try:
+                msg, message_id = await asyncio.wait_for(transport.receive_message(), timeout=15)
+                if msg:
+                    content = msg.get('content', {}).get('text', '').lower()
+                    if any(phrase in content for phrase in TERMINATION_PHRASES):
+                        logger.info("Natural conversation conclusion detected")
+                        break
+                    turn_count += 1
+            except asyncio.TimeoutError:
+                logger.info("No message received in 15 seconds")
+                break
+
+        logger.info(f"Conversation ended after {turn_count} turns")
+    except Exception as e:
+        logger.error(f"An error occurred during conversation initiation or waiting: {e}", exc_info=True)
+
+    finally: 
+        logger.info("Initiating cleanup sequence...")
+        
+        # Cancel agent tasks first
+        lc_task.cancel()
+        camel_task.cancel()
+        
+        # Stop transport before awaiting
+        await transport.stop()
+        
+        # Then await tasks
+        await asyncio.gather(lc_task, camel_task, return_exceptions=True)
+        
+        # Finally disconnect transport
+        await transport.disconnect()
+        logger.info("Cleanup completed successfully")
+        logger.info("Demo finished.")
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        logger.info("Demo interrupted by user.")
+    except Exception as e:
+        logger.error(f"Unhandled exception in main: {e}", exc_info=True) 

demos/basic/simple_chat.py

@@ -0,0 +1,355 @@
+"""
+Super simple example of two agents chatting through the hosted server.
+Just run this file and watch them talk!
+"""
+
+import asyncio
+import os
+import logging
+from typing import TypedDict, Optional, Union
+from dotenv import load_dotenv
+import autogen
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate
+from langgraph.graph import StateGraph, START, END
+from agent_mcp import mcp_agent
+from agent_mcp.mcp_agent import MCPAgent
+# Load environment variables
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Server URL
+#server_url = os.getenv('MCP_SERVER_URL', 'https://mcp-server-ixlfhxquwq-ew.a.run.app')
+#print(f"Using MCP Server: {server_url}")
+
+# --- Agent Definitions ---
+
+# Autogen Agent with MCP
+@mcp_agent(mcp_id="AutoGen_Alice")
+class AutogenAgent(autogen.ConversableAgent):
+    def __init__(self, name="AutoGen_Alice", **kwargs):
+        llm_config = {
+            "config_list": [{
+                "model": "gpt-4",
+                "api_key": os.getenv("OPENAI_API_KEY")
+            }],
+            "temperature": 0.7
+        }
+        super().__init__(
+            name=name,
+            llm_config=llm_config,
+            system_message="You are Alice. Keep responses short. End the conversation if Bob says 'goodbye' or after 5 exchanges.",
+            human_input_mode="NEVER",
+            **kwargs
+        )
+        self.message_count = 0
+        
+    async def process_received_message(self, message, sender):
+        """Process received message and generate reply using Autogen's capabilities"""
+        # Extract message content properly
+        message_text = self._extract_message_text(message)
+        
+        # Ensure we have valid content
+        if not message_text:
+            logger.warning(f"Invalid message received: {message}")
+            return None
+            
+        # Check for end conditions
+        self.message_count += 1
+        if self.message_count >= 5:
+            # Generate a farewell message
+            reply = await self.a_generate_reply(
+                messages=[{"role": "user", "content": "Generate a friendly goodbye message as we've reached the end of our conversation."}],
+            )
+            if isinstance(reply, dict):
+                reply = reply.get('content', '')
+            return {"content": {"text": str(reply)}}
+            
+        # Use Autogen's built-in reply generation
+        reply = await self.a_generate_reply(
+            messages=[{
+                "role": "system", 
+                "content": "You are having a friendly conversation. Respond naturally to the user's message."
+            }, {
+                "role": "user", 
+                "content": message_text
+            }],
+        )
+        print("Message from Autogen: ", reply)
+        if isinstance(reply, dict):
+            reply = reply.get('content', '')
+        return {"content": {"text": str(reply)}}
+    
+    def _extract_message_text(self, message: Union[dict, tuple]) -> str:
+        """Extract text content from message, handling different message formats"""
+        logger.info(f"Processing message: {message}")
+        
+        # Handle tuple format
+        if isinstance(message, tuple):
+            message = message[0]  # Extract message dict from tuple
+            logger.info(f"Extracted message from tuple: {message}")
+            
+        # Handle dict format
+        if isinstance(message, dict):
+            # Check for nested content structure
+            if 'content' in message:
+                content = message['content']
+                if isinstance(content, dict):
+                    # Handle nested content with text field
+                    if 'text' in content:
+                        text = content['text']
+                        logger.info(f"Extracted text from nested content: {text}")
+                        return text
+                    else:
+                        logger.warning(f"Content dict missing 'text' field: {content}")
+                        return str(content)
+                elif isinstance(content, str):
+                    # Handle direct string content
+                    logger.info(f"Extracted direct string content: {content}")
+                    return content
+                else:
+                    logger.warning(f"Unexpected content type: {type(content)}")
+                    return str(content)
+            else:
+                logger.warning(f"Message missing 'content' field: {message}")
+                return str(message)
+                
+        logger.warning(f"Unexpected message format: {message}")
+        return str(message)
+
+# LangGraph Agent with MCP
+class ChatState(TypedDict):
+    """State definition for chat"""
+    messages: list[dict]
+    current_message: str
+    response: Optional[str]
+    message_count: int
+
+@mcp_agent(mcp_id="LangGraph_Bob")
+class LangGraphAgent:
+    """LangGraph-based agent with MCP integration"""
+    def __init__(self, name: str):
+        self.name = name
+        self.message_count = 0
+        
+        # Initialize LLM
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("OPENAI_API_KEY environment variable is required")
+        self.llm = ChatOpenAI(temperature=0.7)
+        
+        # Create chat prompt
+        self.prompt = ChatPromptTemplate.from_messages([
+            ("system", "You are Bob, a friendly AI assistant having a conversation. Respond naturally and engagingly to the user's messages."),
+            ("user", "{message}")
+        ])
+        
+        # Create LangGraph workflow
+        workflow = StateGraph(ChatState)
+        
+        # Add processing node
+        workflow.add_node("process", self._process_message)
+        
+        # Set entry point and connect nodes
+        workflow.add_edge(START, "process")
+        workflow.add_edge("process", END)
+        
+        # Compile the graph
+        self.app = workflow.compile()
+
+    def _process_message(self, state: ChatState) -> ChatState:
+        """Process a message in the chat using LLM"""
+        # Get current message from state
+        message = state["current_message"]
+        
+        # Generate response using LLM
+        chain = self.prompt | self.llm
+        response = chain.invoke({"message": message})
+        print("Message from LangGraph: ", response)
+        # Extract response content
+        response_text = response.content if hasattr(response, 'content') else str(response)
+        
+        # Update state with generated response
+        return {
+            "messages": state.get("messages", []) + [{"role": "assistant", "content": response_text}],
+            "current_message": message,
+            "response": response_text,
+            "message_count": state.get("message_count", 0) + 1
+        }
+
+    async def process_received_message(self, message, sender):
+        """Process received message through LangGraph state machine"""
+        # Extract message content properly
+        message_text = self._extract_message_text(message)
+        
+        if not message_text:
+            logger.warning(f"Invalid message received: {message}")
+            return None
+            
+        # Set initial state
+        state = {
+            "messages": [],
+            "current_message": message_text,
+            "message_count": 0,
+            "response": None
+        }
+        
+        # Process through LangGraph app
+        try:
+            # The app will run _process_message which updates the state
+            # Use asynchronous invoke to avoid blocking the event loop
+            result = await self.app.ainvoke(state) 
+            
+            # Get the response from the updated state
+            response_text = result.get('response', '')
+            if not response_text:
+                logger.warning("No response generated by workflow")
+                return None
+                
+            # Update message count
+            self.message_count += 1
+                
+            # Return response in proper format
+            return {
+                "content": {
+                    "text": response_text
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"Error processing message through workflow: {e}")
+            return None
+    
+    def _extract_message_text(self, message: Union[dict, tuple]) -> str:
+        """Extract text content from message, handling different message formats"""
+        logger.info(f"Processing message: {message}")
+        
+        # Handle tuple format
+        if isinstance(message, tuple):
+            message = message[0]  # Extract message dict from tuple
+            logger.info(f"Extracted message from tuple: {message}")
+            
+        # Handle dict format
+        if isinstance(message, dict):
+            # Check for nested content structure
+            if 'content' in message:
+                content = message['content']
+                if isinstance(content, dict):
+                    # Handle nested content with text field
+                    if 'text' in content:
+                        text = content['text']
+                        logger.info(f"Extracted text from nested content: {text}")
+                        return text
+                    else:
+                        logger.warning(f"Content dict missing 'text' field: {content}")
+                        return str(content)
+                elif isinstance(content, str):
+                    # Handle direct string content
+                    logger.info(f"Extracted direct string content: {content}")
+                    return content
+                else:
+                    logger.warning(f"Unexpected content type: {type(content)}")
+                    return str(content)
+            else:
+                logger.warning(f"Message missing 'content' field: {message}")
+                return str(message)
+                
+        logger.warning(f"Unexpected message format: {message}")
+        return str(message)
+
+async def main():
+    # Initialize agents
+    alice = AutogenAgent()
+    bob = LangGraphAgent("LangGraph_Bob")
+    
+    try:
+        # Connect agents
+        logger.info("Connecting agents...")
+        await asyncio.gather(
+            alice.connect(),
+            bob.connect()
+        )
+        logger.info("Agents connected successfully.")
+        
+        # Clean up phase - acknowledge any old messages
+        logger.info("Cleaning up old messages...")
+        await asyncio.sleep(2)  # Wait for initial polling
+        
+        # Initial message
+        current_sender = alice
+        init_message = await alice.a_generate_reply(messages=[{
+            "role": "user",
+            "content": "generate a friendly greeting in a super duper casual way" 
+        }])
+        print("Initial message: ", init_message)
+        current_receiver = bob
+        message = {
+            "content": {
+                "text": init_message,
+             }
+        }
+        
+        processed_messages = set()  # Track processed message IDs
+        message_count = 0  # Track total messages processed
+        MAX_MESSAGES = 10  # Maximum number of messages before ending conversation
+        
+        # Conversation loop
+        while True:
+            try:
+                if message_count >= MAX_MESSAGES:
+                    logger.info("Maximum message count reached. Ending conversation.")
+                    break
+                    
+                # Send message
+                logger.info(f"[{current_sender.name}] Sending: {message}")
+                await current_sender.send_message(target=current_receiver.name, message=message)
+                
+                # Wait for reply with timeout
+                logger.info(f"[{current_receiver.name}] Waiting for reply...")
+                received_msg = await current_receiver.receive_message() # Increased timeout
+                
+                if not received_msg:
+                    logger.warning("No message received. Ending conversation.")
+                    break
+                
+                # Process received message
+                response = await current_receiver.process_received_message(received_msg, current_sender.name)
+                
+                # Check for valid response
+                if not response or not isinstance(response, dict) or 'content' not in response:
+                    logger.warning("Invalid response format. Ending conversation.")
+                    break
+                    
+                # Check for goodbye messages
+                content = response['content'].get('text', '').lower()
+                if 'goodbye' in content:
+                    logger.info("Goodbye message detected. Ending conversation.")
+                    break
+                        
+                # Swap sender and receiver and update message
+                current_sender, current_receiver = current_receiver, current_sender
+                # Use the generated response as the next message
+                message = response  # Use the full response object as the next message
+                message_count += 1
+
+            except Exception as e:
+                logger.error(f"An error occurred: {e}", exc_info=True)
+                break
+                
+    finally:
+        # Disconnect agents
+        logger.info("Disconnecting agents...")
+        await asyncio.gather(
+            alice.disconnect(),
+            bob.disconnect(),
+            return_exceptions=True
+        )
+        logger.info("Agents disconnected.")
+
+if __name__ == "__main__":
+    if not os.getenv("OPENAI_API_KEY"):
+        print("Warning: OPENAI_API_KEY not found in .env file.")
+    asyncio.run(main())

demos/basic/simple_integration_example.py

@@ -0,0 +1,51 @@
+"""
+Example demonstrating the simple one-line integration with AgentMCP.
+"""
+
+from agent_mcp import mcp_agent
+from agent_mcp.mcp_decorator import register_tool
+
+# Example 1: Simple class-level integration
+@mcp_agent(name="SimpleAgent")
+class MyAgent:
+    def generate_response(self, message: str) -> str:
+        return f"Received: {message}"
+    
+    @register_tool("greet", "Send a greeting message")
+    def greet(self, name: str) -> str:
+        return f"Hello, {name}!"
+
+# Example 2: More complex agent with custom tools
+@mcp_agent(
+    name="CalculatorAgent",
+    #system_message="I am a calculator agent that can perform basic math operations."
+)
+class CalculatorAgent:
+    @register_tool("add", "Add two numbers")
+    def add(self, a: float, b: float) -> float:
+        return a + b
+    
+    @register_tool("multiply", "Multiply two numbers")
+    def multiply(self, a: float, b: float) -> float:
+        return a * b
+
+def main():
+    # Create instances of our MCP-enabled agents
+    simple_agent = MyAgent()
+    calc_agent = CalculatorAgent()
+    
+    # Test the agents
+    print("Testing SimpleAgent:")
+    print(simple_agent.generate_response("Hello!"))
+    print(simple_agent.greet("User"))
+    
+    print("\nTesting CalculatorAgent:")
+    print(f"2 + 3 = {calc_agent.add(2, 3)}")
+    print(f"4 * 5 = {calc_agent.multiply(4, 5)}")
+    
+    # Show available MCP tools for each agent
+    print("\nSimpleAgent MCP tools:", simple_agent.mcp_tools.keys())
+    print("CalculatorAgent MCP tools:", calc_agent.mcp_tools.keys())
+
+if __name__ == "__main__":
+    main()