🛠️ 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"}, ...}

DockerInterpreterToolkit

DockerInterpreterToolkit(name: str = 'DockerInterpreterToolkit', image_tag: Optional[str] = None, dockerfile_path: Optional[str] = None, require_confirm: bool = False, print_stdout: bool = True, print_stderr: bool = True, host_directory: str = '', container_directory: str = '/home/app/', container_command: str = 'tail -f /dev/null', tmp_directory: str = '/tmp', storage_handler: FileStorageHandler = None, auto_cleanup: bool = True, auto_destroy: bool = True, **kwargs)

Bases: Toolkit

Source code in evoagentx/tools/interpreter_docker.py

def __init__(
    self,
    name: str = "DockerInterpreterToolkit",
    image_tag: Optional[str] = None,
    dockerfile_path: Optional[str] = None,
    require_confirm: bool = False,
    print_stdout: bool = True,
    print_stderr: bool = True,
    host_directory: str = "",
    container_directory: str = "/home/app/",
    container_command: str = "tail -f /dev/null",
    tmp_directory: str = "/tmp",
    storage_handler: FileStorageHandler = None,
    auto_cleanup: bool = True,
    auto_destroy: bool = True,
    **kwargs
):
    # Initialize storage handler if not provided
    if storage_handler is None:
        from .storage_handler import LocalStorageHandler
        storage_handler = LocalStorageHandler(base_path="./workplace/docker")

    # Create the shared Docker interpreter instance with storage handler
    docker_interpreter = DockerInterpreter(
        name="DockerInterpreter",
        image_tag=image_tag,
        dockerfile_path=dockerfile_path,
        require_confirm=require_confirm,
        print_stdout=print_stdout,
        print_stderr=print_stderr,
        host_directory=host_directory,
        container_directory=container_directory,
        container_command=container_command,
        tmp_directory=tmp_directory,
        storage_handler=storage_handler,
        auto_cleanup=auto_cleanup,
        auto_destroy=auto_destroy,
        **kwargs
    )

    # Create tools with the shared interpreter
    tools = [
        DockerExecuteTool(docker_interpreter=docker_interpreter),
        DockerExecuteScriptTool(docker_interpreter=docker_interpreter)
    ]

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

    # Store docker_interpreter as instance variable
    self.docker_interpreter = docker_interpreter
    self.storage_handler = storage_handler
    self.auto_cleanup = auto_cleanup
    self.auto_destroy = auto_destroy

cleanup

cleanup()

Clean up the Docker interpreter and storage handler.

Source code in evoagentx/tools/interpreter_docker.py

def cleanup(self):
    """Clean up the Docker interpreter and storage handler."""
    try:
        if hasattr(self, 'auto_cleanup') and self.auto_cleanup:
            if hasattr(self, 'docker_interpreter') and self.docker_interpreter:
                self.docker_interpreter.cleanup()
            if hasattr(self, 'storage_handler') and self.storage_handler:
                try:
                    self.storage_handler.cleanup()
                except Exception:
                    pass
    except Exception:
        pass  # Silently ignore cleanup errors

__del__

__del__()

Cleanup when toolkit is destroyed.

Source code in evoagentx/tools/interpreter_docker.py

def __del__(self):
    """Cleanup when toolkit is destroyed."""
    try:
        if hasattr(self, 'auto_destroy') and self.auto_destroy:
            self.cleanup()
    except Exception:
        pass  # Silently ignore errors during destruction

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
    failed_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.")
            failed_servers.append(server)
        except Exception as e:
            logger.error(f"Error connecting to MCP servers: {str(e)}")
            failed_servers.append(server)

    # Remove failed servers
    for failed_server in failed_servers:
        if failed_server in self.servers:
            self.servers.remove(failed_server)

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:
            # Add timeout to prevent hanging
            import threading
            import queue

            result_queue = queue.Queue()
            exception_queue = queue.Queue()

            def get_tools_with_timeout():
                try:
                    tools = server.get_toolkits()
                    result_queue.put(tools)
                except Exception as e:
                    exception_queue.put(e)

            # Start tool retrieval in a separate thread with timeout
            thread = threading.Thread(target=get_tools_with_timeout)
            thread.daemon = True
            thread.start()
            thread.join(timeout=30)  # 30 second timeout

            if thread.is_alive():
                logger.warning("Timeout getting tools from MCP server after 30 seconds")
                continue

            if not exception_queue.empty():
                raise exception_queue.get()

            tools = result_queue.get()
            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

