Skip to content

🛠️ 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