FAQs

How is task execution handled in the hierarchical process?

Where can I get the latest CrewAI documentation?

What are the key differences between Hierarchical and Sequential Processes in CrewAI?

What are the benefits of using memory in the CrewAI framework?

What is the purpose of setting a maximum RPM limit for an agent?

What role does human input play in the execution of tasks within a CrewAI crew?

What advanced customization options are available for tailoring and enhancing agent behavior and capabilities in CrewAI?

In what scenarios is human input particularly useful in agent execution?

What are the different types of memory that are available in crewAI?

How do I use Output Pydantic in a Task?

To use Output Pydantic in a task, you need to define the expected output of the task as a Pydantic model. Here’s an example:

1

Define a Pydantic model

First, you need to define a Pydantic model. For instance, let’s create a simple model for a user:

from pydantic import BaseModel

class User(BaseModel):
    name: str
    age: int

2

Then, when creating a task, specify the expected output as this Pydantic model:

from crewai import Task, Crew, Agent

# Import the User model
from my_models import User

# Create a task with Output Pydantic
task = Task(
    description="Create a user with the provided name and age",
    expected_output=User,  # This is the Pydantic model
    agent=agent,
    tools=[tool1, tool2]
)

3

In your agent, make sure to set the output_pydantic attribute to the Pydantic model you're using:

from crewai import Agent

# Import the User model
from my_models import User

# Create an agent with Output Pydantic
agent = Agent(
    role='User Creator',
    goal='Create users',
    backstory='I am skilled in creating user accounts',
    tools=[tool1, tool2],
    output_pydantic=User
)

4

When executing the crew, the output of the task will be a User object:

from crewai import Crew

# Create a crew with the agent and task
crew = Crew(agents=[agent], tasks=[task])

# Kick off the crew
result = crew.kickoff()

# The output of the task will be a User object
print(result.tasks[0].output)

Here’s a tutorial on how to consistently get structured outputs from your agents:

How can I create custom tools for my CrewAI agents?

How to Kickoff a Crew from Slack

How to export and use a React Component

Click on the ellipsis (three dots on the right of your deployed crew) and select the export option and save the file locally. We will be using CrewLead.jsx for our example.

To run this React component locally, you’ll need to set up a React development environment and integrate this component into a React project. Here’s a step-by-step guide to get you started:

1

Install Node.js

Download and install Node.js from the official website: https://nodejs.org/
Choose the LTS (Long Term Support) version for stability.

2

Create a new React project

Open Command Prompt or PowerShell
Navigate to the directory where you want to create your project
Run the following command to create a new React project:
```
npx create-react-app my-crew-app
```
Change into the project directory:
```
cd my-crew-app
```

3

Install necessary dependencies

npm install react-dom

4

Create the CrewLead component

Move the downloaded file CrewLead.jsx into the src folder of your project,

5

Modify your `App.js` to use the `CrewLead` component

Open src/App.js
Replace its contents with something like this:

import React from 'react';
import CrewLead from './CrewLead';

function App() {
    return (
        <div className="App">
            <CrewLead baseUrl="YOUR_API_BASE_URL" bearerToken="YOUR_BEARER_TOKEN" />
        </div>
    );
}

export default App;

Replace YOUR_API_BASE_URL and YOUR_BEARER_TOKEN with the actual values for your API.

6

Start the development server

In your project directory, run:
```
npm start
```
This will start the development server, and your default web browser should open automatically to http://localhost:3000, where you’ll see your React app running.

You can then customise the CrewLead.jsx to add color, title etc

How to Invite Team Members to Your CrewAI Enterprise Organization

Using Webhooks in CrewAI Enterprise

CrewAI Enterprise allows you to automate your workflow using webhooks. This article will guide you through the process of setting up and using webhooks to kickoff your crew execution, with a focus on integration with ActivePieces, a workflow automation platform similar to Zapier and Make.com. We will be setting up webhooks in the CrewAI Enterprise UI.

1

Accessing the Kickoff Interface

Navigate to the CrewAI Enterprise dashboard
Look for the /kickoff section, which is used to start the crew execution

2

Configuring the JSON Content

In the JSON Content section, you’ll need to provide the following information:

inputs: A JSON object containing:
- company: The name of the company (e.g., “tesla”)
- product_name: The name of the product (e.g., “crewai”)
- form_response: The type of response (e.g., “financial”)
- icp_description: A brief description of the Ideal Customer Profile
- product_description: A short description of the product
- taskWebhookUrl, stepWebhookUrl, crewWebhookUrl: URLs for various webhook endpoints (ActivePieces, Zapier, Make.com or another compatible platform)

3

Integrating with ActivePieces

In this example we will be using ActivePieces. You can use other platforms such as Zapier and Make.com

To integrate with ActivePieces:

Set up a new flow in ActivePieces
Add a trigger (e.g., Every Day schedule)
Add an HTTP action step
- Set the action to Send HTTP request
- Use POST as the method
- Set the URL to your CrewAI Enterprise kickoff endpoint
- Add necessary headers (e.g., Bearer Token)
- In the body, include the JSON content as configured in step 2
- The crew will then kickoff at the pre-defined time.

