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

agent_mcp/langchain_mcp_adapter.py

@@ -10,6 +10,7 @@ from langchain.agents import AgentExecutor
 from langchain.agents.openai_functions_agent.base import OpenAIFunctionsAgent
 import traceback
 import json
+import uuid
 
 # --- Setup Logger ---
 import logging
@@ -66,12 +67,13 @@ class LangchainMCPAdapter(MCPAgent):
         """Handle incoming messages from other agents"""
         # First check if type is directly in the message
         msg_type = message.get("type")
-        
+        logger.info(f"[{self.name}] Raw message: {message}")
+
         # If not, check if it's inside the content field
         if not msg_type and "content" in message and isinstance(message["content"], dict):
             msg_type = message["content"].get("type")
             
-        sender = message.get("sender", "Unknown")
+        sender = self._extract_sender(message)
         task_id = message.get("task_id") or message.get("content", {}).get("task_id") if isinstance(message.get("content"), dict) else message.get("task_id")
         logger.info(f"[{self.name}] Received message (ID: {message_id}) of type '{msg_type}' from {sender} (Task ID: {task_id})")
         
@@ -87,24 +89,118 @@ class LangchainMCPAdapter(MCPAgent):
         if msg_type == "task":
             logger.info(f"[{self.name}] Queueing task {task_id} (message_id: {message_id}) from {sender}")
             content = message.get("content", {})
-            task_id = content.get("task_id") or message.get("task_id")
+            current_task_id = content.get("task_id") or message.get("task_id") # Handle potential nesting
             description = content.get("description") or message.get("description")
-            reply_to = content.get("reply_to")
-            
-            if not task_id or not description:
-                print(f"[ERROR] {self.name}: Task message missing required fields: {message}")
+            reply_to = content.get("reply_to") or message.get("reply_to")
+
+            if not current_task_id or not description:
+                logger.error(f"[{self.name}] Task message missing required fields: {message}")
+                # Acknowledge if possible to prevent reprocessing bad message
+                if message_id and self.transport:
+                     asyncio.create_task(self.transport.acknowledge_message(self.name, message_id))
                 return
-            
-            # Add message_id to task
+
+            # Add message_id to task context for processing
             message['message_id'] = message_id
-                
-            # Queue task for async processing
-            print(f"[DEBUG] {self.name}: Queueing task {task_id} with message_id {message_id} for processing")
+
+            #task_context = {
+            #    "type": "task", # Ensure type is explicitly set for process_tasks
+            #    "task_id": current_task_id,
+            #    "description": description,
+            #    "reply_to": reply_to,
+            #    "sender": sender,
+            #    "message_id": message_id
+            #}
+            #logger.debug(f"[{self.name}] Queueing task context: {task_context}")
+            logger.debug(f"[DEBUG] {self.name}: Queueing task {task_id} with message_id {message_id} for processing")
+
             await self.task_queue.put(message)
-            print(f"[DEBUG] {self.name}: Successfully queued task {task_id}")
-        else:
-            print(f"[WARN] {self.name}: Received unknown message type: {msg_type}")
+            logger.debug(f"[{self.name}] Successfully queued task {current_task_id}")
+
+        elif msg_type == "task_result":
+            # Received a result, treat it as the next step in the conversation
+            result_content = message.get("result")
+            
+            # --- Robust extraction for various formats ---
+            content = message.get("content")
+            if result_content is None and content is not None:
+                # 1. Try content["result"]
+                if isinstance(content, dict) and "result" in content:
+                    result_content = content["result"]
+                # 2. Try content["text"] as JSON
+                elif isinstance(content, dict) and "text" in content:
+                    text_val = content["text"]
+                    if isinstance(text_val, str):
+                        try:
+                            parsed = json.loads(text_val)
+                            if isinstance(parsed, dict) and "result" in parsed:
+                                result_content = parsed["result"]
+                        except Exception:
+                            pass
+                # 3. Try content itself as JSON string
+                elif isinstance(content, str):
+                    try:
+                        parsed = json.loads(content)
+                        if isinstance(parsed, dict) and "result" in parsed:
+                            result_content = parsed["result"]
+                    except Exception:
+                        pass
+                # 4. Fallback: use content["text"] as plain string
+                if result_content is None and isinstance(content, dict) and "text" in content:
+                    result_content = content["text"]
+
+            # Handle JSON string content
+            if isinstance(result_content, str):
+                try:
+                    result_content = json.loads(result_content)
+                except json.JSONDecodeError:
+                    pass
+
+            # Direct parsing of content["text"] structure
+            if isinstance(result_content, str):
+                try:
+                    text_content = json.loads(result_content)
+                    if isinstance(text_content, dict):
+                        result_content = text_content
+                except json.JSONDecodeError:
+                    pass
+
+            # --- End Robust extraction ---
+            original_task_id = (
+                (result_content.get("task_id") if isinstance(result_content, dict) else None)
+                or message.get("task_id")
+            )
+            logger.info(f"[{self.name}] Received task_result from {sender} for task {original_task_id}. Content: '{str(result_content)[:100]}...'")
+
+            if not result_content:
+                logger.warning(f"[{self.name}] Received task_result from {sender} with empty content.")
             
