Tools

For more detailed usage information, please refer to our cookbook: Tools Cookbook

​

1. Concept

Tools serve as interfaces that allow LLMs and Agents to interact with the world. A tool is essentially a function that has a name, a description, input parameters, and an output type. In this section, we will introduce the tools currently supported by CAMEL and explain how to define your own tools and Toolkits.

Tools: Tools are akin to OpenAI Functions and can be easily converted to that format. In CAMEL, we offer a variety of commonly used tools that you can utilize directly. While built-in tools can be quite useful, it’s highly likely that you’ll need to define your own tools. This guide for detailed instructions on how to create custom tools.

Toolkits: Toolkits are collections of tools that are designed to work well together.

​

2. Get Started

To enhance your agents’ capabilities with CAMEL tools, start by installing our additional tools package:

pip install 'camel-ai[tools]'

In CAMEL, a tool is an FunctionTool that LLMs can call.

​

2.1 How to Define Your Own Tool?

Developers can create custom tools tailored to their agent’s specific needs with ease. Here’s how you can define and use a custom tool:

Example: Adding Two Numbers

First, define your function and wrap it using the FunctionTool

from camel.toolkits import FunctionTool

def add(a: int, b: int) -> int:
    r"""Adds two numbers.

    Args:
        a (int): The first number to be added.
        b (int): The second number to be added.

    Returns:
        integer: The sum of the two numbers.
    """
    return a + b

# Wrap the function with FunctionTool
add_tool = FunctionTool(add)

Accessing Tool Properties

Once your tool is defined, you can inspect its properties using built-in methods:

Retrieve the function’s name:

print(add_tool.get_function_name())

>>> add

Get the description of what the function does:

print(add_tool.get_function_description())

>>> Adds two numbers.

Fetch the schema representation for OpenAI functions:

print(add_tool.get_openai_function_schema())

>>> 
{'name': 'add',
 'description': 'Adds two numbers.',
 'parameters': {'properties': {'a': {'type': 'integer',
    'description': 'The first number to be added.'},
   'b': {'type': 'integer', 'description': 'The second number to be added.'}},
  'required': ['a', 'b'],
  'type': 'object'}}

Retrieve the tool schema, compatible with OpenAI’s structure:

print(add_tool.get_openai_tool_schema())

>>> 
{'type': 'function',
 'function': {'name': 'add',
  'description': 'Adds two numbers.',
  'parameters': {'properties': {'a': {'type': 'integer',
     'description': 'The first number to be added.'},
    'b': {'type': 'integer', 'description': 'The second number to be added.'}},
   'required': ['a', 'b'],
   'type': 'object'}}}

​

2.2 Toolkits

Toolkits are collections of tools that are designed to be used together for specific tasks. All Toolkits expose a get_tools method which returns a list of tools. You can therefore do:

from camel.toolkits import SearchToolkit

# Initialize a toolkit
toolkit = SearchToolkit()

# Get list of tools
tools = toolkit.get_tools()

To utilize specific tools from the toolkits, you can implement code like the following:

from camel.toolkits import FunctionTool, SearchToolkit

google_tool = FunctionTool(SearchToolkit().search_google)
wiki_tool = FunctionTool(SearchToolkit().search_wiki)

​

2.3 Passing Tools to ChatAgent

Enhance the functionality of a ChatAgent by passing custom tools during initialization. Here’s how you can do it:

from camel.agents import ChatAgent

# Initialize a ChatAgent with your custom tools
tool_agent = ChatAgent(
    tools=tools,
)

# Interact with the agent
response = tool_agent.step("A query related to the tool you added")

​

3. Built-in Toolkits

CAMEL provides a variety of built-in toolkits that you can use right away. Here’s a comprehensive list of available toolkits:

​

4. Using Toolkits as MCP Servers

CAMEL supports the Model Context Protocol (MCP), which allows you to expose toolkits as standalone servers that can be accessed by clients. This enables distributed tool execution and integration with various systems.

​

4.1 What is MCP?

Model Context Protocol (MCP) is a protocol that enables language models to interact with external tools and services. In CAMEL, toolkits can be exposed as MCP servers, allowing clients to discover and call tools remotely.

​

4.2 Creating an MCP Server from a Toolkit

Any CAMEL toolkit can be exposed as an MCP server. Here’s how to create an MCP server using the ArXiv toolkit as an example:

# arxiv_toolkit_server.py
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)

    # Run the toolkit as an MCP server
    toolkit.run_mcp_server(mode=args.mode)

The server can be run in two modes:

• stdio: Standard input/output mode (default)
• sse: Server-Sent Events mode

​

4.3 Configuring MCP Servers

Create a configuration file (e.g., mcp_servers_config.json) to specify how to launch your MCP servers:

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

​

4.4 Connecting to MCP Servers from a Client

You can connect to MCP servers and use their tools from a client application:

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

async def run_example():
    # Initialize the MCPToolkit with your configuration file
    mcp_toolkit = MCPToolkit(config_path="path/to/mcp_servers_config.json")

    # Connect to all configured MCP servers
    await mcp_toolkit.connect()

    # Get the first MCP server
    mcp_client: MCPClient = mcp_toolkit.servers[0]
    
    # List available tools from the server
    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}")

    # Call a tool from the server
    result: CallToolResult = await mcp_client.session.call_tool(
        "tool_name", {"param1": "value1", "param2": "value2"}
    )
    print(result.content[0].text)

    # Disconnect from all servers
    await mcp_toolkit.disconnect()

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

​

4.5 Benefits of Using MCP Servers

1. Distributed Execution: Run tools on separate machines or processes.
2. Isolation: Each toolkit runs in its own process, providing better isolation and stability.
3. Resource Management: Allocate resources to specific toolkits based on their requirements.
4. Scalability: Scale individual toolkits independently based on demand.
5. Language Interoperability: MCP servers can be implemented in different programming languages.

​

4.6 Best Practices

• Timeouts: Always set appropriate timeouts to prevent hanging operations.
• Error Handling: Implement proper error handling for both server and client sides.
• Resource Cleanup: Ensure proper disconnection from servers when done.
• Configuration Management: Use environment variables or configuration files for server settings.
• Monitoring: Implement logging and monitoring for MCP servers in production environments.

​

5. Conclusion

Tools are essential for extending the capabilities of CAMEL agents, empowering them to perform a wide range of tasks and collaborate efficiently.