Agent Tools in CrewAI

# bash
pip install "crewai[tools]"

import os
from crewai import Agent, Task, Crew
from crewai_tools import (
    DirectoryReadTool,
    FileReadTool,
    SerperDevTool,
    WebsiteSearchTool,
)

# API keys
os.environ["SERPER_API_KEY"] = "YOUR_SERPER_KEY"
os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_KEY"

# Tools
docs_tool = DirectoryReadTool(directory="./blog-posts")
file_tool = FileReadTool()
search_tool = SerperDevTool()
web_rag_tool = WebsiteSearchTool()

# Agents
researcher = Agent(
    role="Market Research Analyst",
    goal="Provide up-to-date market analysis of the AI industry",
    backstory="An expert analyst with a keen eye for market trends.",
    tools=[search_tool, web_rag_tool],
    verbose=True,
)

writer = Agent(
    role="Content Writer",
    goal="Craft engaging blog posts about the AI industry",
    backstory="A skilled writer with a passion for technology.",
    tools=[docs_tool, file_tool],
    verbose=True,
)

# Tasks
research = Task(
    description="Research the latest trends in the AI industry and provide a summary.",
    expected_output=(
        "A summary of the top 3 trending developments in the AI industry "
        "with a unique perspective on their significance."
    ),
    agent=researcher,
)

write = Task(
    description=(
        "Write an engaging blog post about the AI industry, based on the research "
        "analyst's summary. Draw inspiration from the latest blog posts in the directory."
    ),
    expected_output=(
        "A 4-paragraph blog post in markdown, engaging and accessible, avoiding jargon."
    ),
    agent=writer,
    output_file="blog-posts/new_post.md",
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research, write],
    verbose=True,
    planning=True,  # enable planning
)

crew.kickoff()

from typing import Type
from pydantic import BaseModel, Field
from crewai.tools import BaseTool

class MyToolInput(BaseModel):
    """Input schema for MyCustomTool."""
    argument: str = Field(..., description="Description of the argument.")

class MyCustomTool(BaseTool):
    name: str = "my_custom_tool"
    description: str = "What this tool does. It’s vital for effective utilization."
    args_schema: Type[BaseModel] = MyToolInput

    def _run(self, argument: str) -> str:
        # Your tool logic here
        return f"Tool processed: {argument}"

from crewai.tools import tool

@tool("Name of my tool")
def my_tool(question: str) -> str:
    """Clear description for what this tool is useful for."""
    # Logic here
    return f"Answer for: {question}"

import asyncio
from crewai.tools import tool

@tool("fetch_data_async")
async def fetch_data_async(query: str) -> str:
    """Asynchronously fetch data based on the query."""
    await asyncio.sleep(1)
    return f"Data retrieved for {query}"

from crewai.tools import BaseTool

class AsyncCustomTool(BaseTool):
    name: str = "async_custom_tool"
    description: str = "An asynchronous custom tool"

    async def _run(self, query: str = "") -> str:
        await asyncio.sleep(1)
        return f"Processed {query} asynchronously"

from crewai import Agent, Crew
from crewai.flow.flow import Flow, start

async_tool = AsyncCustomTool()

agent = Agent(role="researcher", tools=[async_tool])

class MyFlow(Flow):
    @start()
    async def begin(self):
        crew = Crew(agents=[agent])
        result = await crew.kickoff_async()
        return result

from crewai.tools import tool

@tool
def multiplication_tool(first_number: int, second_number: int) -> int:
    """Useful for when you need to multiply two numbers together."""
    return first_number * second_number

def cache_func(args, result):
    # Only cache if the result is even
    return result % 2 == 0

multiplication_tool.cache_function = cache_func

from crewai import Agent

writer = Agent(
    role="Writer",
    goal="You write lessons of math for kids.",
    backstory=(
        "You're an expert in writing and you love to teach kids "
        "but you know nothing of math."
    ),
    tools=[multiplication_tool],
    allow_delegation=False,
)