Using Tools - Flowise

Tools give your AI agents the ability to interact with external systems, perform calculations, search the web, call APIs, and much more. Flowise provides a rich library of pre-built tools and supports custom tool creation.

What are Tools?

Tools are functions that agents can call to:

Search Information: Web search, Wikipedia, Arxiv
Perform Actions: Send emails, create calendar events, post to Slack
Process Data: Calculate, parse JSON, transform data
Query Systems: Database queries, API calls
Retrieve Documents: Vector store searches, document lookups

Agents use tools autonomously by deciding when and how to use them based on user input.

Tool Categories

Flowise organizes tools into several categories:

Search Tools

Web search, academic papers, and knowledge bases

Serper, SerpAPI, Brave Search
Google Search API
Tavily API, Exa Search
WolframAlpha

Productivity Tools

Business and productivity integrations

Gmail, Google Calendar
Microsoft Outlook, Teams
Jira, Asana
Google Sheets, Google Docs

API & Integration Tools

External API and service integrations

Custom API Tool
OpenAPI Toolkit
HTTP Requests (GET, POST, PUT, DELETE)
Webhooks

Data Tools

Data processing and retrieval

Retriever Tool
Query Engine Tool
JSON Path Extractor
Calculator

Adding Tools to Workflows

In Chatflows

Add an Agent Node

Tools require an agent node to orchestrate their usage. Add one of:

OpenAI Functions Agent
Conversational Agent
ReAct Agent
Tool Calling Agent

Add Tool Nodes

From the node library, browse the Tools category. Drag desired tools onto the canvas:

Calculator
Web Browser
Custom Tool
And many more

Connect Tools to Agent

Connect each tool node to the agent node’s tool input. You can connect multiple tools to a single agent.

Configure Tools

Double-click each tool to configure:

API keys and credentials
Tool-specific parameters
Descriptions (help the agent understand when to use the tool)

Connect Agent to Chain

Connect the agent to a chain node (like Agent Executor or Conversational Agent Chain) to complete the workflow.

In Agentflows

Add Tool Nodes

In the agentflow canvas, add tool nodes from the Agent Flow Tools category.

Connect in Sequence

Connect tools in the execution sequence where they should be called:

[Start] → [LLM Agent] → [Search Tool] → [Analysis Agent] → [End]

Configure Tool Binding

Configure which agent nodes have access to which tools through the node settings.

Popular Tools

Calculator

Perform mathematical calculations:

// Example usage by agent
User: "What is 25% of 450?"
Agent: [Uses Calculator] "112.5"

Configuration:

No API key required
Works with natural language math expressions

Web Browser

Search and browse web pages: Features:

Google search integration
Page content extraction
Link following

Configuration:

Serper API key or SerpAPI key
Max results to return
Search parameters

API Request Tools

Make HTTP requests to external APIs:

GET Request
POST Request
PUT/DELETE

Retrieve data from APIs:

URL endpoint
Headers and authentication
Query parameters

Retriever Tool

Query vector stores for relevant documents: Setup:

Create Vector Store

First, set up a vector store with your documents in a separate chatflow or through upsert.

Add Retriever Tool

Add the Retriever Tool node to your agent workflow.

Configure Retriever

Connect to your vector store
Set search parameters (top K, similarity threshold)
Write a clear description for the agent

Connect to Agent

Connect the retriever tool to your agent node.

The agent will automatically query the vector store when relevant to the user’s question.

Custom Tool

Create tools with custom JavaScript logic:

Add Custom Tool Node

Drag the Custom Tool node onto the canvas.

Write Tool Function

Write JavaScript code for your tool:

// Example: Convert temperature
const celsius = parseFloat($input);
const fahrenheit = (celsius * 9/5) + 32;
return `${celsius}°C is ${fahrenheit}°F`;

Set Tool Description

Write a clear description so the agent knows when to use it:“Converts temperature from Celsius to Fahrenheit. Input should be a number representing degrees Celsius.”