+            # Acknowledge the result message even if content is empty
+            if message_id and self.transport:
+                asyncio.create_task(self.transport.acknowledge_message(self.name, message_id))
+            return
+
+            # Create a *new* task for this agent based on the received result
+            #new_task_id = f"conv_{uuid.uuid4()}" # Generate a new ID for this conversational turn
+            #new_task_context = {
+            #    "type": "task", # Still a task for this agent to process
+            #    "task_id": new_task_id,
+            #    "description": str(result_content), # The result becomes the new input/description
+            #    "reply_to": message.get("reply_to") or result_content.get("reply_to"),
+            #    "sender": sender, # This agent is the conceptual sender of this internal task
+            #    "message_id": message_id # Carry over original message ID for acknowledgement
+            #}
+
+            #logger.info(f"[{self.name}] Queueing new conversational task {new_task_id} based on result from {sender}")
+            #await self.task_queue.put(new_task_context)
+            #logger.debug(f"[{self.name}] Successfully queued new task {new_task_id}")
+
+        else:
+            logger.warning(f"[{self.name}] Received unknown message type: {msg_type}. Message: {message}")
+            # Acknowledge other message types immediately if they have an ID
+            #if message_id and self.transport:
+            #     asyncio.create_task(self.transport.acknowledge_message(self.name, message_id))
+
     async def _handle_task(self, message: Dict[str, Any]):
         """Handle incoming task"""
         print(f"{self.name}: Received task: {message}")
@@ -112,14 +208,14 @@ class LangchainMCPAdapter(MCPAgent):
         return {"status": "ok"}
         
     async def process_messages(self):
-        print(f"[{self.name}] Message processor loop started.")
+        logger.info(f"[{self.name}] Message processor loop started.")
         while True:
             try:
-                print(f"[{self.name}] Waiting for message from queue...")
+                logger.debug(f"[{self.name}] Waiting for message from transport...")
+                # Pass agent name to receive_message
                 message, message_id = await self.transport.receive_message()
-                print(f"{self.name}: Processing message {message_id}: {message}")
-                
-                # Skip None messages
+                logger.debug(f"[{self.name}] Received raw message from transport: {message} (ID: {message_id})")
+
                 if message is None:
                     print(f"[{self.name}] Received None message, skipping...")
                     continue
@@ -143,48 +239,77 @@ class LangchainMCPAdapter(MCPAgent):
             try:
                 print(f"[{self.name}] Waiting for task from queue...")
                 task = await self.task_queue.get()
-                print(f"\n[{self.name}] Got task from queue: {task}")
+                print(f"\n[{self.name}] Got item from queue: {task}")
                 
                 if not isinstance(task, dict):
-                    print(f"[ERROR] {self.name}: Task is not a dictionary: {task}")
+                    print(f"[ERROR] {self.name}: Task item is not a dictionary: {task}")
                     self.task_queue.task_done()
                     continue
                 
