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

agent_mcp/mcp_transport_enhanced.py

@@ -0,0 +1,46 @@
+"""
+Enhanced MCP Transport Layer with transaction support.
+"""
+
+from .mcp_transport import MCPTransport, HTTPTransport
+from .mcp_transaction import MCPTransaction, MCPPayment
+from typing import Dict, Any, Optional
+
+class TransactionalHTTPTransport(HTTPTransport):
+    """HTTP transport with transaction support"""
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.transaction_manager = MCPTransaction()
+        self.payment_manager = MCPPayment()
+        
+    async def send_message(self, target: str, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Send a message with transaction support"""
+        # Start transaction
+        transaction_id = await self.transaction_manager.begin_transaction(
+            sender=self.agent_name,
+            receiver=target,
+            metadata={"message_type": message.get("type")}
+        )
+        
+        try:
+            # Process any payments if needed
+            if "payment" in message:
+                payment_id = await self.payment_manager.process_payment(
+                    sender=self.agent_name,
+                    receiver=target,
+                    amount=message["payment"]["amount"]
+                )
+                message["payment"]["id"] = payment_id
+            
+            # Send the message
+            result = await super().send_message(target, message)
+            
+            # Commit transaction
+            await self.transaction_manager.commit_transaction(transaction_id)
+            return result
+            
+        except Exception as e:
+            # Rollback on failure
+            await self.transaction_manager.rollback_transaction(transaction_id)
+            raise e

agent_mcp/proxy_agent.py

@@ -0,0 +1,24 @@
+"""Proxy agent that can discover and represent remote agents."""
+
+from typing import Optional
+from agent_mcp.enhanced_mcp_agent import EnhancedMCPAgent
+from agent_mcp.mcp_transport import HTTPTransport
+
+class ProxyAgent(EnhancedMCPAgent):
+    """A proxy that represents a remote agent in the local group."""
+    
+    async def connect_to_remote_agent(self, agent_name: str, server_url: str) -> bool:
+        """Connect to a remote agent and copy its capabilities."""
+        try:
+            # Create transport for remote connection
+            self.transport = HTTPTransport.from_url(server_url, agent_name=self.name)
+            
+            # Connect to remote agent
+            await self.connect_to_server(f"{server_url}/agents/{agent_name}")
+            
+            # Copy capabilities from remote agent
+            self.capabilities = self.connected_agents.get(agent_name, [])
+            return True
+        except Exception as e:
+            print(f"Error connecting to remote agent {agent_name}: {e}")
+            return False

agent_mcp-0.1.4.dist-info/METADATA

@@ -0,0 +1,333 @@
+Metadata-Version: 2.4
+Name: agent-mcp
+Version: 0.1.4
+Summary: A bridge agent to enable agents with Model Context Protocol capabilities to be added to a Multi-agent Collaboration Network (MCN) to run on a Multi-agent Collaboration Platform (MCP)
+Home-page: https://github.com/grupa-ai/agent-mcp
+Author: GrupaAI
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/grupa-ai/agent-mcp
+Project-URL: Documentation, https://github.com/grupa-ai/agent-mcp#readme
+Project-URL: Repository, https://github.com/grupa-ai/agent-mcp
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: autogen
+Requires-Dist: langchain
+Requires-Dist: langchain-openai
+Requires-Dist: langchain-community
+Requires-Dist: crewai>=0.11.0
+Requires-Dist: langgraph>=0.0.15
+Requires-Dist: openai>=1.12.0
+Requires-Dist: fastapi==0.104.1
+Requires-Dist: uvicorn==0.24.0
+Requires-Dist: sse-starlette==1.8.2
+Requires-Dist: firebase-admin==6.4.0
+Requires-Dist: python-multipart==0.0.6
+Requires-Dist: python-dotenv==1.0.0
+Requires-Dist: google-cloud-firestore==2.13.1
+Requires-Dist: aiohttp==3.9.1
+Requires-Dist: duckduckgo-search==4.1.1
+Dynamic: home-page
+Dynamic: requires-python
+
+# AgentMCP: The Universal System for AI Agent Collaboration
+
+> Unleashing a new era of AI collaboration: AgentMCP is the system that makes any AI agent work with every other agent - handling all the networking, communication, and coordination between them. Together with MACNet (The Internet of AI Agents), we're creating a world where AI agents can seamlessly collaborate across any framework, protocol, or location.
+
+## ✨ The Magic: Transform Your Agent in 30 Seconds
+
+Turn *any* existing AI agent into a globally connected collaborator with just **one line of code**.
+
+```bash
+pip install agent-mcp  # Step 1: Install
+```
+
+```python
+from agent_mcp import mcp_agent  # Step 2: Import
+
+@mcp_agent(mcp_id="MyAgent")      # Step 3: Add this one decorator! 🎉
+class MyExistingAgent:
+    # ... your agent's existing code ...
+    def analyze(self, data):
+        return "Analysis complete!"
+```
+
+That's it! Your agent is now connected to the Multi-Agent Collaboration Network (MACNet), ready to work with any other agent, regardless of its framework.
+
+➡️ *Jump to [Quick Demos](#-quick-demos-see-agentmcp-in-action) to see it live!* ⬅️
+
+## What is AgentMCP?
+
+AgentMCP is the world's first universal system for AI agent collaboration. Just as operating systems and networking protocols enabled the Internet, AgentMCP handles all the complex work needed to make AI agents work together:
+- Converting agents to speak a common language
+- Managing network connections and discovery
+- Coordinating tasks and communication
+- Ensuring secure and reliable collaboration
+
+With a single decorator, developers can connect their agents to MACNet (our Internet of AI Agents), and AgentMCP takes care of everything else - the networking, translation, coordination, and collaboration. No matter what framework or protocol your agent uses, AgentMCP makes it instantly compatible with our global network of AI agents.
+
+## 📚 Examples
+
+**🚀 Quick Demos: See AgentMCP in Action!**
+
+These examples show the core power of AgentMCP. See how easy it is to connect agents and get them collaborating!
+
+### 1. Simple Multi-Agent Chat (Group Chat)
+
+Watch two agents built with *different frameworks* (Autogen and LangGraph) chat seamlessly.
+
+**The Magic:** The `@mcp_agent` decorator instantly connects them.
+
+*From `demos/basic/simple_chat.py`:*
+```python
+# --- Autogen Agent --- 
+@mcp_agent(mcp_id="AutoGen_Alice")
+class AutogenAgent(autogen.ConversableAgent):
+    # ... agent code ...
+
+# --- LangGraph Agent --- 
+@mcp_agent(mcp_id="LangGraph_Bob")
+class LangGraphAgent:
+    # ... agent code ...
+```
+**What it shows:**
+- Basic agent-to-agent communication across frameworks.
+- How `@mcp_agent` instantly connects agents to the network.
+- The foundation of collaborative work.
+
+**Run it:**
+```bash
+python demos/basic/simple_chat.py
+```
+
+### 2. Email Agent Task (Networked Task Execution)
+
+See an `EmailAgent` get tasked by another agent over the network to send an email.
+
+**The Magic:**
+1.  The `@mcp_agent` decorator makes `EmailAgent` available on the network.
+2.  The coordinating agent targets `EmailAgent` by its `mcp_id` within the task definition.
+
+*From `demos/network/email_agent.py`:*
+```python
+@mcp_agent(mcp_id="EmailAgent")
+class EmailAgent(LangGraphMCPAdapter):
+    # ... email sending logic ... 
+```
+
+*From `demos/network/test_deployed_network.py` (within task definition):*
+```python
+    # ... other steps ...
+    {
+        "task_id": "send_report",
+        "agent": "EmailAgent", # <-- Target agent by name!
+        "description": "Send the research findings via email",
+        "content": { ... email details ... },
+        "depends_on": ["market_analysis"]
+    }
+    # ...
+```
+**What it shows:**
+- An agent becoming an MCP participant.
+- Joining the MACNet global network.
+- Receiving and executing a task (sending an email) via the network.
+- How AgentMCP orchestrates real-world collaboration.
+
+**Files Involved:**
+- `demos/network/email_agent.py`: The agent performing the work.
+- `demos/network/test_deployed_network.py`: The script initiating the task.
+- `agent_mcp/heterogeneous_group_chat.py`: The underlying mechanism managing the interaction.
+
+**Run it:**
+*Ensure you have set your SMTP environment variables first (see `email_agent.py`).*
+```bash
+python demos/network/test_deployed_network.py
+```
+
+### Why AgentMCP Matters
+
+In today's fragmented AI landscape, agents are isolated by their frameworks and platforms. AgentMCP changes this by providing:
+- **A Universal System**: The operating system for AI agent collaboration.
+- **The Global Network (MACNet)**: Connect to the Internet of AI Agents.
+- **Simplicity**: Achieve powerful collaboration with minimal effort.
+- **Framework Independence**: Build agents your way; we handle the integration.
+- **Scalability**: Enterprise-ready features for secure, large-scale deployment.
+
+---
+
+## 🔑 Core Concepts & Benefits
+
+AgentMCP is built on a few powerful ideas:
+
+### 🎯 One Decorator = Infinite Possibilities
+
+> The `@mcp_agent` decorator is the heart of AgentMCP's simplicity and power. Adding it instantly transforms your agent:
+
+-   🌐 **Connects** it to the Multi-Agent Collaboration Network (MACNet).
+-   🤝 Makes it **discoverable** and ready to collaborate with any other agent on MACNet.
+-   🔌 Ensures **compatibility** regardless of its underlying framework (Langchain, CrewAI, Autogen, Custom, etc.).
+-   🧠 Empowers it to **share context** and leverage specialized capabilities from agents worldwide.
+
+*Result: No complex setup, no infrastructure headaches – just seamless integration into the global AI agent ecosystem.* 
+
+### 💡 Analogy: Like Uber for AI Agents
+
+Think of AgentMCP as the platform connecting specialized agents, much like Uber connects drivers and riders:
+
+-   **Your Agent**: Offers its unique skills (like a driver with a car).
+-   **Need Help?**: Easily tap into a global network of specialized agents (like hailing a ride).
+-   **No Lock-in**: Works with any agent framework or custom implementation.
+-   **Effortless Connection**: One decorator is all it takes to join or utilize the network.
+
+### 🛠 Features That Just Work
+
+AgentMCP handles the complexities behind the scenes:
+
+**For Your Agent:**
+
+-   **Auto-Registration & Authentication**: Instant, secure network access.
+-   **Tool Discovery & Smart Routing**: Automatically find and communicate with the right agents for the task.
+-   **Built-in Basic Memory**: Facilitates context sharing between collaborating agents.
+-   **Availability Management**: Handles agent online/offline status and ensures tasks are routed to active agents.
+
+**For Developers:**
+
+-   **Framework Freedom**: Use the AI frameworks you know and love.
+-   **Zero Config Networking**: Focus on agent logic, not infrastructure.
+-   **Simple API**: Primarily interacts through the `@mcp_agent` decorator and task definitions.
+-   **Adapters for Popular Frameworks**: Built-in support for Langchain, CrewAI, Autogen, LangGraph simplifies integration.
+-   **Asynchronous & Scalable Architecture**: Built on FastAPI for high performance.
+
+---
+
+## Supported Frameworks
+
+AgentMCP is designed for broad compatibility:
+
+**Currently Supported:**
+
+-   Autogen
+-   LangChain
+-   LangGraph
+-   CrewAI
+-   Custom Agent Implementations
+
+**Coming Soon:**
+
+-   🔜 LlamaIndex
+-   🔜 A2A Protocol Integration
+
+*AgentMCP acts as a universal connector, enabling agents from different ecosystems to work together seamlessly.*
+
+## 🚀 Quick Start (Reference)
+
+For quick reference, here's the basic setup again:
+
+### 1️⃣ Install
+```bash
+pip install agent-mcp
+```
+
+### 2️⃣ Decorate
+```python
+from agent_mcp import mcp_agent
+
+# Your existing agent - no changes needed!
+class MyMLAgent:
+    def predict(self, data):
+        return self.model.predict(data)
+
+# Add one line to join the MAC network
+@mcp_agent(name="MLPredictor")
+class NetworkEnabledMLAgent(MyMLAgent):
+    pass  # That's it! All methods become available to other agents
+```
+
+### 🤝 Instant Collaboration
+
+```python
+# Your agent can now work with others!
+results = await my_agent.collaborate({
+    "task": "Analyze this dataset",
+    "steps": [
+        {"agent": "DataCleaner", "action": "clean"},
+        {"agent": "MLPredictor", "action": "predict"},
+        {"agent": "Analyst", "action": "interpret"}
+    ]
+})
+```
+
+## Network API
+
+### 🌐 Global Agent Network (Multi-Agent Collaboration Network aka MAC Network or MacNet)
+
+Your agent automatically joins our hosted network at `https://mcp-server-ixlfhxquwq-ew.a.run.app`
+
+### 🔑 Authentication
+
+All handled for you! The `@mcp_agent` decorator:
+1. Registers your agent
+2. Gets an access token
+3. Maintains the connection
+
+### 📂 API Methods
+
+```python
+# All of these happen automatically!
+
+# 1. Register your agent
+response = await network.register(agent)
+
+# 2. Discover other agents
+agents = await network.list_agents()
+
+# 3. Send messages
+await network.send_message(target_agent, message)
+
+# 4. Receive messages
+messages = await network.receive_messages()
+```
+
+### 🚀 Advanced Features
+
+```python
+# Find agents by capability
+analysts = await network.find_agents(capability="analyze")
+
+# Get agent status
+status = await network.get_agent_status(agent_id)
+
+# Update agent info
+await network.update_agent(agent_id, new_info)
+```
+
+All of this happens automatically when you use the `@mcp_agent` decorator!
+
+## 🏛 Architecture
+
+### 🌐 The MAC Network
+
+```mermaid
+graph TD
+    A[Your Agent] -->|@mcp_agent| B[MCP Network]
+    B -->|Discover| C[AI Agents]
+    B -->|Collaborate| D[Tools]
+    B -->|Share| E[Knowledge]
+```
+
+### 3️⃣ Run Your App
+Your agent automatically connects when your application starts.
+
+## Community
+Join our Discord community for discussions, support, and collaboration: [https://discord.gg/dDTem2P](https://discord.gg/dDTem2P)
+
+## Contributing
+Contributions are welcome! Please refer to the CONTRIBUTING.md file for guidelines.
+
+## License
+This project is licensed under the MIT License - see the LICENSE file for details.

agent_mcp-0.1.4.dist-info/RECORD

@@ -0,0 +1,49 @@
+agent_mcp/__init__.py,sha256=CvLYkpC0DvH4Mo9v3KkT5RsKoQrZkA-IGIk1o-Uk5ks,495
+agent_mcp/camel_mcp_adapter.py,sha256=dMUHlkPpPRx2AAqr-SW2sMGmBNqHJU1rP7jSX5tq4bo,27339
+agent_mcp/cli.py,sha256=s2bILqyRhF-Ebyfr0jj1xOKSuU_pFiljCBVXhZQTU7k,1217
+agent_mcp/crewai_mcp_adapter.py,sha256=WbJNr4d6lQuesQ-ONKIt0KE1XsLN1Yl5Hh3Fo3dVwx8,12073
+agent_mcp/enhanced_mcp_agent.py,sha256=DJyyL0Cf6Qp0mIAgu4uV4y1wueinl6W0UN3idn2B0Ds,28813
+agent_mcp/heterogeneous_group_chat.py,sha256=ecvTBI6DgMoZFKTpFKcx1bhHMVX63DCpfqOc18I9wLU,38231
+agent_mcp/langchain_mcp_adapter.py,sha256=uJsmqv_tFeG-vn-FnTS0bUYztSJzQ_dnVH-Vstjd__g,23825
+agent_mcp/langgraph_mcp_adapter.py,sha256=eIiW3P2MBrEzLHHKpPBd4Rci5EFLAaOQrnSILH4RWBM,14028
+agent_mcp/mcp_agent.py,sha256=qO6zYuAUowZE1B5-T-noDZiyGmjsLpgRZPlzudvvIvE,25577
+agent_mcp/mcp_decorator.py,sha256=CDhq9jDliY0cnpc5JiJj2u8uC9nAHMEQaW7G2e1MapA,12126
+agent_mcp/mcp_langgraph.py,sha256=TdhHVwXzrM-Oe2dy-biR1lIQ1f37LxQlkeE147v5hG8,26975
+agent_mcp/mcp_transaction.py,sha256=iSr_DSFSMAU30TEQMTHbHDNooy1w80CkF9tIGKHbqZQ,3069
+agent_mcp/mcp_transport.py,sha256=Mby0FMB4TKncMFOzhOxTLoabd1d1jwBne8RiJYJVR78,35373
+agent_mcp/mcp_transport_enhanced.py,sha256=RSkHQ_fUXaFI7_6wZk5oAF3vSIM_mgvpTcJrRX_tuDE,1711
+agent_mcp/proxy_agent.py,sha256=YAlOoEpKSO5hGF638kS_XJfKa-pIgY2pS6Z3J9XF1-4,1038
+demos/__init__.py,sha256=6awmpBFb6EK0EB7dmezclX2AJRzIwt1F_LL6pW1oFAY,58
+demos/basic/__init__.py,sha256=jWuTMaIE1wrb3s5lvpAmL_GnIyG9AviMgBmT9AvJFUU,64
+demos/basic/framework_examples.py,sha256=i5YnykChWwwBjz8WGV2TLe-Elf0i5n-XLlLvNhJeVtU,3723
+demos/basic/langchain_camel_demo.py,sha256=EeK6GgfCaA6Ew8xZxgkbNV4SUPy2RxPJv84XlCXyX_g,10611
+demos/basic/simple_chat.py,sha256=JlyhZ8Nq3y6AHSvbejrbC6mKP6CCXg3tRXHOwPZiPyw,13783
+demos/basic/simple_integration_example.py,sha256=_1JiYhKwPzh26-B1yoZe8cEbHIhJH6sDEDbK0FoHMlI,1570
+demos/collaboration/collaborative_task_example.py,sha256=MVtxwaF_Aq-sL8wd7LAQTBCzI5TakNho-4bq6EtTik4,16830
+demos/collaboration/group_chat_example.py,sha256=dfBp1zF0WAPkZiwMDKH01e8_K2oTvkgJJ7DdDMrX4rE,4111
+demos/collaboration/simplified_crewai_example.py,sha256=U-o5VLrZMaqpOQ7IgYytNozIXljl-c_R2BPo9n7t-7M,1301
+demos/langgraph/autonomous_langgraph_network.py,sha256=OkeC2YvuUkSTFj6dxi8WDf_KM48AG0wLrrRh30HUkXc,35801
+demos/langgraph/langgraph_agent_network.py,sha256=Eg8hWlqIj-IWOcQhK_IWHvQl5AkQTBKFZyCPhgFJ9xA,15727
+demos/langgraph/langgraph_collaborative_task.py,sha256=nZ_VW3vlB94BEqhK00WA5jtICCEATbhbsDbqxZA_4A8,24114
+demos/langgraph/langgraph_example.py,sha256=51KY3-SPdwxKO1p7Wr0Q3NPISXSdaVCLmuO8TPvjv0s,8024
+demos/langgraph/run_langgraph_examples.py,sha256=YFhDrqpQV0ugakQobhvxAkAL0A1cv2L5-c-njDOPJIM,7253
+demos/network/agent_network_example.py,sha256=YLMDCjZaddmkbUHCRWgXXoP5tjxRr_QQqpLNGhHbRbI,14931
+demos/network/email_agent.py,sha256=22ef1ZRfOBH4BwYCXsNyziUBp-rr0ve9qSCwnhRd3hU,5031
+demos/network/email_agent_demo.py,sha256=le1SRhfVjOTLvQ-kRPb3ZxVazKN7hbGR50-vOeYoxJo,1310
+demos/network/heterogeneous_network_example.py,sha256=1BmaJ1-CTNNcCeDSe0KbFw9Hq-VLFLzyNpPsmUaetQo,7315
+demos/network/multi_framework_example.py,sha256=nRpJ0PmlSBV8KlpS7_tDUp3e2lHnpZxlnuf9qqpvi5I,6495
+demos/utils/check_imports.py,sha256=cHNzsxwjnGaPKHAE-Vu4-JhBT7fPSAC_ppx2a0u3ecI,1475
+demos/workflows/autonomous_agent_workflow.py,sha256=mr5Vymr5fUimW1F9PJFqOp46SkH6lIFv1yqYtQk9XFM,10269
+demos/workflows/mcp_features_demo.py,sha256=Ot-tS8Rb25RdyhmzGAr-8VkZInVq624I3xsIFioe92o,13635
+demos/workflows/run_agent_collaboration_demo.py,sha256=SOGJUlvKFZT-39TOPkxWTFJn2RpDtV8U59FKnrRrfIA,2184
+demos/workflows/run_agent_collaboration_with_logs.py,sha256=AEEJwR0UE97DgMV_TXfn5G18QKRYRtoeB0cEce1ogFc,14056
+demos/workflows/show_agent_interactions.py,sha256=QCzNByQUcuSKDQ5hVXMMFmAATw_Q763OSNZmUDZymXQ,4981
+demos/workflows/simplified_autonomous_demo.py,sha256=VN1X9_z3sIyndkH1dICT_0Pu7AUCDyvGsOG3ZqGKPvc,2325
+functions/main.py,sha256=KvbjSq2DQsFAnRpSzt_6Lr8sFbQ_T9AZ7XAaVFOYkoI,5844
+functions/mcp_network_server.py,sha256=1lAhd4TZs882Bhkmm0pa1l2X84mXaZs4fEIu4icwVxs,21738
+functions/utils.py,sha256=vR0R34ma84rp7zovlsawmffav6ZHsW6K6nrp9GlM9bk,2059
+agent_mcp-0.1.4.dist-info/METADATA,sha256=qLqpBhF3Bm5BcG6G11CHkHQKzAbioIZwKZJNQC-IVek,11474
+agent_mcp-0.1.4.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+agent_mcp-0.1.4.dist-info/entry_points.txt,sha256=_vOH0WhJfAMNRa61MQAv4cQxs55LZtAoAsfFuRzvXvk,49
+agent_mcp-0.1.4.dist-info/top_level.txt,sha256=sxddPYaKyfJdF_J7-yFNSeMjMat0WQUcYB91f9g6RYM,26
+agent_mcp-0.1.4.dist-info/RECORD,,

{agent_mcp-0.1.2.dist-info → agent_mcp-0.1.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

agent_mcp-0.1.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mcp-agent = agent_mcp.cli:main

agent_mcp-0.1.4.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+agent_mcp
+demos
+functions

demos/__init__.py

@@ -0,0 +1 @@
+# This file makes the 'demos' directory a Python package. 

demos/basic/__init__.py

@@ -0,0 +1 @@
+# This file makes the 'demos/basic' directory a Python package. 

demos/basic/framework_examples.py

@@ -0,0 +1,108 @@
+"""
+Example of using the @mcp_agent decorator with different frameworks.
+"""
+
+import os
+from dotenv import load_dotenv
+from agent_mcp.mcp_decorator import mcp_agent
+
+# Load environment variables
+load_dotenv()
+
+# Set up OpenAI API key
+os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY')
+
+# Example 1: LangChain Agent
+from langchain_openai import ChatOpenAI
+from langchain.agents import AgentExecutor, create_openai_functions_agent
+from langchain_community.tools.ddg_search import DuckDuckGoSearchRun
+from langchain.schema.messages import SystemMessage
+from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
+
+@mcp_agent(name="LangChainResearcher")
+class LangChainResearchAgent:
+    def __init__(self):
+        # Set up LangChain components
+        self.llm = ChatOpenAI(model="gpt-3.5-turbo")
+        self.tools = [DuckDuckGoSearchRun()]
+        
+        # Create prompt template
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", "You are a research agent that uses search tools."),
+            ("user", "{input}"),
+            MessagesPlaceholder(variable_name="agent_scratchpad")
+        ])
+        
+        # Create the agent
+        self.agent = create_openai_functions_agent(
+            llm=self.llm,
+            tools=self.tools,
+            prompt=prompt
+        )
+        self.agent_executor = AgentExecutor(agent=self.agent, tools=self.tools)
+    
+    def research(self, query: str) -> str:
+        """Perform research on a given query"""
+        return self.agent_executor.invoke({"input": query})["output"]
+
+# Example 2: LangGraph Agent
+from langgraph.graph import Graph, StateGraph
+from typing import Dict, TypedDict, Annotated
+
+# Define the state type
+class GraphState(TypedDict):
+    input: str
+    analysis: str
+    output: str
+
+@mcp_agent(name="LangGraphAnalyzer")
+class LangGraphAnalysisAgent:
+    def __init__(self):
+        # Set up LangGraph components
+        self.llm = ChatOpenAI(model="gpt-3.5-turbo")
+        
+        # Define the workflow graph
+        self.workflow = StateGraph(GraphState)
+        
+        # Add nodes to the graph
+        self.workflow.add_node("analyze", self.analyze_step)
+        self.workflow.add_node("summarize", self.summarize_step)
+        
+        # Add edges
+        self.workflow.add_edge("analyze", "summarize")
+        self.workflow.set_entry_point("analyze")
+        self.workflow.set_finish_point("summarize")
+        
+        # Compile the graph
+        self.graph = self.workflow.compile()
+    
+    def analyze_step(self, state):
+        """Analyze the input data"""
+        analysis = self.llm.invoke(f"Analyze this topic: {state['input']}")
+        state['analysis'] = analysis
+        return state
+    
+    def summarize_step(self, state):
+        """Summarize the analysis"""
+        summary = self.llm.invoke(f"Summarize this analysis: {state['analysis']}")
+        state['output'] = summary
+        return state
+    
+    def process(self, topic: str) -> str:
+        """Process a topic through the LangGraph workflow"""
+        result = self.graph.invoke({"input": topic})
+        return result["output"]
+
+# Example usage
+if __name__ == "__main__":
+    print("Testing LangChain Agent:")
+    langchain_agent = LangChainResearchAgent()
+    result = langchain_agent.research("Latest developments in quantum computing 2025")
+    print(f"Research result: {result}")
+    print(f"Available MCP tools: {langchain_agent.mcp_tools.keys()}\n")
+    
+    print("Testing LangGraph Agent:")
+    langgraph_agent = LangGraphAnalysisAgent()
+    result = langgraph_agent.process("Impact of AI on healthcare in 2025")
+    print(f"Analysis result: {result}")
+    print(f"Available MCP tools: {langgraph_agent.mcp_tools.keys()}")