Configure Parameters

Define input parameters and their types:

Parameter names
Data types
Descriptions
Required vs optional

MCP Tools

Model Context Protocol (MCP) tools provide standardized integrations:

GitHub MCP

Interact with GitHub repositories, issues, and pull requests.

PostgreSQL MCP

Query and manage PostgreSQL databases.

Slack MCP

Send messages and interact with Slack workspaces.

Custom MCP

Build your own MCP server integrations.

Tool Configuration Best Practices

Write Clear Descriptions

Tool descriptions are crucial for agent decision-making:

Searches academic papers on ArXiv. Use this when the user asks about 
recent research, scientific papers, or academic publications. Input 
should be a search query with relevant keywords.

Good descriptions include:

What: What the tool does
When: When to use it
Input: What input format is expected
Output: What the tool returns

Set Appropriate Parameters

API Rate Limits: Configure timeouts and retries
Result Limits: Limit results to avoid overwhelming the context
Error Handling: Define what happens when the tool fails
Timeout Settings: Set reasonable timeout values

Security Considerations

Never hardcode API keys in custom tools. Use the credential system or environment variables.

Store credentials securely using Flowise’s credential management
Use least-privilege API keys (read-only when possible)
Validate and sanitize user inputs in custom tools
Review tool permissions carefully

Multi-Tool Workflows

Sequential Tool Usage

Chain tools for complex workflows:

User: "Find recent AI papers and summarize the top result"

[Agent] → [Arxiv Tool] → Gets papers
        → [Web Browser] → Fetches paper content  
        → [LLM] → Summarizes content

The agent automatically orchestrates the sequence.

Tool Selection

Agents select tools based on:

Tool Descriptions: How well the description matches the task
Previous Results: What has worked in the conversation
Context: Current conversation state
User Input: Explicit or implicit tool requests

Tool Fallbacks

Implement fallbacks when tools fail:

// In custom tool
try {
  const result = await externalAPI.call();
  return result;
} catch (error) {
  return "Unable to fetch data. Using cached information...";
}

Advanced Tool Patterns

Conditional Tool Access

Restrict tools based on conditions:

User role or permissions
Time of day or business hours
Conversation state
Resource availability

Implement in agentflows using condition nodes before tool nodes.

Tool Output Processing

Transform tool outputs before returning:

[Tool] → [Transform Node] → [Format] → [Return to Agent]

Useful for:

Formatting data
Filtering sensitive information
Aggregating multiple tool results
Error handling and retry logic

Nested Tools

Use the Agent as Tool pattern:

Create a specialized sub-agent
Expose it as a tool to the main agent
The tool calls the sub-agent internally
Enables modular, reusable agent components

OpenAPI Toolkit

Integrate entire APIs using OpenAPI specifications:

Obtain OpenAPI Spec

Get the OpenAPI (Swagger) specification for the API:

URL to spec file
JSON or YAML format

Add OpenAPI Toolkit Node

Add the OpenAPI Toolkit node to your workflow.

Configure Spec

Paste the OpenAPI spec or provide URL
Configure authentication (API key, OAuth, etc.)
Select which endpoints to expose

Connect to Agent

The toolkit automatically creates tools for each API endpoint.

The agent can now call any endpoint from the API based on user requests.

Debugging Tools

Testing Individual Tools

Test tools in isolation:

Create a simple chatflow with just the tool and an agent
Send test messages that should trigger the tool
Review the tool output in the conversation
Check logs for errors or warnings

Tool Execution Logs

Enable verbose logging to see:

When tools are called
What input is passed to tools
Tool execution time
Tool output or errors

Common Tool Issues

Agent doesn't use the tool

Check tool description is clear and relevant
Verify tool is properly connected to agent
Test with explicit requests (“Use the calculator to…”)
Review agent model capabilities (some models better at tool use)

Tool returns errors