GoogleMapsToolkit

GoogleMapsToolkit(api_key: str = None, timeout: int = 10, name: str = 'GoogleMapsToolkit')

Bases: Toolkit

Complete Google Maps Platform toolkit containing all available tools.

Initialize the Google Maps toolkit.

Parameters:

Name	Type	Description	Default
api_key	str	Google Maps Platform API key. If not provided, will try to get from GOOGLE_MAPS_API_KEY environment variable.	None
timeout	int	Request timeout in seconds	10
name	str	Toolkit name	'GoogleMapsToolkit'

Source code in evoagentx/tools/google_maps_tool.py

def __init__(self, api_key: str = None, timeout: int = 10, name: str = "GoogleMapsToolkit"):
    """
    Initialize the Google Maps toolkit.

    Args:
        api_key (str, optional): Google Maps Platform API key. If not provided, will try to get from GOOGLE_MAPS_API_KEY environment variable.
        timeout (int): Request timeout in seconds
        name (str): Toolkit name
    """
    # Create shared Google Maps base instance
    google_maps_base = GoogleMapsBase(api_key=api_key, timeout=timeout)

    # Create all tools with shared base
    tools = [
        GeocodeAddressTool(google_maps_base=google_maps_base),
        ReverseGeocodeTool(google_maps_base=google_maps_base),
        PlacesSearchTool(google_maps_base=google_maps_base),
        PlaceDetailsTool(google_maps_base=google_maps_base),
        DirectionsTool(google_maps_base=google_maps_base),
        DistanceMatrixTool(google_maps_base=google_maps_base),
        TimeZoneTool(google_maps_base=google_maps_base)
    ]

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

    # Store base instance for access
    self.google_maps_base = google_maps_base

MongoDBToolkit

MongoDBToolkit(name: str = 'MongoDBToolkit', connection_string: str = None, database_name: str = None, local_path: str = None, auto_save: bool = True, read_only: bool = False, **kwargs)

Bases: Toolkit

MongoDB-specific toolkit with simplified design. Automatically handles remote, local file-based, or new database creation.

Initialize the MongoDB toolkit.

Parameters:

Name	Type	Description	Default
name	str	Name of the toolkit	'MongoDBToolkit'
connection_string	str	MongoDB connection string (for remote/existing)	None
database_name	str	Name of the database to use	None
local_path	str	Path for local file-based database	None
auto_save	bool	Automatically save changes to local files	True
read_only	bool	If True, only read operations are allowed (no insert, update, delete)	False
**kwargs		Additional connection parameters	{}

Source code in evoagentx/tools/database_mongodb.py

def __init__(self, 
             name: str = "MongoDBToolkit",
             connection_string: str = None,
             database_name: str = None,
             local_path: str = None,
             auto_save: bool = True,
             read_only: bool = False,
             **kwargs):
    """
    Initialize the MongoDB toolkit.

    Args:
        name: Name of the toolkit
        connection_string: MongoDB connection string (for remote/existing)
        database_name: Name of the database to use
        local_path: Path for local file-based database
        auto_save: Automatically save changes to local files
        read_only: If True, only read operations are allowed (no insert, update, delete)
        **kwargs: Additional connection parameters
    """
    # Initialize database with automatic detection
    database = MongoDBDatabase(
        connection_string=connection_string,
        database_name=database_name,
        local_path=local_path,
        auto_save=auto_save,
        read_only=read_only,
        **kwargs
    )

    # Initialize tools based on read-only mode
    if read_only:
        # Only include read-only tools
        tools = [
            MongoDBExecuteQueryTool(database=database),
            MongoDBFindTool(database=database),
            MongoDBInfoTool(database=database)
        ]
    else:
        # Include all tools for write mode
        tools = [
            MongoDBExecuteQueryTool(database=database),
            MongoDBFindTool(database=database),
            MongoDBUpdateTool(database=database),
            MongoDBDeleteTool(database=database),
            MongoDBInfoTool(database=database)
        ]

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

    # Store configuration after parent initialization
    self.database = database
    self.connection_string = connection_string
    self.database_name = database_name
    self.local_path = local_path
    self.auto_save = auto_save

    # Set up automatic cleanup
    import atexit
    atexit.register(self._cleanup)