-                # Get task details from content field if present
-                content = task.get("content", {})
-                task_desc = content.get("description") or task.get("description")
-                task_id = content.get("task_id") or task.get("task_id")
-                task_type = content.get("type") or task.get("type")
-                reply_to = content.get("reply_to") or task.get("reply_to")
-                
-                print(f"[DEBUG] {self.name}: Task details:")
-                print(f"  - Type: {task_type}")
+                # Extract task details (handle both original message format and task_context format)
+                task_desc = task.get("description")
+                task_id = task.get("task_id")
+                task_type = task.get("type") # Should always be 'task' if queued correctly
+                reply_to = task.get("reply_to")
+                message_id = task.get("message_id") # For acknowledgement
+                sender = self._extract_sender(task)
+                # Fallback for nested content (less likely now but safe)
+                if not task_desc and isinstance(task.get("content"), dict):
+                     content = task.get("content", {})
+                     task_desc = content.get("description")
+                     if not task_id: task_id = content.get("task_id")
+                     if not task_type: task_type = content.get("type")
+                     if not reply_to: reply_to = content.get("reply_to")
+                     if not sender: sender = content.get("sender", "from")
+
+                print(f"[DEBUG] {self.name}: Processing task details:")
                 print(f"  - Task ID: {task_id}")
+                print(f"  - Type: {task_type}")
+                print(f"  - Sender: {sender}")
                 print(f"  - Reply To: {reply_to}")
-                print(f"  - Description: {task_desc}")
+                print(f"  - Description: {str(task_desc)[:100]}...")
+                print(f"  - Original Message ID: {message_id}")
                 
                 if not task_desc or not task_id:
-                    print(f"[ERROR] {self.name}: Task is missing description or task_id")
+                    print(f"[ERROR] {self.name}: Task is missing description or task_id: {task}")
                     self.task_queue.task_done()
+                    # Acknowledge if possible
+                    #if message_id and self.transport:
+                    #    asyncio.create_task(self.transport.acknowledge_message(self.name, message_id))
                     continue
                     
+                # We only queue tasks now, so this check might be redundant but safe
                 if task_type != "task":
-                    print(f"[ERROR] {self.name}: Invalid task type: {task_type}")
+                    print(f"[ERROR] {self.name}: Invalid item type received in task queue: {task_type}. Item: {task}")
                     self.task_queue.task_done()
+                    #if message_id and self.transport:
+                    #    asyncio.create_task(self.transport.acknowledge_message(self.name, message_id))
                     continue
                 
                 print(f"[DEBUG] {self.name}: Starting execution of task {task_id}")
                 # Execute task using Langchain agent
                 try:
-                    print(f"[DEBUG] {self.name}: Calling agent_executor.arun with task description")
-                    # Execute the task using the Langchain agent executor
-                    result = await self.agent_executor.arun(task_desc)
-                    print(f"[DEBUG] {self.name}: Agent execution completed. Result type: {type(result)}")
+                    print(f"[DEBUG] {self.name}: Calling agent_executor.ainvoke with task description")
+                    # Execute the task using the Langchain agent executor's ainvoke method
+                    # Pass input AND agent_name in a dictionary matching the prompt's input variables
+                    input_data = {
+                        "input": task_desc,
+                        "agent_name": self.name # Add agent_name here to indicate this agent as the executor (who's currently executing the task)
+                    }
+                    result_dict = await self.agent_executor.ainvoke(input_data)
+                    print(f"[DEBUG] {self.name}: Agent execution completed. Full result: {result_dict}")
+                    # Extract the final output string, typically under the 'output' key
+                    if isinstance(result_dict, dict) and 'output' in result_dict:
+                        result = result_dict['output']
+                        print(f"[DEBUG] {self.name}: Extracted output: {result}")
+                    else:
+                        logger.warning(f"[{self.name}] Could not find 'output' key in agent result: {result_dict}. Using full dict as string.")
+                        result = str(result_dict)
                 except Exception as e:
                     print(f"[ERROR] {self.name}: Agent execution failed: {e}")
                     print(f"[ERROR] {self.name}: Error type: {type(e)}")
                     traceback.print_exc() # Print the full traceback for detailed debugging
-                    # Provide a user-friendly error message as the result
+                    # Assign error message to result variable for graceful failure
                     result = f"Agent execution failed due to an error: {str(e)}"
 
                 # Ensure result is always a string before sending
@@ -202,11 +327,20 @@ class LangchainMCPAdapter(MCPAgent):
                     try:
                         # --- FIX: Extract agent name from reply_to URL --- 
                         try:
-                            target_agent_name = reply_to.split('/')[-1]
+                            # Handle both URL paths and direct agent names
+                            if '/' in reply_to:
+                                target_agent_name = reply_to.split('/')[-1]
+                            else:
+                                target_agent_name = reply_to
                         except IndexError:
