🛠️ Tools

evoagentx.tools

Tool

Tool(**kwargs)

Bases: BaseModule

Source code in evoagentx/core/module.py

def __init__(self, **kwargs):
    """
    Initializes a BaseModule instance.

    Args:
        **kwargs (Any): Keyword arguments used to initialize the instance

    Raises:
        ValidationError: When parameter validation fails
        Exception: When other errors occur during initialization
    """

    try:
        for field_name, _ in type(self).model_fields.items():
            field_value = kwargs.get(field_name, None)
            if field_value:
                kwargs[field_name] = self._process_data(field_value)
            # if field_value and isinstance(field_value, dict) and "class_name" in field_value:
            #     class_name = field_value.get("class_name")
            #     sub_cls = MODULE_REGISTRY.get_module(cls_name=class_name)
            #     kwargs[field_name] = sub_cls._create_instance(field_value)
        super().__init__(**kwargs) 
        self.init_module()
    except (ValidationError, Exception) as e:
        exception_handler = callback_manager.get_callback("exception_buffer")
        if exception_handler is None:
            error_message = get_base_module_init_error_message(
                cls=self.__class__, 
                data=kwargs, 
                errors=e
            )
            logger.error(error_message)
            raise
        else:
            exception_handler.add(e)

required class-attribute instance-attribute

required: Optional[List[str]] = None

inputs: {"input_name": {"type": "string", "description": "input description"}, ...}

BrowserToolkit

BrowserToolkit(name: str = 'BrowserToolkit', browser_type: str = 'chrome', headless: bool = False, timeout: int = 10, **kwargs)

Bases: Toolkit

Browser toolkit with auto-initialization and cleanup.

The browser is automatically initialized when any tool is first used, and automatically closed when the toolkit instance is destroyed. No explicit initialization or cleanup is required.

Source code in evoagentx/tools/browser_tool.py

def __init__(
    self,
    name: str = "BrowserToolkit",
    browser_type: str = "chrome",
    headless: bool = False,
    timeout: int = 10,
    **kwargs

):
    # Create the shared browser tool instance
    browser_tool = BrowserBase(
        name="BrowserBase",
        browser_type=browser_type,
        headless=headless,
        timeout=timeout,
        **kwargs
    )

    # Create tools with the shared browser tool instance
    # Note: Browser auto-initializes when first used and auto-closes when destroyed
    tools = [
        NavigateToUrlTool(browser_tool=browser_tool),
        InputTextTool(browser_tool=browser_tool),
        BrowserClickTool(browser_tool=browser_tool),
        BrowserSnapshotTool(browser_tool=browser_tool),
        BrowserConsoleMessagesTool(browser_tool=browser_tool)
    ]

    # Initialize parent with tools
    super().__init__(name=name, tools=tools)

    # Store browser_tool as instance variable
    self.browser_tool = browser_tool

MCPToolkit

MCPToolkit(servers: Optional[list[MCPClient]] = None, config_path: Optional[str] = None, config: Optional[dict[str, Any]] = None)

Source code in evoagentx/tools/mcp.py

def __init__(self, servers: Optional[list[MCPClient]] = None, config_path: Optional[str] = None, config: Optional[dict[str, Any]] = None):
    parameters = []
    if config_path:
        parameters += self._from_config_file(config_path)
    if config:
        parameters += self._from_config(config)

    # Initialize servers list
    self.servers = []

    # Only create MCPClient if we have parameters
    if parameters:
        self.servers.append(MCPClient(parameters))

    # Add additional servers if provided
    if servers:
        self.servers.extend(servers)

    # Connect to all servers
    for server in self.servers:
        try:
            server._connect()
            logger.info("Successfully connected to MCP servers")
        except TimeoutError as e:
            logger.warning(f"Timeout connecting to MCP servers: {str(e)}. Some tools may not be available.")
        except Exception as e:
            logger.error(f"Error connecting to MCP servers: {str(e)}")

get_toolkits

get_toolkits() -> List[Toolkit]

Return a flattened list of all tools across all servers

Source code in evoagentx/tools/mcp.py

def get_toolkits(self) -> List[Toolkit]:
    """Return a flattened list of all tools across all servers"""
    all_tools = []
    if not self.servers:
        logger.info("No MCP servers configured, returning empty toolkit list")
        return all_tools

    for server in self.servers:
        try:
            tools = server.get_toolkits()
            all_tools.extend(tools)
            logger.info(f"Added {len(tools)} tools from MCP server")
        except Exception as e:
            logger.error(f"Error getting tools from MCP server: {str(e)}")
    return all_tools

BrowserUseToolkit

BrowserUseToolkit(name: str = 'BrowserUseToolkit', model: str = 'gpt-4o-mini', api_key: str = None, browser_type: str = 'chromium', headless: bool = True)

Bases: Toolkit

Toolkit for browser automation using Browser Use.

Initialize the BrowserUse toolkit.

Parameters:

Name	Type	Description	Default
name	str	Toolkit name	'BrowserUseToolkit'
model	str	LLM model to use	'gpt-4o-mini'
api_key	str	API key for the LLM	None
browser_type	str	Browser type (chromium, firefox, webkit)	'chromium'
headless	bool	Whether to run browser in headless mode	True

Source code in evoagentx/tools/browser_use.py

def __init__(self, name: str = "BrowserUseToolkit", model: str = "gpt-4o-mini", 
             api_key: str = None, browser_type: str = "chromium", 
             headless: bool = True):
    """
    Initialize the BrowserUse toolkit.

    Args:
        name: Toolkit name
        model: LLM model to use
        api_key: API key for the LLM
        browser_type: Browser type (chromium, firefox, webkit)
        headless: Whether to run browser in headless mode
    """
    # Create the shared browser base instance
    browser_base = BrowserUseBase(
        model=model,
        api_key=api_key,
        browser_type=browser_type,
        headless=headless
    )

    # Create tools with the shared base
    tools = [
        BrowserUseTool(browser_base=browser_base)
    ]

    # Initialize parent with tools
    super().__init__(name=name, tools=tools)

    # Store browser_base as instance variable
    self.browser_base = browser_base