get_capabilities

get_capabilities() -> Dict[str, Any]

Get MongoDB-specific capabilities

Source code in evoagentx/tools/database_mongodb.py

def get_capabilities(self) -> Dict[str, Any]:
    """Get MongoDB-specific capabilities"""
    if self.database:
        capabilities = self.database.get_capabilities()
        capabilities.update({
            "is_local_database": self.database.is_local_database,
            "local_path": str(self.database.local_path) if self.database.local_path else None,
            "auto_save": self.database.auto_save,
            "read_only": self.database.read_only
        })
        return capabilities
    return {"error": "MongoDB database not initialized"}

connect

connect() -> bool

Connect to MongoDB

Source code in evoagentx/tools/database_mongodb.py

def connect(self) -> bool:
    """Connect to MongoDB"""
    return self.database.connect() if self.database else False

disconnect

disconnect() -> bool

Disconnect from MongoDB

Source code in evoagentx/tools/database_mongodb.py

def disconnect(self) -> bool:
    """Disconnect from MongoDB"""
    return self.database.disconnect() if self.database else False

test_connection

test_connection() -> bool

Test MongoDB connection

Source code in evoagentx/tools/database_mongodb.py

def test_connection(self) -> bool:
    """Test MongoDB connection"""
    return self.database.test_connection() if self.database else False

get_database

get_database() -> MongoDBDatabase

Get the underlying MongoDB database instance

Source code in evoagentx/tools/database_mongodb.py

def get_database(self) -> MongoDBDatabase:
    """Get the underlying MongoDB database instance"""
    return self.database

get_local_info

get_local_info() -> Dict[str, Any]

Get information about local database setup

Source code in evoagentx/tools/database_mongodb.py

def get_local_info(self) -> Dict[str, Any]:
    """Get information about local database setup"""
    return {
        "is_local_database": self.database.is_local_database,
        "local_path": str(self.database.local_path) if self.database.local_path else None,
        "auto_save": self.database.auto_save,
        "read_only": self.database.read_only,
        "database_name": self.database_name,
        "connection_string": self.connection_string
    } if self.database else {"error": "Database not initialized"}

FileStorageHandler

FileStorageHandler(base_path: str = '.', **kwargs)

Bases: StorageBase

Reference implementation showing all available _raw_xxx methods. This class serves as a template for developers creating new storage handlers. Concrete handlers only need to implement the _raw_xxx methods they need.

Initialize the storage handler.

Parameters:

Name	Type	Description	Default
base_path	str	Base directory for storage operations (default: current directory)	'.'
**kwargs		Additional keyword arguments for parent class initialization	{}

Source code in evoagentx/tools/storage_handler.py

def __init__(self, base_path: str = ".", **kwargs):
    """
    Initialize the storage handler.

    Args:
        base_path (str): Base directory for storage operations (default: current directory)
        **kwargs: Additional keyword arguments for parent class initialization
    """
    super().__init__(base_path=base_path, **kwargs)

LocalStorageHandler

LocalStorageHandler(base_path: str = '.', **kwargs)

Bases: FileStorageHandler

Local filesystem storage implementation. Provides all file operations for local storage with default working directory.

Initialize local storage handler.

Parameters:

Name	Type	Description	Default
base_path	str	Base directory for storage operations (default: current directory)	'.'
**kwargs		Additional keyword arguments for parent class initialization	{}

Source code in evoagentx/tools/storage_handler.py

def __init__(self, base_path: str = ".", **kwargs):
    """
    Initialize local storage handler.

    Args:
        base_path (str): Base directory for storage operations (default: current directory)
        **kwargs: Additional keyword arguments for parent class initialization
    """
    super().__init__(base_path=base_path, **kwargs)

SupabaseStorageHandler

SupabaseStorageHandler(bucket_name: str = None, base_path: str = '/', **kwargs)

Bases: FileStorageHandler

Supabase remote storage implementation. Provides file operations via Supabase Storage API with environment-based configuration.

Initialize Supabase storage handler.

Parameters:

Name	Type	Description	Default
bucket_name	str	Supabase storage bucket name (default: from environment or "default")	None
base_path	str	Base path for storage operations (default: "/")	'/'
**kwargs		Additional keyword arguments for parent class initialization	{}

Source code in evoagentx/tools/storage_handler.py

def __init__(self, bucket_name: str = None, base_path: str = "/", **kwargs):
    """
    Initialize Supabase storage handler.

    Args:
        bucket_name: Supabase storage bucket name (default: from environment or "default")
        base_path: Base path for storage operations (default: "/")
        **kwargs: Additional keyword arguments for parent class initialization
    """
    # Call parent constructor first
    super().__init__(base_path=base_path, **kwargs)

    # Get bucket name from environment or use default
    self.bucket_name = bucket_name or os.getenv("SUPABASE_BUCKET_STORAGE") or "default"
    self.supabase_url = os.getenv("SUPABASE_URL_STORAGE")
    self.supabase_key = os.getenv("SUPABASE_KEY_STORAGE")

    if not self.supabase_url or not self.supabase_key:
        raise ValueError(
            "Supabase configuration not found in environment variables. "
            "Please set SUPABASE_URL/SUPABASE_KEY environment variables."
        )

    # Initialize Supabase client
    try:
        from supabase import create_client, Client
        logger.info(f"Creating Supabase client with URL: {self.supabase_url[:30]}...")
        self.supabase: Client = create_client(self.supabase_url, self.supabase_key)
        logger.info(f"Successfully initialized Supabase client for bucket: {bucket_name}")
    except ImportError:
        raise ImportError(
            "Supabase Python client not installed. "
            "Please install it with: pip install supabase"
        )
    except Exception as e:
        logger.error(f"Failed to initialize Supabase client: {str(e)}")
        raise Exception(f"Failed to initialize Supabase client: {str(e)}")

    # Initialize storage after all attributes are set
    self._initialize_storage()

translate_in

translate_in(file_path: str) -> str

Resolve file path for remote storage

Source code in evoagentx/tools/storage_handler.py

def translate_in(self, file_path: str) -> str:
    """Resolve file path for remote storage"""
    # Use the translate_in method to combine base_path with file_path
    # For Supabase, we need to handle the special case where base_path is "/"
    if self.base_path == "/":
        # If base_path is "/", just clean the file_path
        return file_path.lstrip('/')
    else:
        # Use the standard translate_in method
        return super().translate_in(file_path)

StorageToolkit

StorageToolkit(name: str = 'StorageToolkit', base_path: str = './workplace/storage', storage_handler: LocalStorageHandler = None)

Bases: Toolkit

Comprehensive storage toolkit with local filesystem operations. Provides tools for reading, writing, appending, deleting, moving, copying files, creating directories, and listing files with support for various file formats.

Initialize the storage toolkit.

Parameters:

Name	Type	Description	Default
name	str	Name of the toolkit	'StorageToolkit'
base_path	str	Base directory for storage operations (default: ./workplace/storage)	'./workplace/storage'
storage_handler	LocalStorageHandler	Storage handler instance (defaults to LocalStorageHandler)	None

Source code in evoagentx/tools/storage_file.py

