Skip to content

Tools

This page explores tools in Raikoo, which extend the capabilities of AI agents and operations. Tools enable AI models to perform actions beyond text generation, such as retrieving data, executing code, querying databases, and interacting with external systems.

What are Tools?

Tools in Raikoo are specialized components that give AI agents the ability to perform specific functions. When an AI agent needs to accomplish a task that requires more than natural language processing, such as executing a database query, reading a file, or making an HTTP request, it uses a tool.

Tools are configured per-agent, meaning each agent can have a different set of tools available based on its intended purpose and the permissions granted to it.

Built-in Tools

Raikoo includes 43+ built-in tools organized across several categories:

File Operations

Tools for reading, writing, and manipulating files in the workspace:

  • read_file - Read file contents
  • write_file - Create or overwrite files
  • edit_file - Make targeted edits to existing files
  • list_directory - List files and folders
  • glob - Pattern-based file searching
  • grep - Content-based file searching
  • delete_file - Remove files from workspace
  • create_directory - Create new folders

Code Execution

Tools for running code in various languages:

  • execute_python - Run Python code
  • execute_nodejs - Run JavaScript/Node.js code
  • execute_bash - Run Bash scripts
  • execute_powershell - Run PowerShell scripts

Database Tools

SQL Databases (PostgreSQL, MySQL/MariaDB, SQL Server)

  • sql_query - Execute SELECT queries
  • sql_execute - Execute INSERT, UPDATE, DELETE statements
  • sql_schema - Explore database structure, tables, columns, and constraints

MongoDB

  • mongodb_find - Query documents
  • mongodb_aggregate - Run aggregation pipelines
  • mongodb_modify - Insert, update, and delete documents
  • mongodb_schema - Explore collections and document structure

SQLite

  • sqlite_query - Query SQLite files in the workspace
  • sqlite_execute - Modify SQLite files in the workspace

Vector Store Operations

Tools for working with vector stores and RAG:

  • vector_search - Semantic search across document collections
  • vector_upsert - Add or update vectors
  • vector_delete - Remove vectors

Communication Tools

Tools for interacting with external platforms:

  • teams_send_message - Send messages to Microsoft Teams
  • slack_send_message - Send messages to Slack channels
  • email_send - Send emails via Outlook
  • sms_send - Send SMS messages via Twilio

AI & Agent Tools

Tools for advanced AI capabilities:

  • sub_agent - Invoke another agent as a tool
  • workflow_execute - Execute a workflow programmatically
  • tool_composition - Combine multiple tools into complex operations

Utility Tools

General-purpose tools for common tasks:

  • web_search - Search the internet
  • http_request - Make HTTP API calls
  • json_parse - Parse and manipulate JSON data
  • xml_parse - Parse and manipulate XML data
  • csv_parse - Parse and manipulate CSV data
  • markdown_render - Convert Markdown to HTML
  • template_render - Apply template transformations

For detailed information on each tool, including parameters and usage examples, see the Agent Tools Reference.

MCP Tools

Raikoo supports the Model Context Protocol (MCP), an open standard for connecting AI systems to external tools and data sources. MCP tools enable integration with services beyond Raikoo's built-in capabilities.

What is MCP?

The Model Context Protocol is a standardized way for AI applications to interact with external tools. It defines a common interface for tool discovery, invocation, and result handling, making it easy to extend AI agents with new capabilities without custom integration code.

Transport Protocols

MCP tools can use two transport mechanisms:

Transport Description Use Case
HTTP Standard HTTP requests Stateless tools, REST APIs
SSE (Server-Sent Events) Persistent connection with streaming updates Real-time data, long-running operations

Authentication Methods

MCP tools support two authentication approaches:

Bearer Token Authentication

Simple token-based authentication where Raikoo sends a static token with each request:

  1. Configure the MCP tool with a bearer token
  2. Token is included in the Authorization header
  3. Best for service-to-service authentication

OAuth 2.0 Authentication

Full OAuth flow for user-authenticated access:

  1. Configure OAuth client credentials
  2. User completes OAuth authorization flow
  3. Raikoo manages token refresh automatically
  4. Best for user-scoped access to external services

Configuring MCP Tools

To add an MCP tool to an agent:

  1. Navigate to your agent's configuration
  2. Go to the Tools section
  3. Click "Add Tool" and select "MCP Tool"
  4. Configure the tool:
    • Name - Identifier for the tool
    • Description - What the tool does (helps the AI decide when to use it)
    • Endpoint URL - URL of the MCP service
    • Transport - HTTP or SSE
    • Authentication - Bearer token or OAuth
    • Tool Schema - JSON schema defining the tool's parameters

Custom Tools

For specialized needs beyond built-in and MCP tools, you can develop custom tools using JavaScript or TypeScript.

Creating a Custom Tool

