The Best Pre-Built Toolkits for AI Agents

Python and TypeScript-based AI agent frameworks, CrewAI, LangChain, Agno, and Vercel AI SDK allow developers to build AI applications with multiple agents to act as Computer-Using Agents, or Deep Research Agents to automate browser tasks like clicking, scrolling, ordering products on the web and performing complex and multi-step tasks. These multi-AI agents may be put together to collaborate and hand off their tasks to other agents to solve complex problems. While the above agent frameworks help you build multi-agents quickly, you may soon realize that for an enterprise agentic system, you will need external tools to equip these agents. With tools and toolkits, you can connect your AI assistants to a limitless number of applications like chat to retrieve a channel's information, video conferencing to analyze call participants' sentiments and more.

Overview of AI Agents and External Tools

One of the main components of an AI agent is a large language model (LLM) that powers it to perform its operations. Generally, these LLMs can only answer users' queries using their training data. Although the training data may be a massive dataset, it allows LLMs to only interact with the internal world. However, when you build AI agents, you can give them keys to unlock the external world and access a wide range of knowledge with tools. Giving agents the required tools helps extend LLMs' built-in expertise and enhances prompts' responses.

Continue reading to discover categories of agent toolkits you can plug and play in your next AI agent system. Also, check out our GitHub repo for a complete list of tools/toolkits that integrate seamlessly with popular agentic frameworks.

What is an Agent Tool?

A tool defines an action an LLM can invoke to augment a user query's response. Depending on the user's prompt, a tool can interact with external applications such as YouTube, Gmail, Slack, Yahoo Finance API, and Zoom. On the other hand, a toolkit consists of a collection of ready-to-use tools or functions agents can invoke to provide precise answers. If you want an agent to scrap the web or check today’s calendar, there are specific tools for that.

In the diagram above, a user may ask about the current weather conditions in a specific location. If a weather tool like Tavily or DuckDuckGo live web search is available, the LLM retrieves it so the agent can respond accurately to the user's query.

Agent toolkits are a wide range of ready-to-use functionalities developers can add to their multi-agent AI applications from external sources to achieve a specific goal or perform a specific task. Think of it like the various tools individual team members may need to be equipped with to perform their daily tasks more effectively in a real-world scenario. Using toolkits, you can easily connect LLMs and agents to external applications like GitHub, Slack, and Linear for task management, improved productivity, and more.

Why Integrate External Tools With Agents?

Using tools, you can connect agents to external services to perform and trigger actions in agentic workflows. With tools access frameworks like Composio, you can easily connect several tools and manage their authentication for multi-agents on a single monitoring dashboard.

Out-of-the-box support: Most tools are LLM model and agent framework agnostic. They work instantly with your existing agent infrastructure using agent-building platforms like Agno, CrewAI, LangChain, and a library such as Agentic.so.
Repository of toolkits: Access and connect your agents to over 250+ external applications for web browsing, task management, search, etc.
Mix and match: Hundreds of available agent toolkits are ready for you to mix and match to solve a specific problem or achieve a particular goal using leading AI agent libraries. In the following sections, you will see practical examples of mixing different tools for agentic systems.

The Problem: Create a Basic Agent Without a Tool

The diagram above demonstrates the basic operation of an AI agent.

python

1
2
3
4
5
6
7
8
# Create an agent without a tool (basic inference tasks)
# agent_without_tool.py

from agno.agent import Agent
from agno.models.openai import OpenAIChat

agent = Agent()
agent.print_response("What is the weather in Helsinki?", markdown=True)

As illustrated above, the model could not provide real-time information from the web because it could not access a tool. Let's fix this problem by specifying a tool in the agent's definition.

Solution: Arm a Basic Agent With a Tool

To resolve the problem above, we connect our AI agent to Tavily to provide real-time, accurate search results from the web using the sample code below.

python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import os
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.tavily import TavilyTools
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

# Use token from .env file
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")

agent = Agent(tools=[TavilyTools()], show_tool_calls=True)
agent.print_response("What is the weather in Helsinki?", markdown=True)

Running the sample code above will display an output similar to the image below using the external tool (Tavily).

Common Agent Toolkits and Use Cases

Agent toolkits can be integrated into AI applications for several reasons and in different use cases. External tooling can be added to agents to allow them to perceive and influence the real world directly. For example, you can access the Tavily web search API via an agent tool to present real-time weather information or current affairs as seen previously.