def __init__(self, name: str = "StorageToolkit", base_path: str = "./workplace/storage", storage_handler: LocalStorageHandler = None):
    """
    Initialize the storage toolkit.

    Args:
        name: Name of the toolkit
        base_path: Base directory for storage operations (default: ./workplace/storage)
        storage_handler: Storage handler instance (defaults to LocalStorageHandler)
    """
    if not storage_handler:
        storage_handler = LocalStorageHandler(base_path=base_path)

    # Create tools with the storage handler
    tools = [
        SaveTool(storage_handler=storage_handler),
        ReadTool(storage_handler=storage_handler),
        AppendTool(storage_handler=storage_handler),
        DeleteTool(storage_handler=storage_handler),
        MoveTool(storage_handler=storage_handler),
        CopyTool(storage_handler=storage_handler),
        CreateDirectoryTool(storage_handler=storage_handler),
        ListFileTool(storage_handler=storage_handler),
        ExistsTool(storage_handler=storage_handler)
    ]

    super().__init__(name=name, tools=tools)
    self.storage_handler = storage_handler 

CMDToolkit

CMDToolkit(name: str = 'CMDToolkit', default_shell: str = None, storage_handler: FileStorageHandler = None)

Bases: Toolkit

Command line toolkit that provides safe command execution with permission checking and cross-platform support. Supports Linux, macOS, and Windows.

Initialize the CMDToolkit with a shared command base instance.

Parameters:

Name	Type	Description	Default
name	str	Name of the toolkit	'CMDToolkit'
default_shell	str	Override default shell detection	None
storage_handler	FileStorageHandler	Storage handler for file operations	None

Source code in evoagentx/tools/cmd_toolkit.py

def __init__(self, name: str = "CMDToolkit", default_shell: str = None, storage_handler: FileStorageHandler = None):
    """
    Initialize the CMDToolkit with a shared command base instance.

    Args:
        name: Name of the toolkit
        default_shell: Override default shell detection
        storage_handler: Storage handler for file operations
    """
    # Initialize storage handler if not provided
    if storage_handler is None:
        from .storage_handler import LocalStorageHandler
        storage_handler = LocalStorageHandler(base_path="./workplace/cmd")

    # Create the shared command base instance with storage handler
    cmd_base = CMDBase(default_shell=default_shell, storage_handler=storage_handler)

    # Initialize tools with the shared command base
    tools = [
        ExecuteCommandTool(cmd_base=cmd_base)
    ]

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

RSSToolkit

RSSToolkit(name: str = 'RSSToolkit')

Bases: Toolkit

Toolkit for RSS feed operations.

Source code in evoagentx/tools/rss_feed.py

def __init__(self, name: str = "RSSToolkit"):
    # Create the shared RSS base instance
    rss_base = RSSBase()

    # Create tools with the shared RSS base
    tools = [
        RSSFetchTool(rss_base=rss_base),
        RSSValidateTool(rss_base=rss_base)
    ]

    super().__init__(name=name, tools=tools)

SerperAPIToolkit

SerperAPIToolkit(name: str = 'SerperAPIToolkit', api_key: Optional[str] = None, num_search_pages: Optional[int] = 10, max_content_words: Optional[int] = None, default_location: Optional[str] = None, default_language: Optional[str] = 'en', default_country: Optional[str] = 'us', enable_content_scraping: Optional[bool] = True, **kwargs)

Bases: Toolkit

Initialize SerperAPI Toolkit.

Parameters:

Name	Type	Description	Default
name	str	Name of the toolkit	'SerperAPIToolkit'
api_key	str	SerperAPI authentication key	None
num_search_pages	int	Default number of search results to retrieve	10
max_content_words	int	Default maximum words per result content	None
default_location	str	Default geographic location	None
default_language	str	Default interface language	'en'
default_country	str	Default country code	'us'
enable_content_scraping	bool	Whether to enable content scraping	True
**kwargs		Additional keyword arguments	{}

Source code in evoagentx/tools/search_serperapi.py