4

Setting Up the Webhook

Create a new flow in ActivePieces and name it
Add a webhook step as the trigger:
- Select Catch Webhook as the trigger type
- This will generate a unique URL that will receive HTTP requests and trigger your flow
- Configure the email to use crew webhook body text

5

Generated output

stepWebhookUrl - Callback that will be executed upon each agent inner thought

{
    "action": "**Preliminary Research Report on the Financial Industry for crewai Enterprise Solution**\n1. Industry Overview and Trends\nThe financial industry in ....\nConclusion:\nThe financial industry presents a fertile ground for implementing AI solutions like crewai, particularly in areas such as digital customer engagement, risk management, and regulatory compliance. Further engagement with the lead is recommended to better tailor the crewai solution to their specific needs and scale.",
    "task_id": "97eba64f-958c-40a0-b61c-625fe635a3c0"
}

taskWebhookUrl - Callback that will be executed upon the end of each task

{
    "description": "Using the information gathered from the lead's data, conduct preliminary research on the lead's industry, company background, and potential use cases for crewai. Focus on finding relevant data that can aid in scoring the lead and planning a strategy to pitch them crewai.The financial industry presents a fertile ground for implementing AI solutions like crewai, particularly in areas such as digital customer engagement, risk management, and regulatory compliance. Further engagement with the lead is recommended to better tailor the crewai solution to their specific needs and scale.",
    "task_id": "97eba64f-958c-40a0-b61c-625fe635a3c0"
}

crewWebhookUrl - Callback that will be executed upon the end of the crew execution

{
    "task_id": "97eba64f-958c-40a0-b61c-625fe635a3c0",
    "result": {
        "lead_score": "Customer service enhancement, and compliance are particularly relevant.",
        "talking_points": [
            "Highlight how crewai's AI solutions can transform customer service with automated, personalized experiences and 24/7 support, improving both customer satisfaction and operational efficiency.",
            "Discuss crewai's potential to help the institution achieve its sustainability goals through better data analysis and decision-making, contributing to responsible investing and green initiatives.",
            "Emphasize crewai's ability to enhance compliance with evolving regulations through efficient data processing and reporting, reducing the risk of non-compliance penalties.",
            "Stress the adaptability of crewai to support both extensive multinational operations and smaller, targeted projects, ensuring the solution grows with the institution's needs."
        ]
    }
}

How to use the crewai custom GPT to create a crew

1

Navigate to the CrewAI custom GPT

Click here https://chatgpt.com/g/g-qqTuUWsBY-crewai-assistant to access the CrewAI custom GPT

CrewAI custom GPT

2

Describe your project idea

For example:

Suggest some agents and tasks to retrieve LinkedIn profile details for a given person and a domain.

3

The GPT will provide you with a list of suggested agents and tasks

Here’s an example of the response you will get:

4

Create the project structure in your terminal by entering:

crewai create crew linkedin-profile

This will create a new crew called linkedin-profile in the current directory.

Follow the full instructions in the https://docs.crewai.com/quickstart to create a crew.

CrewAI Docs

5

Ask the GPT to convert the agents and tasks to YAML format.

Here’s an example of the final output you will have to save in the agents.yaml and tasks.yaml files:

Now replace the agents.yaml and tasks.yaml with the above code
Ask GPT to create the custom LinkedIn Tool
Ask the GPT to put everything together into the crew.py file
You will now have a fully working crew.

How to generate images using Dall-E

CrewAI supports integration with OpenAI’s DALL-E, allowing your AI agents to generate images as part of their tasks. This guide will walk you through how to set up and use the DALL-E tool in your CrewAI projects.

Prerequisites

crewAI installed (latest version)
OpenAI API key with access to DALL-E

Setting Up the DALL-E Tool To use the DALL-E tool in your CrewAI project, follow these steps:

1

Import the DALL-E tool

from crewai_tools import DallETool

2

Add the DALL-E tool to your agent configuration

@agent
def researcher(self) -> Agent:
    return Agent(
        config=self.agents_config['researcher'],
        tools=[SerperDevTool(), DallETool()],  # Add DallETool to the list of tools
        allow_delegation=False,
        verbose=True
    )

Using the DALL-E Tool

Once you’ve added the DALL-E tool to your agent, it can generate images based on text prompts. The tool will return a URL to the generated image, which can be used in the agent’s output or passed to other agents for further processing.

Example usage within a task:

role: >
    LinkedIn Profile Senior Data Researcher
goal: >
    Uncover detailed LinkedIn profiles based on provided name {name} and domain {domain}
    Generate a Dall-e image based on domain {domain}
backstory: >
    You're a seasoned researcher with a knack for uncovering the most relevant LinkedIn profiles.
    Known for your ability to navigate LinkedIn efficiently, you excel at gathering and presenting
    professional information clearly and concisely.

The agent with the DALL-E tool will be able to generate the image and provide a URL in its response. You can then download the image.

Best Practices

Be specific in your image generation prompts to get the best results.
Remember that image generation can take some time, so factor this into your task planning.
Always comply with OpenAI’s usage policies when generating images.

