Tools

A Tool in CAMEL is a callable function with a name, description, input parameters, and an output type.
Tools act as the interface between agents and the outside world—think of them like OpenAI Functions you can easily convert, extend, or use directly.

A Toolkit is a curated collection of related tools designed to work together for a specific purpose.
CAMEL provides a range of built-in toolkits—covering everything from web search and data extraction to code execution, GitHub integration, and much more.

To unlock advanced capabilities for your agents, install CAMEL’s extra tools package:

pip install ‘camel-ai[tools]’

A tool in CAMEL is just a FunctionTool—an interface any agent can call to run custom logic or access APIs.

You can easily create your own tools for any use case. Just write a Python function and wrap it using FunctionTool:

from camel.toolkits import FunctionTooldef add(a: int, b: int) -> int:
"""Adds two numbers."""
return a + badd_tool = FunctionTool(add)

Inspect your tool’s properties—such as its name, description, and OpenAI-compatible schema—using built-in methods:

print(add_tool.get_function_name())          # add
print(add_tool.get_function_description())   # Adds two numbers.
print(add_tool.get_openai_function_schema()) # OpenAI Functions schema
print(add_tool.get_openai_tool_schema())     # OpenAI Tool format

Toolkits group related tools for specialized tasks—search, math, or automation. Use built-in toolkits or build your own.

from camel.toolkits import SearchToolkit
toolkit = SearchToolkit()
tools = toolkit.get_tools()

You can also wrap toolkit methods as individual FunctionTools:

from camel.toolkits import FunctionTool, SearchToolkitgoogle_tool = FunctionTool(SearchToolkit().search_google)
wiki_tool = FunctionTool(SearchToolkit().search_wiki)

You can enhance any ChatAgent with custom or toolkit-powered tools. Just pass the tools during initialization:

from camel.agents import ChatAgenttool_agent = ChatAgent(
tools=tools,  # List of FunctionTools
)response = tool_agent.step(“A query related to the tool you added”)

CAMEL supports the Model Context Protocol (MCP), letting you expose any toolkit as a standalone server. This enables distributed tool execution and seamless integration across multiple systems—clients can remotely discover and invoke tools via a consistent protocol.

MCP (Model Context Protocol) is a unified protocol for connecting LLMs with external tools and services. In CAMEL, you can turn any toolkit into an MCP server, making its tools available for remote calls—ideal for building distributed, modular, and language-agnostic AI workflows.

Any CAMEL toolkit can run as an MCP server. Here’s how you can start an ArXiv toolkit server from a script:

import argparse
import sys

from camel.toolkits import ArxivToolkit

if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description="Run Arxiv Toolkit with MCP server mode.",
        usage=f"python {sys.argv[0]} [--mode MODE] [--timeout TIMEOUT]",
    )
    parser.add_argument(
        "--mode",
        choices=["stdio", "sse", "streamable-http"],
        default="stdio",
        help="MCP server mode (default: 'stdio')",
    )
    parser.add_argument(
        "--timeout",
        type=float,
        default=None,
        help="Timeout for the MCP server (default: None)",
    )

    args = parser.parse_args()
    toolkit = ArxivToolkit(timeout=args.timeout)
    toolkit.run_mcp_server(mode=args.mode)

Supported modes:

• stdio: Standard input/output (default)
• sse: Server-Sent Events
• streamable-http: Streamable HTTP

Define how to launch your MCP servers with a config file:

{
  "mcpServers": {
    "arxiv_toolkit": {
      "command": "python",
      "args": [
        "-m",
        "examples.mcp_arxiv_toolkit.arxiv_toolkit_server",
        "--timeout",
        "30"
      ]
    }
  }
}

From your client application, you can connect to MCP servers and use their tools remotely:

import asyncio
from mcp.types import CallToolResult
from camel.toolkits.mcp_toolkit import MCPToolkit, MCPClient

async def run_example():
    mcp_toolkit = MCPToolkit(config_path="path/to/mcp_servers_config.json")
    await mcp_toolkit.connect()

    mcp_client: MCPClient = mcp_toolkit.servers[0]

    res = await mcp_client.list_mcp_tools()
    if isinstance(res, str):
        raise Exception(res)
    tools = [tool.name for tool in res.tools]
    print(f"Available tools: {tools}")

    result: CallToolResult = await mcp_client.session.call_tool(
        "tool_name", {"param1": "value1", "param2": "value2"}
    )
    print(result.content[0].text)

    await mcp_toolkit.disconnect()

if __name__ == "__main__":
    asyncio.run(run_example())

• Distributed Execution: Run tools anywhere—across machines or containers.
• Process Isolation: Each toolkit runs in its own process for reliability and security.
• Resource Management: Allocate memory/CPU for heavy toolkits without impacting others.
• Scalability: Scale specific toolkits up or down as your workload changes.
• Language Interoperability: Implement MCP servers in any language that supports the protocol.

• Timeouts: Always set timeouts to prevent blocked operations.
• Error Handling: Implement robust error and exception handling in both server and client code.
• Resource Cleanup: Properly disconnect and free resources when finished.
• Configuration: Use config files or environment variables for flexible deployment.
• Monitoring: Add logging and health checks for production MCP deployments.

Tools—especially when deployed as MCP servers—are the bridge between CAMEL agents and the real world. With this architecture, you can empower agents to automate, fetch, compute, and integrate with almost any external system.