def __init__(
    self,
    name: str = "SerperAPIToolkit",
    api_key: Optional[str] = None,
    num_search_pages: Optional[int] = 10,
    max_content_words: Optional[int] = None,
    default_location: Optional[str] = None,
    default_language: Optional[str] = "en",
    default_country: Optional[str] = "us",
    enable_content_scraping: Optional[bool] = True,
    **kwargs
):
    """
    Initialize SerperAPI Toolkit.

    Args:
        name (str): Name of the toolkit
        api_key (str): SerperAPI authentication key
        num_search_pages (int): Default number of search results to retrieve
        max_content_words (int): Default maximum words per result content
        default_location (str): Default geographic location
        default_language (str): Default interface language
        default_country (str): Default country code
        enable_content_scraping (bool): Whether to enable content scraping
        **kwargs: Additional keyword arguments
    """
    # Create the shared SerperAPI search instance
    search_serperapi = SearchSerperAPI(
        name="SearchSerperAPI",
        api_key=api_key,
        num_search_pages=num_search_pages,
        max_content_words=max_content_words,
        default_location=default_location,
        default_language=default_language,
        default_country=default_country,
        enable_content_scraping=enable_content_scraping,
        **kwargs
    )

    # Create tools with the shared search instance
    tools = [
        SerperAPITool(search_serperapi=search_serperapi)
    ]

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

    # Store search_serperapi as instance variable
    self.search_serperapi = search_serperapi

SerpAPIToolkit

SerpAPIToolkit(name: str = 'SerpAPIToolkit', api_key: Optional[str] = None, num_search_pages: Optional[int] = 5, max_content_words: Optional[int] = None, default_engine: Optional[str] = 'google', default_location: Optional[str] = None, default_language: Optional[str] = 'en', default_country: Optional[str] = 'us', enable_content_scraping: Optional[bool] = True, **kwargs)

Bases: Toolkit

Initialize SerpAPI Toolkit.

Parameters:

Name	Type	Description	Default
name	str	Name of the toolkit	'SerpAPIToolkit'
api_key	str	SerpAPI authentication key	None
num_search_pages	int	Default number of search results to retrieve	5
max_content_words	int	Default maximum words per result content	None
default_engine	str	Default search engine	'google'
default_location	str	Default geographic location	None
default_language	str	Default interface language	'en'
default_country	str	Default country code	'us'
enable_content_scraping	bool	Whether to enable content scraping	True
**kwargs		Additional keyword arguments	{}

Source code in evoagentx/tools/search_serpapi.py

def __init__(
    self,
    name: str = "SerpAPIToolkit",
    api_key: Optional[str] = None,
    num_search_pages: Optional[int] = 5,
    max_content_words: Optional[int] = None,
    default_engine: Optional[str] = "google",
    default_location: Optional[str] = None,
    default_language: Optional[str] = "en",
    default_country: Optional[str] = "us",
    enable_content_scraping: Optional[bool] = True,
    **kwargs
):
    """
    Initialize SerpAPI Toolkit.

    Args:
        name (str): Name of the toolkit
        api_key (str): SerpAPI authentication key
        num_search_pages (int): Default number of search results to retrieve
        max_content_words (int): Default maximum words per result content
        default_engine (str): Default search engine
        default_location (str): Default geographic location
        default_language (str): Default interface language
        default_country (str): Default country code
        enable_content_scraping (bool): Whether to enable content scraping
        **kwargs: Additional keyword arguments
    """
    # Create the shared SerpAPI search instance
    search_serpapi = SearchSerpAPI(
        name="SearchSerpAPI",
        api_key=api_key,
        num_search_pages=num_search_pages,
        max_content_words=max_content_words,
        default_engine=default_engine,
        default_location=default_location,
        default_language=default_language,
        default_country=default_country,
        enable_content_scraping=enable_content_scraping,
        **kwargs
    )

    # Create tools with the shared search instance
    tools = [
        SerpAPITool(search_serpapi=search_serpapi)
    ]

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

    # Store search_serpapi as instance variable
    self.search_serpapi = search_serpapi