-                            print(f"[ERROR] {self.name}: Could not extract agent name from reply_to URL: {reply_to}")
+                            print(f"[ERROR] {self.name}: Could not extract agent name from reply_to: {reply_to}")
                             target_agent_name = reply_to # Fallback, though likely wrong
                             
+                        print(f"[DEBUG] Conversation Routing - Original sender: {reply_to}, Current agent: {self.name}, Final reply_to: {reply_to}")
+                        print(f"[DEBUG] Derived target agent: {target_agent_name} from reply_to: {reply_to}")
+                        print(f"[DEBUG] TASK_MESSAGE: {task}")
+                        print(f"[DEBUG] Message Chain - From: {sender} -> To: {self.name} -> ReplyTo: {reply_to}")
+                        
                         print(f"[DEBUG] {self.name}: Sending result to target agent: {target_agent_name} (extracted from {reply_to})")
                         # --- END FIX ---
                         
@@ -217,13 +351,12 @@ class LangchainMCPAdapter(MCPAgent):
                                 "task_id": task_id,
                                 "result": result_str,
                                 "sender": self.name,
-                                "original_message_id": task.get('message_id')  # Include original message ID
+                                "original_message_id": message_id # Include original message ID
                             }
                         )
                         print(f"[DEBUG] {self.name}: Result sent successfully")
                         
                         # Acknowledge task completion using message_id
-                        message_id = task.get('message_id')
                         if message_id:
                             await self.transport.acknowledge_message(self.name, message_id)
                             print(f"[DEBUG] {self.name}: Task {task_id} acknowledged with message_id {message_id}")

agent_mcp/mcp_agent.py

@@ -630,3 +630,29 @@ class MCPAgent(ConversableAgent):
             self.completed_task_ids.add(task_id)
         else:
              logger.warning(f"[{self.name}] Attempted to mark task completed, but task_id was None.")
+
+    def _extract_sender(self, message: Dict) -> str:
+        """Centralized sender extraction with nested JSON support
+        TODO: Migrate to MessageSchema validation (GitHub Issue #1?)
+        """
+        # First check root level
+        if sender := message.get('sender') or message.get('from'):
+            return sender
+        
+        content = message.get('content', {})
+        
+        # Check nested JSON in content.text
+        if isinstance(content, dict):
+            try:
+                if text_content := content.get('text'):
+                    parsed = json.loads(text_content)
+                    if sender := parsed.get('sender') or parsed.get('from'):
+                        return sender
+            except json.JSONDecodeError:
+                pass
+            
+            # Fallback to content.sender
+            if sender := content.get('sender') or content.get('from'):
+                return sender
+        
+        return "Unknown"

agent_mcp/mcp_transport.py

@@ -630,7 +630,7 @@ class HTTPTransport(MCPTransport):
         self.server_thread = Thread(target=run_server, daemon=True)
         self.server_thread.start()
         
-    def stop(self):
+    async def stop(self):
         """Stops the local HTTP server (if running).
         
         This method gracefully shuts down the local HTTP server when operating in
@@ -639,12 +639,18 @@ class HTTPTransport(MCPTransport):
         The method ensures proper cleanup of server resources and thread termination.
         """
         if self.is_remote:
-             logger.info(f"[{self.agent_name or 'Unknown'}] In remote mode. Call disconnect() to stop polling.")
-             pass 
+            logger.info(f"[{self.agent_name or 'Unknown'}] In remote mode. Call disconnect() to stop polling.")
+            return 
+        # Close client session if exists
+        if hasattr(self, '_client_session') and self._client_session:
+            await self._client_session.close()
+            self._client_session = None
+    
         elif self.server_thread:
             logger.info(f"Stopping local server thread (implementation pending)...")
-            pass
-            
+            self.server_thread = None  # Important for GC
+
+        
     def set_message_handler(self, handler: Callable):
         """Set a handler for incoming messages.
         

{agent_mcp-0.1.3.dist-info → agent_mcp-0.1.4.dist-info}/METADATA

@@ -1,17 +1,19 @@
 Metadata-Version: 2.4
 Name: agent-mcp
-Version: 0.1.3
-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)
+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: MIT
+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: License :: OSI Approved :: MIT License
 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

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.3.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()}")