Verify API keys and credentials are valid
Check network connectivity and firewall rules
Review tool configuration parameters
Check API rate limits and quotas

Tool output isn't used correctly

Format tool output clearly
Add post-processing if needed
Update tool description to clarify output format
Test with simpler examples first

Performance is slow

Reduce result limits
Use caching when appropriate
Set reasonable timeouts
Consider async execution for independent tools

Tool API Integration

When calling flows with tools via API:

// Example: Chatflow with tools
fetch('https://your-instance.com/api/v1/prediction/chatflow-id', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_API_KEY'
  },
  body: JSON.stringify({
    question: "Search for information about quantum computing",
    // Tools are automatically available to the agent
  })
});

The API response includes:

Agent reasoning
Tool calls made
Tool outputs
Final response

See API Reference - Chatflow Prediction for details.

Creating Custom Tool Libraries

Organize related tools:

Create Multiple Custom Tools: Build related tools
Use Consistent Naming: Prefix tools with category (e.g., “Weather: Get Current”)
Share Credentials: Use the same credential ID across related tools
Document Dependencies: Note which tools work together

Example: Weather Tool Suite

Weather: Get Current - Current conditions
Weather: Get Forecast - Future predictions
Weather: Get Historical - Past weather data
Weather: Get Alerts - Severe weather alerts

Best Practices Summary

Descriptive Names

Give tools clear, descriptive names and descriptions

Error Handling

Implement proper error handling and fallbacks

Test Thoroughly

Test tools individually before integration

Monitor Usage

Track tool calls and performance metrics

Secure Credentials

Never expose API keys or sensitive data

Optimize Performance

Set appropriate limits and timeouts

Next Steps

Explore Memory Management for stateful tool usage
Learn Prompt Engineering to improve tool selection
Review Custom Tool Development for advanced tool creation

Get Started

Core Concepts

Building Workflows

Integrations

Features

Deployment

Development

​What are Tools?

​Tool Categories

Search Tools

Productivity Tools

API & Integration Tools

Data Tools

​Adding Tools to Workflows

​In Chatflows

​In Agentflows

​Popular Tools

​Calculator

​Web Browser

​API Request Tools

​Retriever Tool

​Custom Tool

​MCP Tools

GitHub MCP

PostgreSQL MCP

Slack MCP

Custom MCP

​Tool Configuration Best Practices

​Write Clear Descriptions

​Set Appropriate Parameters

​Security Considerations

​Multi-Tool Workflows

​Sequential Tool Usage

​Tool Selection

​Tool Fallbacks

​Advanced Tool Patterns

​Conditional Tool Access

​Tool Output Processing

​Nested Tools

​OpenAPI Toolkit

​Debugging Tools

​Testing Individual Tools

​Tool Execution Logs

​Common Tool Issues

​Tool API Integration

​Creating Custom Tool Libraries

​Example: Weather Tool Suite

​Best Practices Summary

Descriptive Names

Error Handling

Test Thoroughly

Monitor Usage

Secure Credentials

Optimize Performance

​Next Steps

​Related Resources

Build docs developers (and LLMs) love

What are Tools?

Tool Categories

Adding Tools to Workflows

In Chatflows

In Agentflows

Popular Tools

Calculator

Web Browser

API Request Tools

Retriever Tool

Custom Tool

MCP Tools

Tool Configuration Best Practices

Write Clear Descriptions

Set Appropriate Parameters

Security Considerations

Multi-Tool Workflows

Sequential Tool Usage

Tool Selection

Tool Fallbacks

Advanced Tool Patterns

Conditional Tool Access

Tool Output Processing

Nested Tools

OpenAPI Toolkit

Debugging Tools

Testing Individual Tools

Tool Execution Logs

Common Tool Issues

Tool API Integration

Creating Custom Tool Libraries

Example: Weather Tool Suite

Best Practices Summary

Next Steps

Related Resources