Custom tools are defined at the project level and can be reused across multiple agents within that project:

  1. Define the tool's purpose - Determine what functionality your tool will provide
  2. Implement the tool function - Write JavaScript or TypeScript code that performs the desired action
  3. Specify input parameters - Define what inputs the tool requires using JSON Schema
  4. Structure the outputs - Determine how results will be returned to the AI agent
  5. Add error handling - Ensure the tool degrades gracefully when issues occur
  6. Test thoroughly - Verify the tool works as expected in different scenarios

Custom Tool Structure

A custom tool consists of:

  • Name - Unique identifier for the tool
  • Description - Clear explanation of what the tool does and when to use it
  • Parameters Schema - JSON Schema defining expected inputs
  • Implementation Code - JavaScript/TypeScript function that executes the tool logic
  • Return Format - Structured output that the AI agent can understand

Custom tools have access to:

  • Input parameters passed by the AI agent
  • Workspace file system for reading and writing data
  • Environment variables for configuration
  • External APIs and services (via HTTP requests)

Tool Configuration

Tools are configured on a per-agent basis, allowing fine-grained control over agent capabilities.

Enabling and Disabling Tools

Each agent has a Tools section where you can:

  • Add tools - Select from built-in, MCP, or custom tools
  • Remove tools - Disable tools the agent shouldn't use
  • Reorder tools - Adjust tool priority (affects suggestion order)

Custom Names and Descriptions

When adding a tool to an agent, you can optionally customize:

  • Tool Name - Override the default name (useful for multiple instances of the same tool type)
  • Tool Description - Customize the description to better guide the agent on when to use the tool

Custom descriptions are particularly valuable for helping agents choose the right tool in complex scenarios. A well-written description explains:

  • What the tool does
  • When it should be used
  • What type of input it expects
  • What kind of output it produces

Tool-Specific Configuration

Many tools have additional configuration options:

Database Tools - Database Connection - Which database connection to use - Allow Write - Whether modifications are permitted (for execute/modify tools)

MCP Tools - Endpoint URL - Location of the MCP service - Authentication - Bearer token or OAuth credentials - Transport - HTTP or SSE protocol

Vector Store Tools - Vector Store Connection - Which vector store to use - Collection/Index - Target collection or index name

Communication Tools - External Connection - Which platform credentials to use - Channel/Recipient - Default destination for messages

Best Practices for Tool Usage

To get the most from tools in your agents:

Start Simple

Begin with built-in tools before creating custom ones. Raikoo's built-in tools cover most common use cases and are well-tested.

Focus on Specific Needs

Design custom tools for clear, well-defined purposes. A tool that does one thing well is better than a tool that tries to do everything.

Write Clear Descriptions

Tool descriptions guide the AI in choosing when to use each tool. Be specific about:

  • The tool's purpose
  • What inputs it expects
  • What outputs it produces
  • When it should (and shouldn't) be used

Handle Edge Cases

Ensure custom tools are robust against unexpected inputs:

  • Validate input parameters
  • Handle missing or malformed data gracefully
  • Return clear error messages
  • Don't expose sensitive information in errors

Consider Reusability

Create custom tools at the project level so they can be used across multiple agents. Well-designed tools become valuable shared resources.

Balance Tool Count

While agents can use many tools, too many options can degrade performance and accuracy. Provide agents with the tools they need, but avoid overwhelming them with unnecessary choices.

Test Tool Interactions

When agents use multiple tools together, test how they interact:

  • Do tools work well in sequence?
  • Can tools share data effectively?
  • Are there conflicts or redundancies?

Tool Execution Flow

Understanding how tools are executed helps in designing effective agents:

  1. User Input - User sends a message or workflow starts
  2. Agent Processing - AI agent analyzes the request
  3. Tool Selection - Agent decides which tool(s) to use based on descriptions and context
  4. Tool Invocation - Agent calls the tool with appropriate parameters
  5. Tool Execution - Tool performs its function and returns results
  6. Result Processing - Agent incorporates tool results into its understanding
  7. Iteration - Agent may call additional tools based on results (up to max tool roundtrips)
  8. Response - Agent provides final response incorporating all tool results

The max tool roundtrips setting on each agent controls how many iterations of this cycle can occur, preventing infinite loops while allowing complex multi-step reasoning.

Conclusion

Tools are essential components that extend AI agents beyond pure language processing into practical, real-world capabilities. With 43+ built-in tools, MCP support for external integrations, and the ability to create custom tools, Raikoo provides a comprehensive toolkit for building powerful AI agents.

By carefully selecting and configuring the right tools for each agent, you can create specialized AI assistants that interact with databases, execute code, communicate across platforms, and automate complex workflows.

For detailed information on specific tools, see the Agent Tools Reference. To learn about configuring database tools, see the Databases Guide.