Troubleshooting

Ensure your OpenAI API key has access to DALL-E.
Check that you’re using the latest version of crewAI and crewai-tools.
Verify that the DALL-E tool is correctly added to the agent’s tool list.

How to use Annotations in crew.py

This guide explains how to use annotations to properly reference agents, tasks, and other components in the crew.py file.

Introduction

Annotations in the framework are used to decorate classes and methods, providing metadata and functionality to various components of your crew. These annotations help in organizing and structuring your code, making it more readable and maintainable.

Available Annotations

The CrewAI framework provides the following annotations:

@CrewBase: Used to decorate the main crew class.
@agent: Decorates methods that define and return Agent objects.
@task: Decorates methods that define and return Task objects.
@crew: Decorates the method that creates and returns the Crew object.
@llm: Decorates methods that initialize and return Language Model objects.
@tool: Decorates methods that initialize and return Tool objects.
@callback: (Not shown in the example, but available) Used for defining callback methods.
@output_json: (Not shown in the example, but available) Used for methods that output JSON data.
@output_pydantic: (Not shown in the example, but available) Used for methods that output Pydantic models.
@cache_handler: (Not shown in the example, but available) Used for defining cache handling methods.

Usage Examples

Let’s go through examples of how to use these annotations based on the provided LinkedinProfileCrew class:

1. Crew Base Class

@CrewBase
class LinkedinProfileCrew():
    """LinkedinProfile crew"""
    agents_config = 'config/agents.yaml'
    tasks_config = 'config/tasks.yaml'

The @CrewBase annotation is used to decorate the main crew class. This class typically contains configurations and methods for creating agents, tasks, and the crew itself.

2. Tool Definition

@tool
    def myLinkedInProfileTool(self):
        return LinkedInProfileTool()

The @tool annotation is used to decorate methods that return tool objects. These tools can be used by agents to perform specific tasks.

3. LLM Definition

@llm
def groq_llm(self):
    api_key = os.getenv('api_key')
    return ChatGroq(api_key=api_key, temperature=0, model_name="mixtral-8x7b-32768")

The @llm annotation is used to decorate methods that initialize and return Language Model objects. These LLMs are used by agents for natural language processing tasks.

4. Agent Definition

@agent
def researcher(self) -> Agent:
    return Agent(
        config=self.agents_config['researcher']
    )

The @agent annotation is used to decorate methods that define and return Agent objects.

5. Task Definition

@task
def research_task(self) -> Task:
    return Task(
        config=self.tasks_config['research_linkedin_task'],
        agent=self.researcher()
    )

The @task annotation is used to decorate methods that define and return Task objects. These methods specify the task configuration and the agent responsible for the task.

6. Crew Creation

@crew
def crew(self) -> Crew:
    """Creates the LinkedinProfile crew"""
    return Crew(
        agents=self.agents,
                tasks=self.tasks,
                process=Process.sequential,
                verbose=True
    )

The @crew annotation is used to decorate the method that creates and returns the Crew object. This method assembles all the components (agents and tasks) into a functional crew.

YAML Configuration

The agent configurations are typically stored in a YAML file. Here’s an example of how the agents.yaml file might look for the researcher agent:

researcher:
    role: >
        LinkedIn Profile Senior Data Researcher
    goal: >
        Uncover detailed LinkedIn profiles based on provided name {name} and domain {domain}
        Generate a Dall-E image based on domain {domain}
    backstory: >
        You're a seasoned researcher with a knack for uncovering the most relevant      LinkedIn profiles.
        Known for your ability to navigate LinkedIn efficiently, you excel at            gathering and presenting
        professional information clearly and concisely.
    allow_delegation: False
    verbose: True
    llm: groq_llm
    tools:
        - myLinkedInProfileTool
        - mySerperDevTool
        - myDallETool

This YAML configuration corresponds to the researcher agent defined in the LinkedinProfileCrew class. The configuration specifies the agent’s role, goal, backstory, and other properties such as the LLM and tools it uses.

Note how the llm and tools in the YAML file correspond to the methods decorated with @llm and @tool in the Python class. This connection allows for a flexible and modular design where you can easily update agent configurations without changing the core code.

Best Practices

Consistent Naming: Use clear and consistent naming conventions for your methods. For example, agent methods could be named after their roles (e.g., researcher, reporting_analyst).
Environment Variables: Use environment variables for sensitive information like API keys.
Flexibility: Design your crew to be flexible by allowing easy addition or removal of agents and tasks.
YAML-Code Correspondence: Ensure that the names and structures in your YAML files correspond correctly to the decorated methods in your Python code.

By following these guidelines and properly using annotations, you can create well-structured and maintainable crews using the CrewAI framework.

How to Integrate CrewAI Enterprise with Zapier

How to Integrate CrewAI Enterprise with HubSpot

How to connect Azure OpenAI with Crew Studio?

How to use HITL?

How to configure Salesforce with CrewAI Enterprise

How can you control the maximum number of requests per minute that the entire crew can perform?

Getting Started

How-To Guides

Features

Resources

Hierarchical Process:

Sequential Process:

Which Process is Better Suited for Complex Projects?