praisonaiagents 0.0.64__py3-none-any.whl → 0.0.66__py3-none-any.whl

praisonaiagents/__init__.py

@@ -10,6 +10,7 @@ from .tools.tools import Tools
 from .agents.autoagents import AutoAgents
 from .knowledge.knowledge import Knowledge
 from .knowledge.chunking import Chunking
+from .mcp.mcp import MCP
 from .main import (
     TaskOutput,
     ReflectionOutput,
@@ -51,5 +52,6 @@ __all__ = [
     'sync_display_callbacks',
     'async_display_callbacks',
     'Knowledge',
-    'Chunking'
+    'Chunking',
+    'MCP'
 ] 

praisonaiagents/agents/agents.py

@@ -477,8 +477,14 @@ Context:
                 else:
                     self.run_task(task_id)
 
-    async def astart(self, content=None, **kwargs):
-        """Async version of start method"""
+    async def astart(self, content=None, return_dict=False, **kwargs):
+        """Async version of start method
+        
+        Args:
+            content: Optional content to add to all tasks' context
+            return_dict: If True, returns the full results dictionary instead of only the final response
+            **kwargs: Additional arguments
+        """
         if content:
             # Add content to context of all tasks
             for task in self.tasks.values():
@@ -488,10 +494,25 @@ Context:
                     task.context.append(content)
 
         await self.arun_all_tasks()
-        return {
+        
+        # Get results
+        results = {
             "task_status": self.get_all_tasks_status(),
             "task_results": {task_id: self.get_task_result(task_id) for task_id in self.tasks}
         }
+        
+        # By default, return only the final agent's response
+        if not return_dict:
+            # Get the last task (assuming sequential processing)
+            task_ids = list(self.tasks.keys())
+            if task_ids:
+                last_task_id = task_ids[-1]
+                last_result = self.get_task_result(last_task_id)
+                if last_result:
+                    return last_result.raw
+                    
+        # Return full results dict if return_dict is True or if no final result was found
+        return results
 
     def save_output_to_file(self, task, task_output):
         if task.output_file:
@@ -801,8 +822,14 @@ Context:
             return str(agent[0])
         return None
 
-    def start(self, content=None, **kwargs):
-        """Start agent execution with optional content and config"""
+    def start(self, content=None, return_dict=False, **kwargs):
+        """Start agent execution with optional content and config
+        
+        Args:
+            content: Optional content to add to all tasks' context
+            return_dict: If True, returns the full results dictionary instead of only the final response
+            **kwargs: Additional arguments
+        """
         if content:
             # Add content to context of all tasks
             for task in self.tasks.values():
@@ -815,10 +842,25 @@ Context:
                 
         # Run tasks as before
         self.run_all_tasks()
-        return {
+        
+        # Get results
+        results = {
             "task_status": self.get_all_tasks_status(),
             "task_results": {task_id: self.get_task_result(task_id) for task_id in self.tasks}
         }
+        
+        # By default, return only the final agent's response
+        if not return_dict:
+            # Get the last task (assuming sequential processing)
+            task_ids = list(self.tasks.keys())
+            if task_ids:
+                last_task_id = task_ids[-1]
+                last_result = self.get_task_result(last_task_id)
+                if last_result:
+                    return last_result.raw
+                    
+        # Return full results dict if return_dict is True or if no final result was found
+        return results
 
     def set_state(self, key: str, value: Any) -> None:
         """Set a state value"""

praisonaiagents/mcp/mcp.py

@@ -0,0 +1,278 @@
+import asyncio
+import threading
+import queue
+import time
+import inspect
+import shlex
+from typing import Dict, Any, List, Optional, Callable, Iterable, Union
+from functools import wraps, partial
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+class MCPToolRunner(threading.Thread):
+    """A dedicated thread for running MCP operations."""
+    
+    def __init__(self, server_params):
+        super().__init__(daemon=True)
+        self.server_params = server_params
+        self.queue = queue.Queue()
+        self.result_queue = queue.Queue()
+        self.initialized = threading.Event()
+        self.tools = []
+        self.start()
+        
+    def run(self):
+        """Main thread function that processes MCP requests."""
+        asyncio.run(self._run_async())
+        
+    async def _run_async(self):
+        """Async entry point for MCP operations."""
+        try:
+            # Set up MCP session
+            async with stdio_client(self.server_params) as (read, write):
+                async with ClientSession(read, write) as session:
+                    # Initialize connection
+                    await session.initialize()
+                    
+                    # Get tools
+                    tools_result = await session.list_tools()
+                    self.tools = tools_result.tools
+                    
+                    # Signal that initialization is complete
+                    self.initialized.set()
+                    
+                    # Process requests
+                    while True:
+                        try:
+                            # Check for new requests
+                            try:
+                                item = self.queue.get(block=False)
+                                if item is None:  # Shutdown signal
+                                    break
+                                
+                                tool_name, arguments = item
+                                try:
+                                    result = await session.call_tool(tool_name, arguments)
+                                    self.result_queue.put((True, result))
+                                except Exception as e:
+                                    self.result_queue.put((False, str(e)))
+                            except queue.Empty:
+                                pass
+                            
+                            # Give other tasks a chance to run
+                            await asyncio.sleep(0.01)
+                        except asyncio.CancelledError:
+                            break
+        except Exception as e:
+            self.initialized.set()  # Ensure we don't hang
+            self.result_queue.put((False, f"MCP initialization error: {str(e)}"))
+    
+    def call_tool(self, tool_name, arguments):
+        """Call an MCP tool and wait for the result."""
+        if not self.initialized.is_set():
+            self.initialized.wait(timeout=30)
+            if not self.initialized.is_set():
+                return "Error: MCP initialization timed out"
+        
+        # Put request in queue
+        self.queue.put((tool_name, arguments))
+        
+        # Wait for result
+        success, result = self.result_queue.get()
+        if not success:
+            return f"Error: {result}"
+        
+        # Process result
+        if hasattr(result, 'content') and result.content:
+            if hasattr(result.content[0], 'text'):
+                return result.content[0].text
+            return str(result.content[0])
+        return str(result)
+    
+    def shutdown(self):
+        """Signal the thread to shut down."""
+        self.queue.put(None)
+
+
+class MCP:
+    """
+    Model Context Protocol (MCP) integration for PraisonAI Agents.
+    
+    This class provides a simple way to connect to MCP servers and use their tools
+    within PraisonAI agents.
+    
+    Example:
+        ```python
+        from praisonaiagents import Agent
+        from praisonaiagents.mcp import MCP
+        
+        # Method 1: Using command and args separately
+        agent = Agent(
+            instructions="You are a helpful assistant...",
+            llm="gpt-4o-mini",
+            tools=MCP(
+                command="/path/to/python",
+                args=["/path/to/app.py"]
+            )
+        )
+        
+        # Method 2: Using a single command string
+        agent = Agent(
+            instructions="You are a helpful assistant...",
+            llm="gpt-4o-mini",
+            tools=MCP("/path/to/python /path/to/app.py")
+        )
+        
+        agent.start("What is the stock price of Tesla?")
+        ```
+    """
+    
+    def __init__(self, command_or_string=None, args=None, *, command=None, **kwargs):
+        """
+        Initialize the MCP connection and get tools.
+        
+        Args:
+            command_or_string: Either:
+                             - The command to run the MCP server (e.g., Python path)
+                             - A complete command string (e.g., "/path/to/python /path/to/app.py")
+            args: Arguments to pass to the command (when command_or_string is the command)
+            command: Alternative parameter name for backward compatibility
+            **kwargs: Additional parameters for StdioServerParameters
+        """
+        # Handle backward compatibility with named parameter 'command'
+        if command_or_string is None and command is not None:
+            command_or_string = command
+        
+        # Handle the single string format
+        if isinstance(command_or_string, str) and args is None:
+            # Split the string into command and args using shell-like parsing
+            parts = shlex.split(command_or_string)
+            if not parts:
+                raise ValueError("Empty command string")
+            
+            cmd = parts[0]
+            arguments = parts[1:] if len(parts) > 1 else []
+        else:
+            # Use the original format with separate command and args
+            cmd = command_or_string
+            arguments = args or []
+            
+        self.server_params = StdioServerParameters(
+            command=cmd,
+            args=arguments,
+            **kwargs
+        )
+        self.runner = MCPToolRunner(self.server_params)
+        
+        # Wait for initialization
+        if not self.runner.initialized.wait(timeout=30):
+            print("Warning: MCP initialization timed out")
+        
+        # Generate tool functions immediately and store them
+        self._tools = self._generate_tool_functions()
+    
+    def _generate_tool_functions(self) -> List[Callable]:
+        """
+        Generate functions for each MCP tool.
+        
+        Returns:
+            List[Callable]: Functions that can be used as tools
+        """
+        tool_functions = []
+        
+        for tool in self.runner.tools:
+            wrapper = self._create_tool_wrapper(tool)
+            tool_functions.append(wrapper)
+        
+        return tool_functions
+    
+    def _create_tool_wrapper(self, tool):
+        """Create a wrapper function for an MCP tool."""
+        # Determine parameter names from the schema
+        param_names = []
+        param_annotations = {}
+        required_params = []
+        
+        if hasattr(tool, 'inputSchema') and tool.inputSchema:
+            properties = tool.inputSchema.get("properties", {})
+            required = tool.inputSchema.get("required", [])
+            
+            for name, prop in properties.items():
+                param_names.append(name)
+                
+                # Set annotation based on property type
+                prop_type = prop.get("type", "string")
+                if prop_type == "string":
+                    param_annotations[name] = str
+                elif prop_type == "integer":
+                    param_annotations[name] = int
+                elif prop_type == "number":
+                    param_annotations[name] = float
+                elif prop_type == "boolean":
+                    param_annotations[name] = bool
+                elif prop_type == "array":
+                    param_annotations[name] = list
+                elif prop_type == "object":
+                    param_annotations[name] = dict
+                else:
+                    param_annotations[name] = Any
+                
+                if name in required:
+                    required_params.append(name)
+        
+        # Create the function signature
+        params = []
+        for name in param_names:
+            is_required = name in required_params
+            param = inspect.Parameter(
+                name=name,
+                kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                default=inspect.Parameter.empty if is_required else None,
+                annotation=param_annotations.get(name, Any)
+            )
+            params.append(param)
+        
+        # Create function template to be properly decorated
+        def template_function(*args, **kwargs):
+            return None
+        
+        # Create a proper function with the correct signature
+        template_function.__signature__ = inspect.Signature(params)
+        template_function.__annotations__ = param_annotations
+        template_function.__name__ = tool.name
+        template_function.__qualname__ = tool.name
+        template_function.__doc__ = tool.description
+        
+        # Create the actual function using a decorator
+        @wraps(template_function)
+        def wrapper(*args, **kwargs):
+            # Map positional args to parameter names
+            all_args = {}
+            for i, arg in enumerate(args):
+                if i < len(param_names):
+                    all_args[param_names[i]] = arg
+            
+            # Add keyword args
+            all_args.update(kwargs)
+            
+            # Call the tool
+            return self.runner.call_tool(tool.name, all_args)
+        
+        # Make sure the wrapper has the correct signature for inspection
+        wrapper.__signature__ = inspect.Signature(params)
+        
+        return wrapper
+    
+    def __iter__(self) -> Iterable[Callable]:
+        """
+        Allow the MCP instance to be used directly as an iterable of tools.
+        
+        This makes it possible to pass the MCP instance directly to the Agent's tools parameter.
+        """
+        return iter(self._tools)
+    
+    def __del__(self):
+        """Clean up resources when the object is garbage collected."""
+        if hasattr(self, 'runner'):
+            self.runner.shutdown() 

{praisonaiagents-0.0.64.dist-info → praisonaiagents-0.0.66.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: praisonaiagents
-Version: 0.0.64
+Version: 0.0.66
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Dist: pydantic

{praisonaiagents-0.0.64.dist-info → praisonaiagents-0.0.66.dist-info}/RECORD

@@ -1,16 +1,17 @@
-praisonaiagents/__init__.py,sha256=frdIvimDY-kU9j-9yXV1z4NtXypfPvyvlnac5mgBCuQ,1288
+praisonaiagents/__init__.py,sha256=Z2_rSA6mYozz0r3ioUgKzl3QV8uWRDS_QaqPg2oGjqg,1324
 praisonaiagents/main.py,sha256=l29nGEbV2ReBi4szURbnH0Fk0w2F_QZTmECysyZjYcA,15066
 praisonaiagents/agent/__init__.py,sha256=j0T19TVNbfZcClvpbZDDinQxZ0oORgsMrMqx16jZ-bA,128
 praisonaiagents/agent/agent.py,sha256=h3s0-1M88zujllDHnKijHmYeVihD75d-K9s2Y3IHLY4,61850
 praisonaiagents/agent/image_agent.py,sha256=-5MXG594HVwSpFMcidt16YBp7udtik-Cp7eXlzLE1fY,8696
 praisonaiagents/agents/__init__.py,sha256=_1d6Pqyk9EoBSo7E68sKyd1jDRlN1vxvVIRpoMc0Jcw,168
-praisonaiagents/agents/agents.py,sha256=94YPQl-hl-EPY6-Xk2Rj9wlIs9YtiLQbsutSOXWX8QI,36156
+praisonaiagents/agents/agents.py,sha256=KLfSuz6nGEJM-n4xCXdtIkES6cUI-LwvMxI3R-MjrD0,37862
 praisonaiagents/agents/autoagents.py,sha256=olYDn--rlJp-SckxILqmREkkgNlzCgEEcAUzfMj-54E,13518
 praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9bge0Ujuto,246
 praisonaiagents/knowledge/chunking.py,sha256=FzoNY0q8MkvG4gADqk4JcRhmH3lcEHbRdonDgitQa30,6624
 praisonaiagents/knowledge/knowledge.py,sha256=fQNREDiwdoisfIxJBLVkteXgq_8Gbypfc3UaZbxf5QY,13210
 praisonaiagents/llm/__init__.py,sha256=ttPQQJQq6Tah-0updoEXDZFKWtJAM93rBWRoIgxRWO8,689
 praisonaiagents/llm/llm.py,sha256=6QMRW47fgFozibzaqxa3dwxlD756rMLCRjL3eNsw8QQ,74088
+praisonaiagents/mcp/mcp.py,sha256=xvORgbsbsdaY_j3jKCP8BH3ERoKi_ZK8zM57mobC2Ac,10488
 praisonaiagents/memory/memory.py,sha256=I8dOTkrl1i-GgQbDcrFOsSruzJ7MiI6Ys37DK27wrUs,35537
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
 praisonaiagents/process/process.py,sha256=HPw84OhnKQW3EyrDkpoQu0DcpxThbrzR2hWUgwQh9Pw,59955
@@ -37,7 +38,7 @@ praisonaiagents/tools/xml_tools.py,sha256=iYTMBEk5l3L3ryQ1fkUnNVYK-Nnua2Kx2S0dxN
 praisonaiagents/tools/yaml_tools.py,sha256=uogAZrhXV9O7xvspAtcTfpKSQYL2nlOTvCQXN94-G9A,14215
 praisonaiagents/tools/yfinance_tools.py,sha256=s2PBj_1v7oQnOobo2fDbQBACEHl61ftG4beG6Z979ZE,8529
 praisonaiagents/tools/train/data/generatecot.py,sha256=H6bNh-E2hqL5MW6kX3hqZ05g9ETKN2-kudSjiuU_SD8,19403
-praisonaiagents-0.0.64.dist-info/METADATA,sha256=-tEl9Hf9UGdFXGT1K9IF2XoT4RvsA5WDrzNr1P9L5OU,830
-praisonaiagents-0.0.64.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-praisonaiagents-0.0.64.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.64.dist-info/RECORD,,
+praisonaiagents-0.0.66.dist-info/METADATA,sha256=mZDRbV3kjDru4ehwjOVkMLJAKZeYq79yZB_8VjQDzUA,830
+praisonaiagents-0.0.66.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+praisonaiagents-0.0.66.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.66.dist-info/RECORD,,

{praisonaiagents-0.0.64.dist-info → praisonaiagents-0.0.66.dist-info}/WHEEL

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