As the image above demonstrates, you can leverage tools for AI agent applications in many ways, from marketplaces to on-demand services, etc. The following are some key application areas where you can equip agents with tools for a more precise and better understanding of the real world.

Healthcare

You can mix and match several agent tools to solve healthcare problems. Imagine a telehealth app; we can build an in-app AI agent and arm it with tools like Tavily to allow patients to search for doctors nearby in real-time. Doctors can use Cal.com to schedule their availability for appointments. Additionally, we can equip the agent with Resend to schedule patient-doctor appointment email notifications.

Project Management

Using tools, you can build an AI assistant that coordinates and manages projects across different teams in Linear or Jira. In this case, the AI agent will be responsible for providing accurate information about the status of tasks, team members' availability, and deadlines for specific projects.

python

1
2
3
4
5
6
7
8
9
10
from agno.agent import Agent
from agno.tools.linear_tools import LinearTool

agent = Agent(
    name="Linear Tool Agent",
    tools=[LinearTool()],
    show_tool_calls=True,
    markdown=True,
)
agent.print_response("Show all the issues assigned to user id: 103348")

The code snippet above demonstrates an agent that can display all issues assigned to a particular user in Linear using Agno.

Academic Research

Building your own app? Get early access to our Livestream or Video Calling API and launch in days!

By extending the capabilities of multi-agent AI applications and their trained knowledge with external tools like Arxiv, you can create an AI chatbot for students and academic researchers that allows them to analyze scholarly research papers quickly.

The following example agent is responsible for searching topics on Arxiv using Agno.

python

1
2
3
4
5
from agno.agent import Agent
from agno.tools.arxiv_toolkit import ArxivToolkit

agent = Agent(tools=[ArxivToolkit()], show_tool_calls=True)
agent.print_response("Search arxiv for 'language models'", markdown=True)

Complex Data Analysis

In analyzing complex data with an AI system, you can connect CSV search tools with agents to perform efficient Retrieval Augmented Generation (RAG). The search tool can help agents extract information from CSV documents using semantic search.

python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
from crewai_tools import CSVSearchTool

# Initialize the tool with a specific CSV file.
# This setup allows the agent to only search the given CSV file.
tool = CSVSearchTool(csv="weather_data.csv")

# OR

# Initialize the tool without a specific CSV file.
# Agent will need to provide the CSV path at runtime.
tool = CSVSearchTool()

tool = CSVSearchTool(
    config=dict(
        llm=dict(
            provider="openai",  # or google, openai, anthropic, llama2, ...
            config=dict(
                model="gpt-4o",
                temperature=0.5,
                top_p=1,
                stream=True,
            ),
        ),
        embedder=dict(
            provider="openai",  # or openai, ollama, ...
            config=dict(
                model="text-embedding-3-small",
            ),
        ),
    )
)

print(tool.run("Where did Light shower rain occurred?"))

The example here uses CrewAI's CSVSearchTool to extract weather information from a CSV file.

Finance

API tools from Yahoo Finance, Pandas, and OpenBB can be integrated into agents to give financial recommendations, visualize financial data from CSV, and provide information about companies and their stock news.

It is impossible to cover every tool support for popular AI agent frameworks for Python and TypeScript. Therefore, it is recommended that you look up the following links for hundreds of agent tools and toolkits you can integrate to extend the capabilities of your AI applications.

Advantages of Arming Agents With External Tools

Connecting AI agents to use external tools is helpful in many circumstances.

Accuracy of responses: Empower your AI assistants with real-time and accurate search results.
Trust: It improves the trust and reliability of responses to user queries.
Real-time access: Always retrieves and presents live information to ensure fast and better LLM decision-making and prevent hallucinations.
Plug and play: It is simple to set up with or without an API key and integrates seamlessly into your multi-agent AI system.
It enhances agentic workflows by retrieving information based on relevance.
Knowledge extensibility: Connecting external systems via tools to LLms in agentic workflows helps extend their knowledge.
Usually, AI agent frameworks like Agno, CrewAI, and LangChain implement tools natively in agents' infrastructures.
External capabilities: Agent tools help bridge the gap between foundational AI models and their access to the outside world.

Types of Tools for AI Agents

You can integrate tools and a set of ready-made application kits with agents differently. You may prefer writing your own custom Python functions as tools, using pre-built apps from external APIs, or installing a framework like Composio for easy, quick, and secure access to multiple tools.

Use Pure Python and TypeScript Functions

You can write custom pure Python and TypeScript functions in any popular AI agent framework as tools for agents. The sample code below demonstrates a Python function, get_top_hackernews_stories, that fetches top stories from hacker news using Agno. Check out an alternative implementation for CrewAI and compare their similarities.

python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import json
import httpx

from agno.agent import Agent

def get_top_hackernews_stories(num_stories: int = 10) -> str:
    """Use this function to get top stories from Hacker News.

    Args:
        num_stories (int): Number of stories to return. Defaults to 10.

    Returns:
        str: JSON string of top stories.
    """

    # Fetch top story IDs
    response = httpx.get('https://hacker-news.firebaseio.com/v0/topstories.json')
    story_ids = response.json()

    # Fetch story details
    stories = []
    for story_id in story_ids[:num_stories]:
        story_response = httpx.get(f'https://hacker-news.firebaseio.com/v0/item/{story_id}.json')
        story = story_response.json()
        if "text" in story:
            story.pop("text", None)
        stories.append(story)
    return json.dumps(stories)

agent = Agent(tools=[get_top_hackernews_stories], show_tool_calls=True, markdown=True)
agent.print_response("Summarize the top 5 stories on hackernews?", stream=True)

Running the Python code above will display a result similar to this preview.

Use Toolkits and Manage Them at Scale

Fundamentally, it is easier to integrate external applications into AI agents via tools/toolkits. However, authenticating and managing these external applications in an agentic system becomes tedious. To simplify the process, you can utilize platforms like Composio and Toolhouse. Both platforms support AI applications and agents built with Python and TypeScript.

Integrate External Tools at Scale With Composio

Composio is a production-ready platform for integrating tools with LLMs and AI agent applications to construct complex workflows. You can start with Composio to add toolkits to your Python-based AI projects or use it through AI frameworks like Agno, LangChain, and CrewAI. In building a complex agentic workflow, Composio becomes a handy tool if your agents need to access applications like Gmail, GitHub, and Salesforce.

Use Composio With Crew AI

Let's look at an example of CrewAI and Conposio integration for an agent that can navigate to a given GitHub repo and "star" it.

python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
from composio_crewai import ComposioToolSet, App
from crewai import Agent, Task, Crew
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
import os

# Load environment variables from .env file
load_dotenv()

toolset = ComposioToolSet(api_key=os.getenv("COMPOSIO_API_KEY"))
llm = ChatOpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# request = toolset.initiate_connection(app=App.GITHUB)
# print(f"Open this URL to authenticate: {request.redirectUrl}")

crewai_agent = Agent(
    role="GitHub Agent",
    goal="You take action on GitHub using GitHub APIs",
    backstory="You are AI agent that is responsible for taking actions on GitHub on behalf of users using GitHub APIs",
    verbose=True,
    tools=toolset.get_tools(),
    llm=llm,
)

task = Task(
    description="Star the repo GetStream/stream-tutorial-projects on GitHub",
    agent=crewai_agent,
    expected_output="Status of the operation",
)

crew = Crew(agents=[crewai_agent], tasks=[task])

result = crew.kickoff()
print(result)

To summarize the sample code above, you should install CrewAI, Composio, and other CrewAI dependencies. Running the agent with the specified tool requires an API key to access your preferred LLM, Composio, and CrewAI. This example uses OpenAI and stores all the required API keys as environment variables, as presented in the code. Running this example will display an output similar to the image below.

Install and Manage External Apps With Toolhouse

Toolhouse is a platform that allows developers to build, configure, run, test, and integrate tools into LLMs and agents. Its Tool Store feature supports installing different tools for agents, similar to how apps are installed on phones. You can start with Toolhouse by choosing your preferred library, Python or TypeScript.

Use External Tooling for TypeScript-based Agentic Systems

At the time of writing this article, Python has countless frameworks and libraries that support external agent tools. On the other hand, TypeScript has just a few of them. The best TypeScript AI SDKs and libraries with built-in support for tools/toolkits are the Vercel AI SDK and Agentic.so. However, as the AI landscape is growing rapidly, several TypeScript-based frameworks and libraries with many tools may soon emerge.

Wrap Up

This tutorial covered AI agent tools/toolkits, why they are essential to AI applications, and how they can be implemented in Python and Typescript-based AI projects using leading agentic AI frameworks like LangChain, CrewAI, Agno and the library, Agentic.so. All the tools you discovered in this article and many more are in the AI Agent Tools Catalog repo.