# Table of Contents
- [Introduction - CrewAI](#introduction-crewai)
- [Installation - CrewAI](#installation-crewai)
- [CrewAI Examples - CrewAI](#crewai-examples-crewai)
- [Quickstart - CrewAI](#quickstart-crewai)
- [Agents - CrewAI](#agents-crewai)
- [Crews - CrewAI](#crews-crewai)
- [Tasks - CrewAI](#tasks-crewai)
- [Flows - CrewAI](#flows-crewai)
- [Processes - CrewAI](#processes-crewai)
- [Collaboration - CrewAI](#collaboration-crewai)
- [Planning - CrewAI](#planning-crewai)
- [Memory - CrewAI](#memory-crewai)
- [LLMs - CrewAI](#llms-crewai)
- [Knowledge - CrewAI](#knowledge-crewai)
- [Training - CrewAI](#training-crewai)
- [CLI - CrewAI](#cli-crewai)
- [Testing - CrewAI](#testing-crewai)
- [Using LangChain Tools - CrewAI](#using-langchain-tools-crewai)
- [Tools - CrewAI](#tools-crewai)
- [Using LlamaIndex Tools - CrewAI](#using-llamaindex-tools-crewai)
- [Create Custom Tools - CrewAI](#create-custom-tools-crewai)
---
# Introduction - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Get Started
Introduction
[Get Started](/introduction)
[Examples](/examples/example)
[](#what-is-crewai%3F)
What is CrewAI?
==========================================
**CrewAI is a cutting-edge framework for orchestrating autonomous AI agents.**
CrewAI enables you to create AI teams where each agent has specific roles, tools, and goals, working together to accomplish complex tasks.
Think of it as assembling your dream team - each member (agent) brings unique skills and expertise, collaborating seamlessly to achieve your objectives.
[](#how-crewai-works)
How CrewAI Works
------------------------------------------
Just like a company has departments (Sales, Engineering, Marketing) working together under leadership to achieve business goals, CrewAI helps you create an organization of AI agents with specialized roles collaborating to accomplish complex tasks.
CrewAI Framework Overview
| Component | Description | Key Features |
| --- | --- | --- |
| **Crew** | The top-level organization | • Manages AI agent teams
• Oversees workflows
• Ensures collaboration
• Delivers outcomes |
| **AI Agents** | Specialized team members | • Have specific roles (researcher, writer)
• Use designated tools
• Can delegate tasks
• Make autonomous decisions |
| **Process** | Workflow management system | • Defines collaboration patterns
• Controls task assignments
• Manages interactions
• Ensures efficient execution |
| **Tasks** | Individual assignments | • Have clear objectives
• Use specific tools
• Feed into larger process
• Produce actionable results |
###
[](#how-it-all-works-together)
How It All Works Together
1. The **Crew** organizes the overall operation
2. **AI Agents** work on their specialized tasks
3. The **Process** ensures smooth collaboration
4. **Tasks** get completed to achieve the goal
[](#key-features)
Key Features
----------------------------------
Role-Based Agents
-----------------
Create specialized agents with defined roles, expertise, and goals - from researchers to analysts to writers
Flexible Tools
--------------
Equip agents with custom tools and APIs to interact with external services and data sources
Intelligent Collaboration
-------------------------
Agents work together, sharing insights and coordinating tasks to achieve complex objectives
Task Management
---------------
Define sequential or parallel workflows, with agents automatically handling task dependencies
[](#why-choose-crewai%3F)
Why Choose CrewAI?
------------------------------------------------
* 🧠 **Autonomous Operation**: Agents make intelligent decisions based on their roles and available tools
* 📝 **Natural Interaction**: Agents communicate and collaborate like human team members
* 🛠️ **Extensible Design**: Easy to add new tools, roles, and capabilities
* 🚀 **Production Ready**: Built for reliability and scalability in real-world applications
[Install CrewAI\
--------------\
\
Get started with CrewAI in your development environment.](/installation)
[Quick Start\
-----------\
\
Follow our quickstart guide to create your first CrewAI agent and get hands-on experience.](/quickstart)
[Join the Community\
------------------\
\
Connect with other developers, get help, and share your CrewAI experiences.](https://community.crewai.com)
Was this page helpful?
YesNo
[Installation](/installation)
On this page
* [What is CrewAI?](#what-is-crewai%3F)
* [How CrewAI Works](#how-crewai-works)
* [How It All Works Together](#how-it-all-works-together)
* [Key Features](#key-features)
* [Why Choose CrewAI?](#why-choose-crewai%3F)
---
# Installation - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Get Started
Installation
[Get Started](/introduction)
[Examples](/examples/example)
**Python Version Requirements**
CrewAI requires `Python >=3.10 and <3.13`. Here’s how to check your version:
python3 --version
If you need to update Python, visit [python.org/downloads](https://python.org/downloads)
[](#setting-up-your-environment)
Setting Up Your Environment
================================================================
Before installing CrewAI, it’s recommended to set up a virtual environment. This helps isolate your project dependencies and avoid conflicts.
1
Create a Virtual Environment
Choose your preferred method to create a virtual environment:
**Using venv (Python’s built-in tool):**
Terminal
python3 -m venv .venv
**Using conda:**
Terminal
conda create -n crewai-env python=3.12
2
Activate the Virtual Environment
Activate your virtual environment based on your platform:
**On macOS/Linux (venv):**
Terminal
source .venv/bin/activate
**On Windows (venv):**
Terminal
.venv\Scripts\activate
**Using conda (all platforms):**
Terminal
conda activate crewai-env
[](#installing-crewai)
Installing CrewAI
============================================
Now let’s get you set up! 🚀
1
Install CrewAI
Install CrewAI with all recommended tools using either method:
Terminal
pip install 'crewai[tools]'
or
Terminal
pip install crewai crewai-tools
Both methods install the core package and additional tools needed for most use cases.
2
Upgrade CrewAI (Existing Installations Only)
If you have an older version of CrewAI installed, you can upgrade it:
Terminal
pip install --upgrade crewai crewai-tools
If you see a Poetry-related warning, you’ll need to migrate to our new dependency manager:
Terminal
crewai update
This will update your project to use [UV](https://github.com/astral-sh/uv)
, our new faster dependency manager.
Skip this step if you’re doing a fresh installation.
3
Verify Installation
Check your installed versions:
Terminal
pip freeze | grep crewai
You should see something like:
Output
crewai==X.X.X
crewai-tools==X.X.X
Installation successful! You’re ready to create your first crew.
[](#creating-a-new-project)
Creating a New Project
======================================================
We recommend using the YAML Template scaffolding for a structured approach to defining agents and tasks.
1
Generate Project Structure
Run the CrewAI CLI command:
Terminal
crewai create crew
This creates a new project with the following structure:
my_project/
├── .gitignore
├── pyproject.toml
├── README.md
├── .env
└── src/
└── my_project/
├── __init__.py
├── main.py
├── crew.py
├── tools/
│ ├── custom_tool.py
│ └── __init__.py
└── config/
├── agents.yaml
└── tasks.yaml
2
Install Additional Tools
You can install additional tools using UV:
Terminal
uv add
UV is our preferred package manager as it’s significantly faster than pip and provides better dependency resolution.
3
Customize Your Project
Your project will contain these essential files:
| File | Purpose |
| --- | --- |
| `agents.yaml` | Define your AI agents and their roles |
| `tasks.yaml` | Set up agent tasks and workflows |
| `.env` | Store API keys and environment variables |
| `main.py` | Project entry point and execution flow |
| `crew.py` | Crew orchestration and coordination |
| `tools/` | Directory for custom agent tools |
Start by editing `agents.yaml` and `tasks.yaml` to define your crew’s behavior. Keep sensitive information like API keys in `.env`.
[](#next-steps)
Next Steps
------------------------------
[Build Your First Agent\
----------------------\
\
Follow our quickstart guide to create your first CrewAI agent and get hands-on experience.](/quickstart)
[Join the Community\
------------------\
\
Connect with other developers, get help, and share your CrewAI experiences.](https://community.crewai.com)
Was this page helpful?
YesNo
[Introduction](/introduction)
[Quickstart](/quickstart)
On this page
* [Setting Up Your Environment](#setting-up-your-environment)
* [Installing CrewAI](#installing-crewai)
* [Creating a New Project](#creating-a-new-project)
* [Next Steps](#next-steps)
---
# CrewAI Examples - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Examples
CrewAI Examples
[Get Started](/introduction)
[Examples](/examples/example)
[Marketing Strategy\
------------------\
\
Automate marketing strategy creation with CrewAI.](https://github.com/crewAIInc/crewAI-examples/tree/main/marketing_strategy)
[Surprise Trip\
-------------\
\
Create a surprise trip itinerary with CrewAI.](https://github.com/crewAIInc/crewAI-examples/tree/main/surprise_trip)
[Match Profile to Positions\
--------------------------\
\
Match a profile to jobpositions with CrewAI.](https://github.com/crewAIInc/crewAI-examples/tree/main/match_profile_to_positions)
[Create Job Posting\
------------------\
\
Create a job posting with CrewAI.](https://github.com/crewAIInc/crewAI-examples/tree/main/job-posting)
[Game Generator\
--------------\
\
Create a game with CrewAI.](https://github.com/crewAIInc/crewAI-examples/tree/main/game-builder-crew)
[Find Job Candidates\
-------------------\
\
Find job candidates with CrewAI.](https://github.com/crewAIInc/crewAI-examples/tree/main/recruitment)
Was this page helpful?
YesNo
---
# Quickstart - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Get Started
Quickstart
[Get Started](/introduction)
[Examples](/examples/example)
[](#build-your-first-crewai-agent)
Build your first CrewAI Agent
--------------------------------------------------------------------
Let’s create a simple crew that will help us `research` and `report` on the `latest AI developments` for a given topic or subject.
Before we proceed, make sure you have `crewai` and `crewai-tools` installed. If you haven’t installed them yet, you can do so by following the [installation guide](/installation)
.
Follow the steps below to get crewing! 🚣♂️
1
Create your crew
Create a new crew project by running the following command in your terminal. This will create a new directory called `latest-ai-development` with the basic structure for your crew.
Terminal
crewai create crew latest-ai-development
2
Modify your \`agents.yaml\` file
You can also modify the agents as needed to fit your use case or copy and paste as is to your project. Any variable interpolated in your `agents.yaml` and `tasks.yaml` files like `{topic}` will be replaced by the value of the variable in the `main.py` file.
agents.yaml
# src/latest_ai_development/config/agents.yaml
researcher:
role: >
{topic} Senior Data Researcher
goal: >
Uncover cutting-edge developments in {topic}
backstory: >
You're a seasoned researcher with a knack for uncovering the latest
developments in {topic}. Known for your ability to find the most relevant
information and present it in a clear and concise manner.
reporting_analyst:
role: >
{topic} Reporting Analyst
goal: >
Create detailed reports based on {topic} data analysis and research findings
backstory: >
You're a meticulous analyst with a keen eye for detail. You're known for
your ability to turn complex data into clear and concise reports, making
it easy for others to understand and act on the information you provide.
3
Modify your \`tasks.yaml\` file
tasks.yaml
# src/latest_ai_development/config/tasks.yaml
research_task:
description: >
Conduct a thorough research about {topic}
Make sure you find any interesting and relevant information given
the current year is 2025.
expected_output: >
A list with 10 bullet points of the most relevant information about {topic}
agent: researcher
reporting_task:
description: >
Review the context you got and expand each topic into a full section for a report.
Make sure the report is detailed and contains any and all relevant information.
expected_output: >
A fully fledge reports with the mains topics, each with a full section of information.
Formatted as markdown without '```'
agent: reporting_analyst
output_file: report.md
4
Modify your \`crew.py\` file
crew.py
# src/latest_ai_development/crew.py
from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from crewai_tools import SerperDevTool
@CrewBase
class LatestAiDevelopmentCrew():
"""LatestAiDevelopment crew"""
@agent
def researcher(self) -> Agent:
return Agent(
config=self.agents_config['researcher'],
verbose=True,
tools=[SerperDevTool()]
)
@agent
def reporting_analyst(self) -> Agent:
return Agent(
config=self.agents_config['reporting_analyst'],
verbose=True
)
@task
def research_task(self) -> Task:
return Task(
config=self.tasks_config['research_task'],
)
@task
def reporting_task(self) -> Task:
return Task(
config=self.tasks_config['reporting_task'],
output_file='output/report.md' # This is the file that will be contain the final report.
)
@crew
def crew(self) -> Crew:
"""Creates the LatestAiDevelopment crew"""
return Crew(
agents=self.agents, # Automatically created by the @agent decorator
tasks=self.tasks, # Automatically created by the @task decorator
process=Process.sequential,
verbose=True,
)
5
\[Optional\] Add before and after crew functions
crew.py
# src/latest_ai_development/crew.py
from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task, before_kickoff, after_kickoff
from crewai_tools import SerperDevTool
@CrewBase
class LatestAiDevelopmentCrew():
"""LatestAiDevelopment crew"""
@before_kickoff
def before_kickoff_function(self, inputs):
print(f"Before kickoff function with inputs: {inputs}")
return inputs # You can return the inputs or modify them as needed
@after_kickoff
def after_kickoff_function(self, result):
print(f"After kickoff function with result: {result}")
return result # You can return the result or modify it as needed
# ... remaining code
6
Feel free to pass custom inputs to your crew
For example, you can pass the `topic` input to your crew to customize the research and reporting.
main.py
#!/usr/bin/env python
# src/latest_ai_development/main.py
import sys
from latest_ai_development.crew import LatestAiDevelopmentCrew
def run():
"""
Run the crew.
"""
inputs = {
'topic': 'AI Agents'
}
LatestAiDevelopmentCrew().crew().kickoff(inputs=inputs)
7
Set your environment variables
Before running your crew, make sure you have the following keys set as environment variables in your `.env` file:
* An [OpenAI API key](https://platform.openai.com/account/api-keys)
(or other LLM API key): `OPENAI_API_KEY=sk-...`
* A [Serper.dev](https://serper.dev/)
API key: `SERPER_API_KEY=YOUR_KEY_HERE`
8
Lock and install the dependencies
Lock the dependencies and install them by using the CLI command but first, navigate to your project directory:
Terminal
cd latest-ai-development
crewai install
9
Run your crew
To run your crew, execute the following command in the root of your project:
Terminal
crewai run
10
View your final report
You should see the output in the console and the `report.md` file should be created in the root of your project with the final report.
Here’s an example of what the report should look like:
output/report.md
# Comprehensive Report on the Rise and Impact of AI Agents in 2025
## 1. Introduction to AI Agents
In 2025, Artificial Intelligence (AI) agents are at the forefront of innovation across various industries. As intelligent systems that can perform tasks typically requiring human cognition, AI agents are paving the way for significant advancements in operational efficiency, decision-making, and overall productivity within sectors like Human Resources (HR) and Finance. This report aims to detail the rise of AI agents, their frameworks, applications, and potential implications on the workforce.
## 2. Benefits of AI Agents
AI agents bring numerous advantages that are transforming traditional work environments. Key benefits include:
- **Task Automation**: AI agents can carry out repetitive tasks such as data entry, scheduling, and payroll processing without human intervention, greatly reducing the time and resources spent on these activities.
- **Improved Efficiency**: By quickly processing large datasets and performing analyses that would take humans significantly longer, AI agents enhance operational efficiency. This allows teams to focus on strategic tasks that require higher-level thinking.
- **Enhanced Decision-Making**: AI agents can analyze trends and patterns in data, provide insights, and even suggest actions, helping stakeholders make informed decisions based on factual data rather than intuition alone.
## 3. Popular AI Agent Frameworks
Several frameworks have emerged to facilitate the development of AI agents, each with its own unique features and capabilities. Some of the most popular frameworks include:
- **Autogen**: A framework designed to streamline the development of AI agents through automation of code generation.
- **Semantic Kernel**: Focuses on natural language processing and understanding, enabling agents to comprehend user intentions better.
- **Promptflow**: Provides tools for developers to create conversational agents that can navigate complex interactions seamlessly.
- **Langchain**: Specializes in leveraging various APIs to ensure agents can access and utilize external data effectively.
- **CrewAI**: Aimed at collaborative environments, CrewAI strengthens teamwork by facilitating communication through AI-driven insights.
- **MemGPT**: Combines memory-optimized architectures with generative capabilities, allowing for more personalized interactions with users.
These frameworks empower developers to build versatile and intelligent agents that can engage users, perform advanced analytics, and execute various tasks aligned with organizational goals.
## 4. AI Agents in Human Resources
AI agents are revolutionizing HR practices by automating and optimizing key functions:
- **Recruiting**: AI agents can screen resumes, schedule interviews, and even conduct initial assessments, thus accelerating the hiring process while minimizing biases.
- **Succession Planning**: AI systems analyze employee performance data and potential, helping organizations identify future leaders and plan appropriate training.
- **Employee Engagement**: Chatbots powered by AI can facilitate feedback loops between employees and management, promoting an open culture and addressing concerns promptly.
As AI continues to evolve, HR departments leveraging these agents can realize substantial improvements in both efficiency and employee satisfaction.
## 5. AI Agents in Finance
The finance sector is seeing extensive integration of AI agents that enhance financial practices:
- **Expense Tracking**: Automated systems manage and monitor expenses, flagging anomalies and offering recommendations based on spending patterns.
- **Risk Assessment**: AI models assess credit risk and uncover potential fraud by analyzing transaction data and behavioral patterns.
- **Investment Decisions**: AI agents provide stock predictions and analytics based on historical data and current market conditions, empowering investors with informative insights.
The incorporation of AI agents into finance is fostering a more responsive and risk-aware financial landscape.
## 6. Market Trends and Investments
The growth of AI agents has attracted significant investment, especially amidst the rising popularity of chatbots and generative AI technologies. Companies and entrepreneurs are eager to explore the potential of these systems, recognizing their ability to streamline operations and improve customer engagement.
Conversely, corporations like Microsoft are taking strides to integrate AI agents into their product offerings, with enhancements to their Copilot 365 applications. This strategic move emphasizes the importance of AI literacy in the modern workplace and indicates the stabilizing of AI agents as essential business tools.
## 7. Future Predictions and Implications
Experts predict that AI agents will transform essential aspects of work life. As we look toward the future, several anticipated changes include:
- Enhanced integration of AI agents across all business functions, creating interconnected systems that leverage data from various departmental silos for comprehensive decision-making.
- Continued advancement of AI technologies, resulting in smarter, more adaptable agents capable of learning and evolving from user interactions.
- Increased regulatory scrutiny to ensure ethical use, especially concerning data privacy and employee surveillance as AI agents become more prevalent.
To stay competitive and harness the full potential of AI agents, organizations must remain vigilant about latest developments in AI technology and consider continuous learning and adaptation in their strategic planning.
## 8. Conclusion
The emergence of AI agents is undeniably reshaping the workplace landscape in 5. With their ability to automate tasks, enhance efficiency, and improve decision-making, AI agents are critical in driving operational success. Organizations must embrace and adapt to AI developments to thrive in an increasingly digital business environment.
###
[](#note-on-consistency-in-naming)
Note on Consistency in Naming
The names you use in your YAML files (`agents.yaml` and `tasks.yaml`) should match the method names in your Python code. For example, you can reference the agent for specific tasks from `tasks.yaml` file. This naming consistency allows CrewAI to automatically link your configurations with your code; otherwise, your task won’t recognize the reference properly.
####
[](#example-references)
Example References
Note how we use the same name for the agent in the `agents.yaml` (`email_summarizer`) file as the method name in the `crew.py` (`email_summarizer`) file.
agents.yaml
email_summarizer:
role: >
Email Summarizer
goal: >
Summarize emails into a concise and clear summary
backstory: >
You will create a 5 bullet point summary of the report
llm: openai/gpt-4o
Note how we use the same name for the agent in the `tasks.yaml` (`email_summarizer_task`) file as the method name in the `crew.py` (`email_summarizer_task`) file.
tasks.yaml
email_summarizer_task:
description: >
Summarize the email into a 5 bullet point summary
expected_output: >
A 5 bullet point summary of the email
agent: email_summarizer
context:
- reporting_task
- research_task
Use the annotations to properly reference the agent and task in the `crew.py` file.
###
[](#annotations-include%3A)
Annotations include:
Here are examples of how to use each annotation in your CrewAI project, and when you should use them:
####
[](#%40agent)
@agent
Used to define an agent in your crew. Use this when:
* You need to create a specialized AI agent with a specific role
* You want the agent to be automatically collected and managed by the crew
* You need to reuse the same agent configuration across multiple tasks
@agent
def research_agent(self) -> Agent:
return Agent(
role="Research Analyst",
goal="Conduct thorough research on given topics",
backstory="Expert researcher with years of experience in data analysis",
tools=[SerperDevTool()],
verbose=True
)
####
[](#%40task)
@task
Used to define a task that can be executed by agents. Use this when:
* You need to define a specific piece of work for an agent
* You want tasks to be automatically sequenced and managed
* You need to establish dependencies between different tasks
@task
def research_task(self) -> Task:
return Task(
description="Research the latest developments in AI technology",
expected_output="A comprehensive report on AI advancements",
agent=self.research_agent(),
output_file="output/research.md"
)
####
[](#%40crew)
@crew
Used to define your crew configuration. Use this when:
* You want to automatically collect all @agent and @task definitions
* You need to specify how tasks should be processed (sequential or hierarchical)
* You want to set up crew-wide configurations
@crew
def research_crew(self) -> Crew:
return Crew(
agents=self.agents, # Automatically collected from @agent methods
tasks=self.tasks, # Automatically collected from @task methods
process=Process.sequential,
verbose=True
)
####
[](#%40tool)
@tool
Used to create custom tools for your agents. Use this when:
* You need to give agents specific capabilities (like web search, data analysis)
* You want to encapsulate external API calls or complex operations
* You need to share functionality across multiple agents
@tool
def web_search_tool(query: str, max_results: int = 5) -> list[str]:
"""
Search the web for information.
Args:
query: The search query
max_results: Maximum number of results to return
Returns:
List of search results
"""
# Implement your search logic here
return [f"Result {i} for: {query}" for i in range(max_results)]
####
[](#%40before-kickoff)
@before\_kickoff
Used to execute logic before the crew starts. Use this when:
* You need to validate or preprocess input data
* You want to set up resources or configurations before execution
* You need to perform any initialization logic
@before_kickoff
def validate_inputs(self, inputs: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
"""Validate and preprocess inputs before the crew starts."""
if inputs is None:
return None
if 'topic' not in inputs:
raise ValueError("Topic is required")
# Add additional context
inputs['timestamp'] = datetime.now().isoformat()
inputs['topic'] = inputs['topic'].strip().lower()
return inputs
####
[](#%40after-kickoff)
@after\_kickoff
Used to process results after the crew completes. Use this when:
* You need to format or transform the final output
* You want to perform cleanup operations
* You need to save or log the results in a specific way
@after_kickoff
def process_results(self, result: CrewOutput) -> CrewOutput:
"""Process and format the results after the crew completes."""
result.raw = result.raw.strip()
result.raw = f"""
# Research Results
Generated on: {datetime.now().isoformat()}
{result.raw}
"""
return result
####
[](#%40callback)
@callback
Used to handle events during crew execution. Use this when:
* You need to monitor task progress
* You want to log intermediate results
* You need to implement custom progress tracking or metrics
@callback
def log_task_completion(self, task: Task, output: str):
"""Log task completion details for monitoring."""
print(f"Task '{task.description}' completed")
print(f"Output length: {len(output)} characters")
print(f"Agent used: {task.agent.role}")
print("-" * 50)
####
[](#%40cache-handler)
@cache\_handler
Used to implement custom caching for task results. Use this when:
* You want to avoid redundant expensive operations
* You need to implement custom cache storage or expiration logic
* You want to persist results between runs
@cache_handler
def custom_cache(self, key: str) -> Optional[str]:
"""Custom cache implementation for storing task results."""
cache_file = f"cache/{key}.json"
if os.path.exists(cache_file):
with open(cache_file, 'r') as f:
data = json.load(f)
# Check if cache is still valid (e.g., not expired)
if datetime.fromisoformat(data['timestamp']) > datetime.now() - timedelta(days=1):
return data['result']
return None
These decorators are part of the CrewAI framework and help organize your crew’s structure by automatically collecting agents, tasks, and handling various lifecycle events. They should be used within a class decorated with `@CrewBase`.
###
[](#replay-tasks-from-latest-crew-kickoff)
Replay Tasks from Latest Crew Kickoff
CrewAI now includes a replay feature that allows you to list the tasks from the last run and replay from a specific one. To use this feature, run.
crewai replay
Replace `` with the ID of the task you want to replay.
###
[](#reset-crew-memory)
Reset Crew Memory
If you need to reset the memory of your crew before running it again, you can do so by calling the reset memory feature:
crewai reset-memories --all
This will clear the crew’s memory, allowing for a fresh start.
[](#deploying-your-project)
Deploying Your Project
------------------------------------------------------
The easiest way to deploy your crew is through CrewAI Enterprise, where you can deploy your crew in a few clicks.
[Deploy on Enterprise\
--------------------\
\
Get started with CrewAI Enterprise and deploy your crew in a production environment with just a few clicks.](http://app.crewai.com)
[Join the Community\
------------------\
\
Join our open source community to discuss ideas, share your projects, and connect with other CrewAI developers.](https://community.crewai.com)
Was this page helpful?
YesNo
[Installation](/installation)
[Agents](/concepts/agents)
On this page
* [Build your first CrewAI Agent](#build-your-first-crewai-agent)
* [Note on Consistency in Naming](#note-on-consistency-in-naming)
* [Example References](#example-references)
* [Annotations include:](#annotations-include%3A)
* [@agent](#%40agent)
* [@task](#%40task)
* [@crew](#%40crew)
* [@tool](#%40tool)
* [@before\_kickoff](#%40before-kickoff)
* [@after\_kickoff](#%40after-kickoff)
* [@callback](#%40callback)
* [@cache\_handler](#%40cache-handler)
* [Replay Tasks from Latest Crew Kickoff](#replay-tasks-from-latest-crew-kickoff)
* [Reset Crew Memory](#reset-crew-memory)
* [Deploying Your Project](#deploying-your-project)
---
# Agents - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Core Concepts
Agents
[Get Started](/introduction)
[Examples](/examples/example)
[](#overview-of-an-agent)
Overview of an Agent
--------------------------------------------------
In the CrewAI framework, an `Agent` is an autonomous unit that can:
* Perform specific tasks
* Make decisions based on its role and goal
* Use tools to accomplish objectives
* Communicate and collaborate with other agents
* Maintain memory of interactions
* Delegate tasks when allowed
Think of an agent as a specialized team member with specific skills, expertise, and responsibilities. For example, a `Researcher` agent might excel at gathering and analyzing information, while a `Writer` agent might be better at creating content.
[](#agent-attributes)
Agent Attributes
------------------------------------------
| Attribute | Parameter | Type | Description |
| --- | --- | --- | --- |
| **Role** | `role` | `str` | Defines the agent’s function and expertise within the crew. |
| **Goal** | `goal` | `str` | The individual objective that guides the agent’s decision-making. |
| **Backstory** | `backstory` | `str` | Provides context and personality to the agent, enriching interactions. |
| **LLM** _(optional)_ | `llm` | `Union[str, LLM, Any]` | Language model that powers the agent. Defaults to the model specified in `OPENAI_MODEL_NAME` or “gpt-4”. |
| **Tools** _(optional)_ | `tools` | `List[BaseTool]` | Capabilities or functions available to the agent. Defaults to an empty list. |
| **Function Calling LLM** _(optional)_ | `function_calling_llm` | `Optional[Any]` | Language model for tool calling, overrides crew’s LLM if specified. |
| **Max Iterations** _(optional)_ | `max_iter` | `int` | Maximum iterations before the agent must provide its best answer. Default is 20. |
| **Max RPM** _(optional)_ | `max_rpm` | `Optional[int]` | Maximum requests per minute to avoid rate limits. |
| **Max Execution Time** _(optional)_ | `max_execution_time` | `Optional[int]` | Maximum time (in seconds) for task execution. |
| **Memory** _(optional)_ | `memory` | `bool` | Whether the agent should maintain memory of interactions. Default is True. |
| **Verbose** _(optional)_ | `verbose` | `bool` | Enable detailed execution logs for debugging. Default is False. |
| **Allow Delegation** _(optional)_ | `allow_delegation` | `bool` | Allow the agent to delegate tasks to other agents. Default is False. |
| **Step Callback** _(optional)_ | `step_callback` | `Optional[Any]` | Function called after each agent step, overrides crew callback. |
| **Cache** _(optional)_ | `cache` | `bool` | Enable caching for tool usage. Default is True. |
| **System Template** _(optional)_ | `system_template` | `Optional[str]` | Custom system prompt template for the agent. |
| **Prompt Template** _(optional)_ | `prompt_template` | `Optional[str]` | Custom prompt template for the agent. |
| **Response Template** _(optional)_ | `response_template` | `Optional[str]` | Custom response template for the agent. |
| **Allow Code Execution** _(optional)_ | `allow_code_execution` | `Optional[bool]` | Enable code execution for the agent. Default is False. |
| **Max Retry Limit** _(optional)_ | `max_retry_limit` | `int` | Maximum number of retries when an error occurs. Default is 2. |
| **Respect Context Window** _(optional)_ | `respect_context_window` | `bool` | Keep messages under context window size by summarizing. Default is True. |
| **Code Execution Mode** _(optional)_ | `code_execution_mode` | `Literal["safe", "unsafe"]` | Mode for code execution: ‘safe’ (using Docker) or ‘unsafe’ (direct). Default is ‘safe’. |
| **Embedder** _(optional)_ | `embedder` | `Optional[Dict[str, Any]]` | Configuration for the embedder used by the agent. |
| **Knowledge Sources** _(optional)_ | `knowledge_sources` | `Optional[List[BaseKnowledgeSource]]` | Knowledge sources available to the agent. |
| **Use System Prompt** _(optional)_ | `use_system_prompt` | `Optional[bool]` | Whether to use system prompt (for o1 model support). Default is True. |
[](#creating-agents)
Creating Agents
----------------------------------------
There are two ways to create agents in CrewAI: using **YAML configuration (recommended)** or defining them **directly in code**.
###
[](#yaml-configuration-recommended)
YAML Configuration (Recommended)
Using YAML configuration provides a cleaner, more maintainable way to define agents. We strongly recommend using this approach in your CrewAI projects.
After creating your CrewAI project as outlined in the [Installation](/installation)
section, navigate to the `src/latest_ai_development/config/agents.yaml` file and modify the template to match your requirements.
Variables in your YAML files (like `{topic}`) will be replaced with values from your inputs when running the crew:
Code
crew.kickoff(inputs={'topic': 'AI Agents'})
Here’s an example of how to configure agents using YAML:
agents.yaml
# src/latest_ai_development/config/agents.yaml
researcher:
role: >
{topic} Senior Data Researcher
goal: >
Uncover cutting-edge developments in {topic}
backstory: >
You're a seasoned researcher with a knack for uncovering the latest
developments in {topic}. Known for your ability to find the most relevant
information and present it in a clear and concise manner.
reporting_analyst:
role: >
{topic} Reporting Analyst
goal: >
Create detailed reports based on {topic} data analysis and research findings
backstory: >
You're a meticulous analyst with a keen eye for detail. You're known for
your ability to turn complex data into clear and concise reports, making
it easy for others to understand and act on the information you provide.
To use this YAML configuration in your code, create a crew class that inherits from `CrewBase`:
Code
# src/latest_ai_development/crew.py
from crewai import Agent, Crew, Process
from crewai.project import CrewBase, agent, crew
from crewai_tools import SerperDevTool
@CrewBase
class LatestAiDevelopmentCrew():
"""LatestAiDevelopment crew"""
agents_config = "config/agents.yaml"
@agent
def researcher(self) -> Agent:
return Agent(
config=self.agents_config['researcher'],
verbose=True,
tools=[SerperDevTool()]
)
@agent
def reporting_analyst(self) -> Agent:
return Agent(
config=self.agents_config['reporting_analyst'],
verbose=True
)
The names you use in your YAML files (`agents.yaml`) should match the method names in your Python code.
###
[](#direct-code-definition)
Direct Code Definition
You can create agents directly in code by instantiating the `Agent` class. Here’s a comprehensive example showing all available parameters:
Code
from crewai import Agent
from crewai_tools import SerperDevTool
# Create an agent with all available parameters
agent = Agent(
role="Senior Data Scientist",
goal="Analyze and interpret complex datasets to provide actionable insights",
backstory="With over 10 years of experience in data science and machine learning, "
"you excel at finding patterns in complex datasets.",
llm="gpt-4", # Default: OPENAI_MODEL_NAME or "gpt-4"
function_calling_llm=None, # Optional: Separate LLM for tool calling
memory=True, # Default: True
verbose=False, # Default: False
allow_delegation=False, # Default: False
max_iter=20, # Default: 20 iterations
max_rpm=None, # Optional: Rate limit for API calls
max_execution_time=None, # Optional: Maximum execution time in seconds
max_retry_limit=2, # Default: 2 retries on error
allow_code_execution=False, # Default: False
code_execution_mode="safe", # Default: "safe" (options: "safe", "unsafe")
respect_context_window=True, # Default: True
use_system_prompt=True, # Default: True
tools=[SerperDevTool()], # Optional: List of tools
knowledge_sources=None, # Optional: List of knowledge sources
embedder=None, # Optional: Custom embedder configuration
system_template=None, # Optional: Custom system prompt template
prompt_template=None, # Optional: Custom prompt template
response_template=None, # Optional: Custom response template
step_callback=None, # Optional: Callback function for monitoring
)
Let’s break down some key parameter combinations for common use cases:
####
[](#basic-research-agent)
Basic Research Agent
Code
research_agent = Agent(
role="Research Analyst",
goal="Find and summarize information about specific topics",
backstory="You are an experienced researcher with attention to detail",
tools=[SerperDevTool()],
verbose=True # Enable logging for debugging
)
####
[](#code-development-agent)
Code Development Agent
Code
dev_agent = Agent(
role="Senior Python Developer",
goal="Write and debug Python code",
backstory="Expert Python developer with 10 years of experience",
allow_code_execution=True,
code_execution_mode="safe", # Uses Docker for safety
max_execution_time=300, # 5-minute timeout
max_retry_limit=3 # More retries for complex code tasks
)
####
[](#long-running-analysis-agent)
Long-Running Analysis Agent
Code
analysis_agent = Agent(
role="Data Analyst",
goal="Perform deep analysis of large datasets",
backstory="Specialized in big data analysis and pattern recognition",
memory=True,
respect_context_window=True,
max_rpm=10, # Limit API calls
function_calling_llm="gpt-4o-mini" # Cheaper model for tool calls
)
####
[](#custom-template-agent)
Custom Template Agent
Code
custom_agent = Agent(
role="Customer Service Representative",
goal="Assist customers with their inquiries",
backstory="Experienced in customer support with a focus on satisfaction",
system_template="""<|start_header_id|>system<|end_header_id|>
{{ .System }}<|eot_id|>""",
prompt_template="""<|start_header_id|>user<|end_header_id|>
{{ .Prompt }}<|eot_id|>""",
response_template="""<|start_header_id|>assistant<|end_header_id|>
{{ .Response }}<|eot_id|>""",
)
###
[](#parameter-details)
Parameter Details
####
[](#critical-parameters)
Critical Parameters
* `role`, `goal`, and `backstory` are required and shape the agent’s behavior
* `llm` determines the language model used (default: OpenAI’s GPT-4)
####
[](#memory-and-context)
Memory and Context
* `memory`: Enable to maintain conversation history
* `respect_context_window`: Prevents token limit issues
* `knowledge_sources`: Add domain-specific knowledge bases
####
[](#execution-control)
Execution Control
* `max_iter`: Maximum attempts before giving best answer
* `max_execution_time`: Timeout in seconds
* `max_rpm`: Rate limiting for API calls
* `max_retry_limit`: Retries on error
####
[](#code-execution)
Code Execution
* `allow_code_execution`: Must be True to run code
* `code_execution_mode`:
* `"safe"`: Uses Docker (recommended for production)
* `"unsafe"`: Direct execution (use only in trusted environments)
####
[](#templates)
Templates
* `system_template`: Defines agent’s core behavior
* `prompt_template`: Structures input format
* `response_template`: Formats agent responses
When using custom templates, you can use variables like `{role}`, `{goal}`, and `{input}` in your templates. These will be automatically populated during execution.
[](#agent-tools)
Agent Tools
--------------------------------
Agents can be equipped with various tools to enhance their capabilities. CrewAI supports tools from:
* [CrewAI Toolkit](https://github.com/joaomdmoura/crewai-tools)
* [LangChain Tools](https://python.langchain.com/docs/integrations/tools)
Here’s how to add tools to an agent:
Code
from crewai import Agent
from crewai_tools import SerperDevTool, WikipediaTools
# Create tools
search_tool = SerperDevTool()
wiki_tool = WikipediaTools()
# Add tools to agent
researcher = Agent(
role="AI Technology Researcher",
goal="Research the latest AI developments",
tools=[search_tool, wiki_tool],
verbose=True
)
[](#agent-memory-and-context)
Agent Memory and Context
----------------------------------------------------------
Agents can maintain memory of their interactions and use context from previous tasks. This is particularly useful for complex workflows where information needs to be retained across multiple tasks.
Code
from crewai import Agent
analyst = Agent(
role="Data Analyst",
goal="Analyze and remember complex data patterns",
memory=True, # Enable memory
verbose=True
)
When `memory` is enabled, the agent will maintain context across multiple interactions, improving its ability to handle complex, multi-step tasks.
[](#important-considerations-and-best-practices)
Important Considerations and Best Practices
------------------------------------------------------------------------------------------------
###
[](#security-and-code-execution)
Security and Code Execution
* When using `allow_code_execution`, be cautious with user input and always validate it
* Use `code_execution_mode: "safe"` (Docker) in production environments
* Consider setting appropriate `max_execution_time` limits to prevent infinite loops
###
[](#performance-optimization)
Performance Optimization
* Use `respect_context_window: true` to prevent token limit issues
* Set appropriate `max_rpm` to avoid rate limiting
* Enable `cache: true` to improve performance for repetitive tasks
* Adjust `max_iter` and `max_retry_limit` based on task complexity
###
[](#memory-and-context-management)
Memory and Context Management
* Use `memory: true` for tasks requiring historical context
* Leverage `knowledge_sources` for domain-specific information
* Configure `embedder_config` when using custom embedding models
* Use custom templates (`system_template`, `prompt_template`, `response_template`) for fine-grained control over agent behavior
###
[](#agent-collaboration)
Agent Collaboration
* Enable `allow_delegation: true` when agents need to work together
* Use `step_callback` to monitor and log agent interactions
* Consider using different LLMs for different purposes:
* Main `llm` for complex reasoning
* `function_calling_llm` for efficient tool usage
###
[](#model-compatibility)
Model Compatibility
* Set `use_system_prompt: false` for older models that don’t support system messages
* Ensure your chosen `llm` supports the features you need (like function calling)
[](#troubleshooting-common-issues)
Troubleshooting Common Issues
--------------------------------------------------------------------
1. **Rate Limiting**: If you’re hitting API rate limits:
* Implement appropriate `max_rpm`
* Use caching for repetitive operations
* Consider batching requests
2. **Context Window Errors**: If you’re exceeding context limits:
* Enable `respect_context_window`
* Use more efficient prompts
* Clear agent memory periodically
3. **Code Execution Issues**: If code execution fails:
* Verify Docker is installed for safe mode
* Check execution permissions
* Review code sandbox settings
4. **Memory Issues**: If agent responses seem inconsistent:
* Verify memory is enabled
* Check knowledge source configuration
* Review conversation history management
Remember that agents are most effective when configured according to their specific use case. Take time to understand your requirements and adjust these parameters accordingly.
Was this page helpful?
YesNo
[Quickstart](/quickstart)
[Tasks](/concepts/tasks)
On this page
* [Overview of an Agent](#overview-of-an-agent)
* [Agent Attributes](#agent-attributes)
* [Creating Agents](#creating-agents)
* [YAML Configuration (Recommended)](#yaml-configuration-recommended)
* [Direct Code Definition](#direct-code-definition)
* [Basic Research Agent](#basic-research-agent)
* [Code Development Agent](#code-development-agent)
* [Long-Running Analysis Agent](#long-running-analysis-agent)
* [Custom Template Agent](#custom-template-agent)
* [Parameter Details](#parameter-details)
* [Critical Parameters](#critical-parameters)
* [Memory and Context](#memory-and-context)
* [Execution Control](#execution-control)
* [Code Execution](#code-execution)
* [Templates](#templates)
* [Agent Tools](#agent-tools)
* [Agent Memory and Context](#agent-memory-and-context)
* [Important Considerations and Best Practices](#important-considerations-and-best-practices)
* [Security and Code Execution](#security-and-code-execution)
* [Performance Optimization](#performance-optimization)
* [Memory and Context Management](#memory-and-context-management)
* [Agent Collaboration](#agent-collaboration)
* [Model Compatibility](#model-compatibility)
* [Troubleshooting Common Issues](#troubleshooting-common-issues)
---
# Crews - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Core Concepts
Crews
[Get Started](/introduction)
[Examples](/examples/example)
[](#what-is-a-crew%3F)
What is a Crew?
------------------------------------------
A crew in crewAI represents a collaborative group of agents working together to achieve a set of tasks. Each crew defines the strategy for task execution, agent collaboration, and the overall workflow.
[](#crew-attributes)
Crew Attributes
----------------------------------------
| Attribute | Parameters | Description |
| --- | --- | --- |
| **Tasks** | `tasks` | A list of tasks assigned to the crew. |
| **Agents** | `agents` | A list of agents that are part of the crew. |
| **Process** _(optional)_ | `process` | The process flow (e.g., sequential, hierarchical) the crew follows. Default is `sequential`. |
| **Verbose** _(optional)_ | `verbose` | The verbosity level for logging during execution. Defaults to `False`. |
| **Manager LLM** _(optional)_ | `manager_llm` | The language model used by the manager agent in a hierarchical process. **Required when using a hierarchical process.** |
| **Function Calling LLM** _(optional)_ | `function_calling_llm` | If passed, the crew will use this LLM to do function calling for tools for all agents in the crew. Each agent can have its own LLM, which overrides the crew’s LLM for function calling. |
| **Config** _(optional)_ | `config` | Optional configuration settings for the crew, in `Json` or `Dict[str, Any]` format. |
| **Max RPM** _(optional)_ | `max_rpm` | Maximum requests per minute the crew adheres to during execution. Defaults to `None`. |
| **Language** _(optional)_ | `language` | Language used for the crew, defaults to English. |
| **Language File** _(optional)_ | `language_file` | Path to the language file to be used for the crew. |
| **Memory** _(optional)_ | `memory` | Utilized for storing execution memories (short-term, long-term, entity memory). |
| **Memory Config** _(optional)_ | `memory_config` | Configuration for the memory provider to be used by the crew. |
| **Cache** _(optional)_ | `cache` | Specifies whether to use a cache for storing the results of tools’ execution. Defaults to `True`. |
| **Embedder** _(optional)_ | `embedder` | Configuration for the embedder to be used by the crew. Mostly used by memory for now. Default is `{"provider": "openai"}`. |
| **Full Output** _(optional)_ | `full_output` | Whether the crew should return the full output with all tasks outputs or just the final output. Defaults to `False`. |
| **Step Callback** _(optional)_ | `step_callback` | A function that is called after each step of every agent. This can be used to log the agent’s actions or to perform other operations; it won’t override the agent-specific `step_callback`. |
| **Task Callback** _(optional)_ | `task_callback` | A function that is called after the completion of each task. Useful for monitoring or additional operations post-task execution. |
| **Share Crew** _(optional)_ | `share_crew` | Whether you want to share the complete crew information and execution with the crewAI team to make the library better, and allow us to train models. |
| **Output Log File** _(optional)_ | `output_log_file` | Set to True to save logs as logs.txt in the current directory or provide a file path. Logs will be in JSON format if the filename ends in .json, otherwise .txt. Defautls to `None`. |
| **Manager Agent** _(optional)_ | `manager_agent` | `manager` sets a custom agent that will be used as a manager. |
| **Prompt File** _(optional)_ | `prompt_file` | Path to the prompt JSON file to be used for the crew. |
| **Planning** _(optional)_ | `planning` | Adds planning ability to the Crew. When activated before each Crew iteration, all Crew data is sent to an AgentPlanner that will plan the tasks and this plan will be added to each task description. |
| **Planning LLM** _(optional)_ | `planning_llm` | The language model used by the AgentPlanner in a planning process. |
**Crew Max RPM**: The `max_rpm` attribute sets the maximum number of requests per minute the crew can perform to avoid rate limits and will override individual agents’ `max_rpm` settings if you set it.
[](#creating-crews)
Creating Crews
--------------------------------------
There are two ways to create crews in CrewAI: using **YAML configuration (recommended)** or defining them **directly in code**.
###
[](#yaml-configuration-recommended)
YAML Configuration (Recommended)
Using YAML configuration provides a cleaner, more maintainable way to define crews and is consistent with how agents and tasks are defined in CrewAI projects.
After creating your CrewAI project as outlined in the [Installation](/installation)
section, you can define your crew in a class that inherits from `CrewBase` and uses decorators to define agents, tasks, and the crew itself.
####
[](#example-crew-class-with-decorators)
Example Crew Class with Decorators
code
from crewai import Agent, Crew, Task, Process
from crewai.project import CrewBase, agent, task, crew, before_kickoff, after_kickoff
@CrewBase
class YourCrewName:
"""Description of your crew"""
# Paths to your YAML configuration files
# To see an example agent and task defined in YAML, checkout the following:
# - Task: https://docs.crewai.com/concepts/tasks#yaml-configuration-recommended
# - Agents: https://docs.crewai.com/concepts/agents#yaml-configuration-recommended
agents_config = 'config/agents.yaml'
tasks_config = 'config/tasks.yaml'
@before_kickoff
def prepare_inputs(self, inputs):
# Modify inputs before the crew starts
inputs['additional_data'] = "Some extra information"
return inputs
@after_kickoff
def process_output(self, output):
# Modify output after the crew finishes
output.raw += "\nProcessed after kickoff."
return output
@agent
def agent_one(self) -> Agent:
return Agent(
config=self.agents_config['agent_one'],
verbose=True
)
@agent
def agent_two(self) -> Agent:
return Agent(
config=self.agents_config['agent_two'],
verbose=True
)
@task
def task_one(self) -> Task:
return Task(
config=self.tasks_config['task_one']
)
@task
def task_two(self) -> Task:
return Task(
config=self.tasks_config['task_two']
)
@crew
def crew(self) -> Crew:
return Crew(
agents=self.agents, # Automatically collected by the @agent decorator
tasks=self.tasks, # Automatically collected by the @task decorator.
process=Process.sequential,
verbose=True,
)
Tasks will be executed in the order they are defined.
The `CrewBase` class, along with these decorators, automates the collection of agents and tasks, reducing the need for manual management.
####
[](#decorators-overview-from-annotations-py)
Decorators overview from `annotations.py`
CrewAI provides several decorators in the `annotations.py` file that are used to mark methods within your crew class for special handling:
* `@CrewBase`: Marks the class as a crew base class.
* `@agent`: Denotes a method that returns an `Agent` object.
* `@task`: Denotes a method that returns a `Task` object.
* `@crew`: Denotes the method that returns the `Crew` object.
* `@before_kickoff`: (Optional) Marks a method to be executed before the crew starts.
* `@after_kickoff`: (Optional) Marks a method to be executed after the crew finishes.
These decorators help in organizing your crew’s structure and automatically collecting agents and tasks without manually listing them.
###
[](#direct-code-definition-alternative)
Direct Code Definition (Alternative)
Alternatively, you can define the crew directly in code without using YAML configuration files.
code
from crewai import Agent, Crew, Task, Process
from crewai_tools import YourCustomTool
class YourCrewName:
def agent_one(self) -> Agent:
return Agent(
role="Data Analyst",
goal="Analyze data trends in the market",
backstory="An experienced data analyst with a background in economics",
verbose=True,
tools=[YourCustomTool()]
)
def agent_two(self) -> Agent:
return Agent(
role="Market Researcher",
goal="Gather information on market dynamics",
backstory="A diligent researcher with a keen eye for detail",
verbose=True
)
def task_one(self) -> Task:
return Task(
description="Collect recent market data and identify trends.",
expected_output="A report summarizing key trends in the market.",
agent=self.agent_one()
)
def task_two(self) -> Task:
return Task(
description="Research factors affecting market dynamics.",
expected_output="An analysis of factors influencing the market.",
agent=self.agent_two()
)
def crew(self) -> Crew:
return Crew(
agents=[self.agent_one(), self.agent_two()],
tasks=[self.task_one(), self.task_two()],
process=Process.sequential,
verbose=True
)
In this example:
* Agents and tasks are defined directly within the class without decorators.
* We manually create and manage the list of agents and tasks.
* This approach provides more control but can be less maintainable for larger projects.
[](#crew-output)
Crew Output
--------------------------------
The output of a crew in the CrewAI framework is encapsulated within the `CrewOutput` class. This class provides a structured way to access results of the crew’s execution, including various formats such as raw strings, JSON, and Pydantic models. The `CrewOutput` includes the results from the final task output, token usage, and individual task outputs.
###
[](#crew-output-attributes)
Crew Output Attributes
| Attribute | Parameters | Type | Description |
| --- | --- | --- | --- |
| **Raw** | `raw` | `str` | The raw output of the crew. This is the default format for the output. |
| **Pydantic** | `pydantic` | `Optional[BaseModel]` | A Pydantic model object representing the structured output of the crew. |
| **JSON Dict** | `json_dict` | `Optional[Dict[str, Any]]` | A dictionary representing the JSON output of the crew. |
| **Tasks Output** | `tasks_output` | `List[TaskOutput]` | A list of `TaskOutput` objects, each representing the output of a task in the crew. |
| **Token Usage** | `token_usage` | `Dict[str, Any]` | A summary of token usage, providing insights into the language model’s performance during execution. |
###
[](#crew-output-methods-and-properties)
Crew Output Methods and Properties
| Method/Property | Description |
| --- | --- |
| **json** | Returns the JSON string representation of the crew output if the output format is JSON. |
| **to\_dict** | Converts the JSON and Pydantic outputs to a dictionary. |
| \***\*str\*\*** | Returns the string representation of the crew output, prioritizing Pydantic, then JSON, then raw. |
###
[](#accessing-crew-outputs)
Accessing Crew Outputs
Once a crew has been executed, its output can be accessed through the `output` attribute of the `Crew` object. The `CrewOutput` class provides various ways to interact with and present this output.
####
[](#example)
Example
Code
# Example crew execution
crew = Crew(
agents=[research_agent, writer_agent],
tasks=[research_task, write_article_task],
verbose=True
)
crew_output = crew.kickoff()
# Accessing the crew output
print(f"Raw Output: {crew_output.raw}")
if crew_output.json_dict:
print(f"JSON Output: {json.dumps(crew_output.json_dict, indent=2)}")
if crew_output.pydantic:
print(f"Pydantic Output: {crew_output.pydantic}")
print(f"Tasks Output: {crew_output.tasks_output}")
print(f"Token Usage: {crew_output.token_usage}")
[](#accessing-crew-logs)
Accessing Crew Logs
------------------------------------------------
You can see real time log of the crew execution, by setting `output_log_file` as a `True(Boolean)` or a `file_name(str)`. Supports logging of events as both `file_name.txt` and `file_name.json`. In case of `True(Boolean)` will save as `logs.txt`.
In case of `output_log_file` is set as `False(Booelan)` or `None`, the logs will not be populated.
Code
# Save crew logs
crew = Crew(output_log_file = True) # Logs will be saved as logs.txt
crew = Crew(output_log_file = file_name) # Logs will be saved as file_name.txt
crew = Crew(output_log_file = file_name.txt) # Logs will be saved as file_name.txt
crew = Crew(output_log_file = file_name.json) # Logs will be saved as file_name.json
[](#memory-utilization)
Memory Utilization
----------------------------------------------
Crews can utilize memory (short-term, long-term, and entity memory) to enhance their execution and learning over time. This feature allows crews to store and recall execution memories, aiding in decision-making and task execution strategies.
[](#cache-utilization)
Cache Utilization
--------------------------------------------
Caches can be employed to store the results of tools’ execution, making the process more efficient by reducing the need to re-execute identical tasks.
[](#crew-usage-metrics)
Crew Usage Metrics
----------------------------------------------
After the crew execution, you can access the `usage_metrics` attribute to view the language model (LLM) usage metrics for all tasks executed by the crew. This provides insights into operational efficiency and areas for improvement.
Code
# Access the crew's usage metrics
crew = Crew(agents=[agent1, agent2], tasks=[task1, task2])
crew.kickoff()
print(crew.usage_metrics)
[](#crew-execution-process)
Crew Execution Process
------------------------------------------------------
* **Sequential Process**: Tasks are executed one after another, allowing for a linear flow of work.
* **Hierarchical Process**: A manager agent coordinates the crew, delegating tasks and validating outcomes before proceeding. **Note**: A `manager_llm` or `manager_agent` is required for this process and it’s essential for validating the process flow.
###
[](#kicking-off-a-crew)
Kicking Off a Crew
Once your crew is assembled, initiate the workflow with the `kickoff()` method. This starts the execution process according to the defined process flow.
Code
# Start the crew's task execution
result = my_crew.kickoff()
print(result)
###
[](#different-ways-to-kick-off-a-crew)
Different Ways to Kick Off a Crew
Once your crew is assembled, initiate the workflow with the appropriate kickoff method. CrewAI provides several methods for better control over the kickoff process: `kickoff()`, `kickoff_for_each()`, `kickoff_async()`, and `kickoff_for_each_async()`.
* `kickoff()`: Starts the execution process according to the defined process flow.
* `kickoff_for_each()`: Executes tasks sequentially for each provided input event or item in the collection.
* `kickoff_async()`: Initiates the workflow asynchronously.
* `kickoff_for_each_async()`: Executes tasks concurrently for each provided input event or item, leveraging asynchronous processing.
Code
# Start the crew's task execution
result = my_crew.kickoff()
print(result)
# Example of using kickoff_for_each
inputs_array = [{'topic': 'AI in healthcare'}, {'topic': 'AI in finance'}]
results = my_crew.kickoff_for_each(inputs=inputs_array)
for result in results:
print(result)
# Example of using kickoff_async
inputs = {'topic': 'AI in healthcare'}
async_result = my_crew.kickoff_async(inputs=inputs)
print(async_result)
# Example of using kickoff_for_each_async
inputs_array = [{'topic': 'AI in healthcare'}, {'topic': 'AI in finance'}]
async_results = my_crew.kickoff_for_each_async(inputs=inputs_array)
for async_result in async_results:
print(async_result)
These methods provide flexibility in how you manage and execute tasks within your crew, allowing for both synchronous and asynchronous workflows tailored to your needs.
###
[](#replaying-from-a-specific-task)
Replaying from a Specific Task
You can now replay from a specific task using our CLI command `replay`.
The replay feature in CrewAI allows you to replay from a specific task using the command-line interface (CLI). By running the command `crewai replay -t `, you can specify the `task_id` for the replay process.
Kickoffs will now save the latest kickoffs returned task outputs locally for you to be able to replay from.
###
[](#replaying-from-a-specific-task-using-the-cli)
Replaying from a Specific Task Using the CLI
To use the replay feature, follow these steps:
1. Open your terminal or command prompt.
2. Navigate to the directory where your CrewAI project is located.
3. Run the following command:
To view the latest kickoff task IDs, use:
crewai log-tasks-outputs
Then, to replay from a specific task, use:
crewai replay -t
These commands let you replay from your latest kickoff tasks, still retaining context from previously executed tasks.
Was this page helpful?
YesNo
[Tasks](/concepts/tasks)
[Flows](/concepts/flows)
On this page
* [What is a Crew?](#what-is-a-crew%3F)
* [Crew Attributes](#crew-attributes)
* [Creating Crews](#creating-crews)
* [YAML Configuration (Recommended)](#yaml-configuration-recommended)
* [Example Crew Class with Decorators](#example-crew-class-with-decorators)
* [Decorators overview from annotations.py](#decorators-overview-from-annotations-py)
* [Direct Code Definition (Alternative)](#direct-code-definition-alternative)
* [Crew Output](#crew-output)
* [Crew Output Attributes](#crew-output-attributes)
* [Crew Output Methods and Properties](#crew-output-methods-and-properties)
* [Accessing Crew Outputs](#accessing-crew-outputs)
* [Example](#example)
* [Accessing Crew Logs](#accessing-crew-logs)
* [Memory Utilization](#memory-utilization)
* [Cache Utilization](#cache-utilization)
* [Crew Usage Metrics](#crew-usage-metrics)
* [Crew Execution Process](#crew-execution-process)
* [Kicking Off a Crew](#kicking-off-a-crew)
* [Different Ways to Kick Off a Crew](#different-ways-to-kick-off-a-crew)
* [Replaying from a Specific Task](#replaying-from-a-specific-task)
* [Replaying from a Specific Task Using the CLI](#replaying-from-a-specific-task-using-the-cli)
---
# Tasks - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Core Concepts
Tasks
[Get Started](/introduction)
[Examples](/examples/example)
[](#overview-of-a-task)
Overview of a Task
----------------------------------------------
In the CrewAI framework, a `Task` is a specific assignment completed by an `Agent`.
Tasks provide all necessary details for execution, such as a description, the agent responsible, required tools, and more, facilitating a wide range of action complexities.
Tasks within CrewAI can be collaborative, requiring multiple agents to work together. This is managed through the task properties and orchestrated by the Crew’s process, enhancing teamwork and efficiency.
###
[](#task-execution-flow)
Task Execution Flow
Tasks can be executed in two ways:
* **Sequential**: Tasks are executed in the order they are defined
* **Hierarchical**: Tasks are assigned to agents based on their roles and expertise
The execution flow is defined when creating the crew:
Code
crew = Crew(
agents=[agent1, agent2],
tasks=[task1, task2],
process=Process.sequential # or Process.hierarchical
)
[](#task-attributes)
Task Attributes
----------------------------------------
| Attribute | Parameters | Type | Description |
| --- | --- | --- | --- |
| **Description** | `description` | `str` | A clear, concise statement of what the task entails. |
| **Expected Output** | `expected_output` | `str` | A detailed description of what the task’s completion looks like. |
| **Name** _(optional)_ | `name` | `Optional[str]` | A name identifier for the task. |
| **Agent** _(optional)_ | `agent` | `Optional[BaseAgent]` | The agent responsible for executing the task. |
| **Tools** _(optional)_ | `tools` | `List[BaseTool]` | The tools/resources the agent is limited to use for this task. |
| **Context** _(optional)_ | `context` | `Optional[List["Task"]]` | Other tasks whose outputs will be used as context for this task. |
| **Async Execution** _(optional)_ | `async_execution` | `Optional[bool]` | Whether the task should be executed asynchronously. Defaults to False. |
| **Human Input** _(optional)_ | `human_input` | `Optional[bool]` | Whether the task should have a human review the final answer of the agent. Defaults to False. |
| **Config** _(optional)_ | `config` | `Optional[Dict[str, Any]]` | Task-specific configuration parameters. |
| **Output File** _(optional)_ | `output_file` | `Optional[str]` | File path for storing the task output. |
| **Output JSON** _(optional)_ | `output_json` | `Optional[Type[BaseModel]]` | A Pydantic model to structure the JSON output. |
| **Output Pydantic** _(optional)_ | `output_pydantic` | `Optional[Type[BaseModel]]` | A Pydantic model for task output. |
| **Callback** _(optional)_ | `callback` | `Optional[Any]` | Function/object to be executed after task completion. |
[](#creating-tasks)
Creating Tasks
--------------------------------------
There are two ways to create tasks in CrewAI: using **YAML configuration (recommended)** or defining them **directly in code**.
###
[](#yaml-configuration-recommended)
YAML Configuration (Recommended)
Using YAML configuration provides a cleaner, more maintainable way to define tasks. We strongly recommend using this approach to define tasks in your CrewAI projects.
After creating your CrewAI project as outlined in the [Installation](/installation)
section, navigate to the `src/latest_ai_development/config/tasks.yaml` file and modify the template to match your specific task requirements.
Variables in your YAML files (like `{topic}`) will be replaced with values from your inputs when running the crew:
Code
crew.kickoff(inputs={'topic': 'AI Agents'})
Here’s an example of how to configure tasks using YAML:
tasks.yaml
research_task:
description: >
Conduct a thorough research about {topic}
Make sure you find any interesting and relevant information given
the current year is 2025.
expected_output: >
A list with 10 bullet points of the most relevant information about {topic}
agent: researcher
reporting_task:
description: >
Review the context you got and expand each topic into a full section for a report.
Make sure the report is detailed and contains any and all relevant information.
expected_output: >
A fully fledge reports with the mains topics, each with a full section of information.
Formatted as markdown without '```'
agent: reporting_analyst
output_file: report.md
To use this YAML configuration in your code, create a crew class that inherits from `CrewBase`:
crew.py
# src/latest_ai_development/crew.py
from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from crewai_tools import SerperDevTool
@CrewBase
class LatestAiDevelopmentCrew():
"""LatestAiDevelopment crew"""
@agent
def researcher(self) -> Agent:
return Agent(
config=self.agents_config['researcher'],
verbose=True,
tools=[SerperDevTool()]
)
@agent
def reporting_analyst(self) -> Agent:
return Agent(
config=self.agents_config['reporting_analyst'],
verbose=True
)
@task
def research_task(self) -> Task:
return Task(
config=self.tasks_config['research_task']
)
@task
def reporting_task(self) -> Task:
return Task(
config=self.tasks_config['reporting_task']
)
@crew
def crew(self) -> Crew:
return Crew(
agents=[\
self.researcher(),\
self.reporting_analyst()\
],
tasks=[\
self.research_task(),\
self.reporting_task()\
],
process=Process.sequential
)
The names you use in your YAML files (`agents.yaml` and `tasks.yaml`) should match the method names in your Python code.
###
[](#direct-code-definition-alternative)
Direct Code Definition (Alternative)
Alternatively, you can define tasks directly in your code without using YAML configuration:
task.py
from crewai import Task
research_task = Task(
description="""
Conduct a thorough research about AI Agents.
Make sure you find any interesting and relevant information given
the current year is 2025.
""",
expected_output="""
A list with 10 bullet points of the most relevant information about AI Agents
""",
agent=researcher
)
reporting_task = Task(
description="""
Review the context you got and expand each topic into a full section for a report.
Make sure the report is detailed and contains any and all relevant information.
""",
expected_output="""
A fully fledge reports with the mains topics, each with a full section of information.
Formatted as markdown without '```'
""",
agent=reporting_analyst,
output_file="report.md"
)
Directly specify an `agent` for assignment or let the `hierarchical` CrewAI’s process decide based on roles, availability, etc.
[](#task-output)
Task Output
--------------------------------
Understanding task outputs is crucial for building effective AI workflows. CrewAI provides a structured way to handle task results through the `TaskOutput` class, which supports multiple output formats and can be easily passed between tasks.
The output of a task in CrewAI framework is encapsulated within the `TaskOutput` class. This class provides a structured way to access results of a task, including various formats such as raw output, JSON, and Pydantic models.
By default, the `TaskOutput` will only include the `raw` output. A `TaskOutput` will only include the `pydantic` or `json_dict` output if the original `Task` object was configured with `output_pydantic` or `output_json`, respectively.
###
[](#task-output-attributes)
Task Output Attributes
| Attribute | Parameters | Type | Description |
| --- | --- | --- | --- |
| **Description** | `description` | `str` | Description of the task. |
| **Summary** | `summary` | `Optional[str]` | Summary of the task, auto-generated from the first 10 words of the description. |
| **Raw** | `raw` | `str` | The raw output of the task. This is the default format for the output. |
| **Pydantic** | `pydantic` | `Optional[BaseModel]` | A Pydantic model object representing the structured output of the task. |
| **JSON Dict** | `json_dict` | `Optional[Dict[str, Any]]` | A dictionary representing the JSON output of the task. |
| **Agent** | `agent` | `str` | The agent that executed the task. |
| **Output Format** | `output_format` | `OutputFormat` | The format of the task output, with options including RAW, JSON, and Pydantic. The default is RAW. |
###
[](#task-methods-and-properties)
Task Methods and Properties
| Method/Property | Description |
| --- | --- |
| **json** | Returns the JSON string representation of the task output if the output format is JSON. |
| **to\_dict** | Converts the JSON and Pydantic outputs to a dictionary. |
| **str** | Returns the string representation of the task output, prioritizing Pydantic, then JSON, then raw. |
###
[](#accessing-task-outputs)
Accessing Task Outputs
Once a task has been executed, its output can be accessed through the `output` attribute of the `Task` object. The `TaskOutput` class provides various ways to interact with and present this output.
####
[](#example)
Example
Code
# Example task
task = Task(
description='Find and summarize the latest AI news',
expected_output='A bullet list summary of the top 5 most important AI news',
agent=research_agent,
tools=[search_tool]
)
# Execute the crew
crew = Crew(
agents=[research_agent],
tasks=[task],
verbose=True
)
result = crew.kickoff()
# Accessing the task output
task_output = task.output
print(f"Task Description: {task_output.description}")
print(f"Task Summary: {task_output.summary}")
print(f"Raw Output: {task_output.raw}")
if task_output.json_dict:
print(f"JSON Output: {json.dumps(task_output.json_dict, indent=2)}")
if task_output.pydantic:
print(f"Pydantic Output: {task_output.pydantic}")
[](#task-dependencies-and-context)
Task Dependencies and Context
--------------------------------------------------------------------
Tasks can depend on the output of other tasks using the `context` attribute. For example:
Code
research_task = Task(
description="Research the latest developments in AI",
expected_output="A list of recent AI developments",
agent=researcher
)
analysis_task = Task(
description="Analyze the research findings and identify key trends",
expected_output="Analysis report of AI trends",
agent=analyst,
context=[research_task] # This task will wait for research_task to complete
)
[](#task-guardrails)
Task Guardrails
----------------------------------------
Task guardrails provide a way to validate and transform task outputs before they are passed to the next task. This feature helps ensure data quality and provides feedback to agents when their output doesn’t meet specific criteria.
###
[](#using-task-guardrails)
Using Task Guardrails
To add a guardrail to a task, provide a validation function through the `guardrail` parameter:
Code
from typing import Tuple, Union, Dict, Any
def validate_blog_content(result: str) -> Tuple[bool, Union[Dict[str, Any], str]]:
"""Validate blog content meets requirements."""
try:
# Check word count
word_count = len(result.split())
if word_count > 200:
return (False, {
"error": "Blog content exceeds 200 words",
"code": "WORD_COUNT_ERROR",
"context": {"word_count": word_count}
})
# Additional validation logic here
return (True, result.strip())
except Exception as e:
return (False, {
"error": "Unexpected error during validation",
"code": "SYSTEM_ERROR"
})
blog_task = Task(
description="Write a blog post about AI",
expected_output="A blog post under 200 words",
agent=blog_agent,
guardrail=validate_blog_content # Add the guardrail function
)
###
[](#guardrail-function-requirements)
Guardrail Function Requirements
1. **Function Signature**:
* Must accept exactly one parameter (the task output)
* Should return a tuple of `(bool, Any)`
* Type hints are recommended but optional
2. **Return Values**:
* Success: Return `(True, validated_result)`
* Failure: Return `(False, error_details)`
###
[](#error-handling-best-practices)
Error Handling Best Practices
1. **Structured Error Responses**:
Code
def validate_with_context(result: str) -> Tuple[bool, Union[Dict[str, Any], str]]:
try:
# Main validation logic
validated_data = perform_validation(result)
return (True, validated_data)
except ValidationError as e:
return (False, {
"error": str(e),
"code": "VALIDATION_ERROR",
"context": {"input": result}
})
except Exception as e:
return (False, {
"error": "Unexpected error",
"code": "SYSTEM_ERROR"
})
2. **Error Categories**:
* Use specific error codes
* Include relevant context
* Provide actionable feedback
3. **Validation Chain**:
Code
from typing import Any, Dict, List, Tuple, Union
def complex_validation(result: str) -> Tuple[bool, Union[str, Dict[str, Any]]]:
"""Chain multiple validation steps."""
# Step 1: Basic validation
if not result:
return (False, {"error": "Empty result", "code": "EMPTY_INPUT"})
# Step 2: Content validation
try:
validated = validate_content(result)
if not validated:
return (False, {"error": "Invalid content", "code": "CONTENT_ERROR"})
# Step 3: Format validation
formatted = format_output(validated)
return (True, formatted)
except Exception as e:
return (False, {
"error": str(e),
"code": "VALIDATION_ERROR",
"context": {"step": "content_validation"}
})
###
[](#handling-guardrail-results)
Handling Guardrail Results
When a guardrail returns `(False, error)`:
1. The error is sent back to the agent
2. The agent attempts to fix the issue
3. The process repeats until:
* The guardrail returns `(True, result)`
* Maximum retries are reached
Example with retry handling:
Code
from typing import Optional, Tuple, Union
def validate_json_output(result: str) -> Tuple[bool, Union[Dict[str, Any], str]]:
"""Validate and parse JSON output."""
try:
# Try to parse as JSON
data = json.loads(result)
return (True, data)
except json.JSONDecodeError as e:
return (False, {
"error": "Invalid JSON format",
"code": "JSON_ERROR",
"context": {"line": e.lineno, "column": e.colno}
})
task = Task(
description="Generate a JSON report",
expected_output="A valid JSON object",
agent=analyst,
guardrail=validate_json_output,
max_retries=3 # Limit retry attempts
)
[](#getting-structured-consistent-outputs-from-tasks)
Getting Structured Consistent Outputs from Tasks
----------------------------------------------------------------------------------------------------------
It’s also important to note that the output of the final task of a crew becomes the final output of the actual crew itself.
###
[](#using-output-pydantic)
Using `output_pydantic`
The `output_pydantic` property allows you to define a Pydantic model that the task output should conform to. This ensures that the output is not only structured but also validated according to the Pydantic model.
Here’s an example demonstrating how to use output\_pydantic:
Code
import json
from crewai import Agent, Crew, Process, Task
from pydantic import BaseModel
class Blog(BaseModel):
title: str
content: str
blog_agent = Agent(
role="Blog Content Generator Agent",
goal="Generate a blog title and content",
backstory="""You are an expert content creator, skilled in crafting engaging and informative blog posts.""",
verbose=False,
allow_delegation=False,
llm="gpt-4o",
)
task1 = Task(
description="""Create a blog title and content on a given topic. Make sure the content is under 200 words.""",
expected_output="A compelling blog title and well-written content.",
agent=blog_agent,
output_pydantic=Blog,
)
# Instantiate your crew with a sequential process
crew = Crew(
agents=[blog_agent],
tasks=[task1],
verbose=True,
process=Process.sequential,
)
result = crew.kickoff()
# Option 1: Accessing Properties Using Dictionary-Style Indexing
print("Accessing Properties - Option 1")
title = result["title"]
content = result["content"]
print("Title:", title)
print("Content:", content)
# Option 2: Accessing Properties Directly from the Pydantic Model
print("Accessing Properties - Option 2")
title = result.pydantic.title
content = result.pydantic.content
print("Title:", title)
print("Content:", content)
# Option 3: Accessing Properties Using the to_dict() Method
print("Accessing Properties - Option 3")
output_dict = result.to_dict()
title = output_dict["title"]
content = output_dict["content"]
print("Title:", title)
print("Content:", content)
# Option 4: Printing the Entire Blog Object
print("Accessing Properties - Option 5")
print("Blog:", result)
In this example:
* A Pydantic model Blog is defined with title and content fields.
* The task task1 uses the output\_pydantic property to specify that its output should conform to the Blog model.
* After executing the crew, you can access the structured output in multiple ways as shown.
####
[](#explanation-of-accessing-the-output)
Explanation of Accessing the Output
1. Dictionary-Style Indexing: You can directly access the fields using result\[“field\_name”\]. This works because the CrewOutput class implements the **getitem** method.
2. Directly from Pydantic Model: Access the attributes directly from the result.pydantic object.
3. Using to\_dict() Method: Convert the output to a dictionary and access the fields.
4. Printing the Entire Object: Simply print the result object to see the structured output.
###
[](#using-output-json)
Using `output_json`
The `output_json` property allows you to define the expected output in JSON format. This ensures that the task’s output is a valid JSON structure that can be easily parsed and used in your application.
Here’s an example demonstrating how to use `output_json`:
Code
import json
from crewai import Agent, Crew, Process, Task
from pydantic import BaseModel
# Define the Pydantic model for the blog
class Blog(BaseModel):
title: str
content: str
# Define the agent
blog_agent = Agent(
role="Blog Content Generator Agent",
goal="Generate a blog title and content",
backstory="""You are an expert content creator, skilled in crafting engaging and informative blog posts.""",
verbose=False,
allow_delegation=False,
llm="gpt-4o",
)
# Define the task with output_json set to the Blog model
task1 = Task(
description="""Create a blog title and content on a given topic. Make sure the content is under 200 words.""",
expected_output="A JSON object with 'title' and 'content' fields.",
agent=blog_agent,
output_json=Blog,
)
# Instantiate the crew with a sequential process
crew = Crew(
agents=[blog_agent],
tasks=[task1],
verbose=True,
process=Process.sequential,
)
# Kickoff the crew to execute the task
result = crew.kickoff()
# Option 1: Accessing Properties Using Dictionary-Style Indexing
print("Accessing Properties - Option 1")
title = result["title"]
content = result["content"]
print("Title:", title)
print("Content:", content)
# Option 2: Printing the Entire Blog Object
print("Accessing Properties - Option 2")
print("Blog:", result)
In this example:
* A Pydantic model Blog is defined with title and content fields, which is used to specify the structure of the JSON output.
* The task task1 uses the output\_json property to indicate that it expects a JSON output conforming to the Blog model.
* After executing the crew, you can access the structured JSON output in two ways as shown.
####
[](#explanation-of-accessing-the-output-2)
Explanation of Accessing the Output
1. Accessing Properties Using Dictionary-Style Indexing: You can access the fields directly using result\[“field\_name”\]. This is possible because the CrewOutput class implements the **getitem** method, allowing you to treat the output like a dictionary. In this option, we’re retrieving the title and content from the result.
2. Printing the Entire Blog Object: By printing result, you get the string representation of the CrewOutput object. Since the **str** method is implemented to return the JSON output, this will display the entire output as a formatted string representing the Blog object.
* * *
By using output\_pydantic or output\_json, you ensure that your tasks produce outputs in a consistent and structured format, making it easier to process and utilize the data within your application or across multiple tasks.
[](#integrating-tools-with-tasks)
Integrating Tools with Tasks
------------------------------------------------------------------
Leverage tools from the [CrewAI Toolkit](https://github.com/joaomdmoura/crewai-tools)
and [LangChain Tools](https://python.langchain.com/docs/integrations/tools)
for enhanced task performance and agent interaction.
[](#creating-a-task-with-tools)
Creating a Task with Tools
--------------------------------------------------------------
Code
import os
os.environ["OPENAI_API_KEY"] = "Your Key"
os.environ["SERPER_API_KEY"] = "Your Key" # serper.dev API key
from crewai import Agent, Task, Crew
from crewai_tools import SerperDevTool
research_agent = Agent(
role='Researcher',
goal='Find and summarize the latest AI news',
backstory="""You're a researcher at a large company.
You're responsible for analyzing data and providing insights
to the business.""",
verbose=True
)
# to perform a semantic search for a specified query from a text's content across the internet
search_tool = SerperDevTool()
task = Task(
description='Find and summarize the latest AI news',
expected_output='A bullet list summary of the top 5 most important AI news',
agent=research_agent,
tools=[search_tool]
)
crew = Crew(
agents=[research_agent],
tasks=[task],
verbose=True
)
result = crew.kickoff()
print(result)
This demonstrates how tasks with specific tools can override an agent’s default set for tailored task execution.
[](#referring-to-other-tasks)
Referring to Other Tasks
----------------------------------------------------------
In CrewAI, the output of one task is automatically relayed into the next one, but you can specifically define what tasks’ output, including multiple, should be used as context for another task.
This is useful when you have a task that depends on the output of another task that is not performed immediately after it. This is done through the `context` attribute of the task:
Code
# ...
research_ai_task = Task(
description="Research the latest developments in AI",
expected_output="A list of recent AI developments",
async_execution=True,
agent=research_agent,
tools=[search_tool]
)
research_ops_task = Task(
description="Research the latest developments in AI Ops",
expected_output="A list of recent AI Ops developments",
async_execution=True,
agent=research_agent,
tools=[search_tool]
)
write_blog_task = Task(
description="Write a full blog post about the importance of AI and its latest news",
expected_output="Full blog post that is 4 paragraphs long",
agent=writer_agent,
context=[research_ai_task, research_ops_task]
)
#...
[](#asynchronous-execution)
Asynchronous Execution
------------------------------------------------------
You can define a task to be executed asynchronously. This means that the crew will not wait for it to be completed to continue with the next task. This is useful for tasks that take a long time to be completed, or that are not crucial for the next tasks to be performed.
You can then use the `context` attribute to define in a future task that it should wait for the output of the asynchronous task to be completed.
Code
#...
list_ideas = Task(
description="List of 5 interesting ideas to explore for an article about AI.",
expected_output="Bullet point list of 5 ideas for an article.",
agent=researcher,
async_execution=True # Will be executed asynchronously
)
list_important_history = Task(
description="Research the history of AI and give me the 5 most important events.",
expected_output="Bullet point list of 5 important events.",
agent=researcher,
async_execution=True # Will be executed asynchronously
)
write_article = Task(
description="Write an article about AI, its history, and interesting ideas.",
expected_output="A 4 paragraph article about AI.",
agent=writer,
context=[list_ideas, list_important_history] # Will wait for the output of the two tasks to be completed
)
#...
[](#callback-mechanism)
Callback Mechanism
----------------------------------------------
The callback function is executed after the task is completed, allowing for actions or notifications to be triggered based on the task’s outcome.
Code
# ...
def callback_function(output: TaskOutput):
# Do something after the task is completed
# Example: Send an email to the manager
print(f"""
Task completed!
Task: {output.description}
Output: {output.raw}
""")
research_task = Task(
description='Find and summarize the latest AI news',
expected_output='A bullet list summary of the top 5 most important AI news',
agent=research_agent,
tools=[search_tool],
callback=callback_function
)
#...
[](#accessing-a-specific-task-output)
Accessing a Specific Task Output
--------------------------------------------------------------------------
Once a crew finishes running, you can access the output of a specific task by using the `output` attribute of the task object:
Code
# ...
task1 = Task(
description='Find and summarize the latest AI news',
expected_output='A bullet list summary of the top 5 most important AI news',
agent=research_agent,
tools=[search_tool]
)
#...
crew = Crew(
agents=[research_agent],
tasks=[task1, task2, task3],
verbose=True
)
result = crew.kickoff()
# Returns a TaskOutput object with the description and results of the task
print(f"""
Task completed!
Task: {task1.output.description}
Output: {task1.output.raw}
""")
[](#tool-override-mechanism)
Tool Override Mechanism
--------------------------------------------------------
Specifying tools in a task allows for dynamic adaptation of agent capabilities, emphasizing CrewAI’s flexibility.
[](#error-handling-and-validation-mechanisms)
Error Handling and Validation Mechanisms
------------------------------------------------------------------------------------------
While creating and executing tasks, certain validation mechanisms are in place to ensure the robustness and reliability of task attributes. These include but are not limited to:
* Ensuring only one output type is set per task to maintain clear output expectations.
* Preventing the manual assignment of the `id` attribute to uphold the integrity of the unique identifier system.
These validations help in maintaining the consistency and reliability of task executions within the crewAI framework.
[](#task-guardrails-2)
Task Guardrails
------------------------------------------
Task guardrails provide a powerful way to validate, transform, or filter task outputs before they are passed to the next task. Guardrails are optional functions that execute before the next task starts, allowing you to ensure that task outputs meet specific requirements or formats.
###
[](#basic-usage)
Basic Usage
Code
from typing import Tuple, Union
from crewai import Task
def validate_json_output(result: str) -> Tuple[bool, Union[dict, str]]:
"""Validate that the output is valid JSON."""
try:
json_data = json.loads(result)
return (True, json_data)
except json.JSONDecodeError:
return (False, "Output must be valid JSON")
task = Task(
description="Generate JSON data",
expected_output="Valid JSON object",
guardrail=validate_json_output
)
###
[](#how-guardrails-work)
How Guardrails Work
1. **Optional Attribute**: Guardrails are an optional attribute at the task level, allowing you to add validation only where needed.
2. **Execution Timing**: The guardrail function is executed before the next task starts, ensuring valid data flow between tasks.
3. **Return Format**: Guardrails must return a tuple of `(success, data)`:
* If `success` is `True`, `data` is the validated/transformed result
* If `success` is `False`, `data` is the error message
4. **Result Routing**:
* On success (`True`), the result is automatically passed to the next task
* On failure (`False`), the error is sent back to the agent to generate a new answer
###
[](#common-use-cases)
Common Use Cases
####
[](#data-format-validation)
Data Format Validation
Code
def validate_email_format(result: str) -> Tuple[bool, Union[str, str]]:
"""Ensure the output contains a valid email address."""
import re
email_pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$'
if re.match(email_pattern, result.strip()):
return (True, result.strip())
return (False, "Output must be a valid email address")
####
[](#content-filtering)
Content Filtering
Code
def filter_sensitive_info(result: str) -> Tuple[bool, Union[str, str]]:
"""Remove or validate sensitive information."""
sensitive_patterns = ['SSN:', 'password:', 'secret:']
for pattern in sensitive_patterns:
if pattern.lower() in result.lower():
return (False, f"Output contains sensitive information ({pattern})")
return (True, result)
####
[](#data-transformation)
Data Transformation
Code
def normalize_phone_number(result: str) -> Tuple[bool, Union[str, str]]:
"""Ensure phone numbers are in a consistent format."""
import re
digits = re.sub(r'\D', '', result)
if len(digits) == 10:
formatted = f"({digits[:3]}) {digits[3:6]}-{digits[6:]}"
return (True, formatted)
return (False, "Output must be a 10-digit phone number")
###
[](#advanced-features)
Advanced Features
####
[](#chaining-multiple-validations)
Chaining Multiple Validations
Code
def chain_validations(*validators):
"""Chain multiple validators together."""
def combined_validator(result):
for validator in validators:
success, data = validator(result)
if not success:
return (False, data)
result = data
return (True, result)
return combined_validator
# Usage
task = Task(
description="Get user contact info",
expected_output="Email and phone",
guardrail=chain_validations(
validate_email_format,
filter_sensitive_info
)
)
####
[](#custom-retry-logic)
Custom Retry Logic
Code
task = Task(
description="Generate data",
expected_output="Valid data",
guardrail=validate_data,
max_retries=5 # Override default retry limit
)
[](#creating-directories-when-saving-files)
Creating Directories when Saving Files
--------------------------------------------------------------------------------------
You can now specify if a task should create directories when saving its output to a file. This is particularly useful for organizing outputs and ensuring that file paths are correctly structured.
Code
# ...
save_output_task = Task(
description='Save the summarized AI news to a file',
expected_output='File saved successfully',
agent=research_agent,
tools=[file_save_tool],
output_file='outputs/ai_news_summary.txt',
create_directory=True
)
#...
[](#conclusion)
Conclusion
------------------------------
Tasks are the driving force behind the actions of agents in CrewAI. By properly defining tasks and their outcomes, you set the stage for your AI agents to work effectively, either independently or as a collaborative unit. Equipping tasks with appropriate tools, understanding the execution process, and following robust validation practices are crucial for maximizing CrewAI’s potential, ensuring agents are effectively prepared for their assignments and that tasks are executed as intended.
Was this page helpful?
YesNo
[Agents](/concepts/agents)
[Crews](/concepts/crews)
On this page
* [Overview of a Task](#overview-of-a-task)
* [Task Execution Flow](#task-execution-flow)
* [Task Attributes](#task-attributes)
* [Creating Tasks](#creating-tasks)
* [YAML Configuration (Recommended)](#yaml-configuration-recommended)
* [Direct Code Definition (Alternative)](#direct-code-definition-alternative)
* [Task Output](#task-output)
* [Task Output Attributes](#task-output-attributes)
* [Task Methods and Properties](#task-methods-and-properties)
* [Accessing Task Outputs](#accessing-task-outputs)
* [Example](#example)
* [Task Dependencies and Context](#task-dependencies-and-context)
* [Task Guardrails](#task-guardrails)
* [Using Task Guardrails](#using-task-guardrails)
* [Guardrail Function Requirements](#guardrail-function-requirements)
* [Error Handling Best Practices](#error-handling-best-practices)
* [Handling Guardrail Results](#handling-guardrail-results)
* [Getting Structured Consistent Outputs from Tasks](#getting-structured-consistent-outputs-from-tasks)
* [Using output\_pydantic](#using-output-pydantic)
* [Explanation of Accessing the Output](#explanation-of-accessing-the-output)
* [Using output\_json](#using-output-json)
* [Explanation of Accessing the Output](#explanation-of-accessing-the-output-2)
* [Integrating Tools with Tasks](#integrating-tools-with-tasks)
* [Creating a Task with Tools](#creating-a-task-with-tools)
* [Referring to Other Tasks](#referring-to-other-tasks)
* [Asynchronous Execution](#asynchronous-execution)
* [Callback Mechanism](#callback-mechanism)
* [Accessing a Specific Task Output](#accessing-a-specific-task-output)
* [Tool Override Mechanism](#tool-override-mechanism)
* [Error Handling and Validation Mechanisms](#error-handling-and-validation-mechanisms)
* [Task Guardrails](#task-guardrails-2)
* [Basic Usage](#basic-usage)
* [How Guardrails Work](#how-guardrails-work)
* [Common Use Cases](#common-use-cases)
* [Data Format Validation](#data-format-validation)
* [Content Filtering](#content-filtering)
* [Data Transformation](#data-transformation)
* [Advanced Features](#advanced-features)
* [Chaining Multiple Validations](#chaining-multiple-validations)
* [Custom Retry Logic](#custom-retry-logic)
* [Creating Directories when Saving Files](#creating-directories-when-saving-files)
* [Conclusion](#conclusion)
---
# Flows - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Core Concepts
Flows
[Get Started](/introduction)
[Examples](/examples/example)
[](#introduction)
Introduction
----------------------------------
CrewAI Flows is a powerful feature designed to streamline the creation and management of AI workflows. Flows allow developers to combine and coordinate coding tasks and Crews efficiently, providing a robust framework for building sophisticated AI automations.
Flows allow you to create structured, event-driven workflows. They provide a seamless way to connect multiple tasks, manage state, and control the flow of execution in your AI applications. With Flows, you can easily design and implement multi-step processes that leverage the full potential of CrewAI’s capabilities.
1. **Simplified Workflow Creation**: Easily chain together multiple Crews and tasks to create complex AI workflows.
2. **State Management**: Flows make it super easy to manage and share state between different tasks in your workflow.
3. **Event-Driven Architecture**: Built on an event-driven model, allowing for dynamic and responsive workflows.
4. **Flexible Control Flow**: Implement conditional logic, loops, and branching within your workflows.
[](#getting-started)
Getting Started
----------------------------------------
Let’s create a simple Flow where you will use OpenAI to generate a random city in one task and then use that city to generate a fun fact in another task.
Code
from crewai.flow.flow import Flow, listen, start
from dotenv import load_dotenv
from litellm import completion
class ExampleFlow(Flow):
model = "gpt-4o-mini"
@start()
def generate_city(self):
print("Starting flow")
# Each flow state automatically gets a unique ID
print(f"Flow State ID: {self.state['id']}")
response = completion(
model=self.model,
messages=[\
{\
"role": "user",\
"content": "Return the name of a random city in the world.",\
},\
],
)
random_city = response["choices"][0]["message"]["content"]
# Store the city in our state
self.state["city"] = random_city
print(f"Random City: {random_city}")
return random_city
@listen(generate_city)
def generate_fun_fact(self, random_city):
response = completion(
model=self.model,
messages=[\
{\
"role": "user",\
"content": f"Tell me a fun fact about {random_city}",\
},\
],
)
fun_fact = response["choices"][0]["message"]["content"]
# Store the fun fact in our state
self.state["fun_fact"] = fun_fact
return fun_fact
flow = ExampleFlow()
result = flow.kickoff()
print(f"Generated fun fact: {result}")
In the above example, we have created a simple Flow that generates a random city using OpenAI and then generates a fun fact about that city. The Flow consists of two tasks: `generate_city` and `generate_fun_fact`. The `generate_city` task is the starting point of the Flow, and the `generate_fun_fact` task listens for the output of the `generate_city` task.
Each Flow instance automatically receives a unique identifier (UUID) in its state, which helps track and manage flow executions. The state can also store additional data (like the generated city and fun fact) that persists throughout the flow’s execution.
When you run the Flow, it will:
1. Generate a unique ID for the flow state
2. Generate a random city and store it in the state
3. Generate a fun fact about that city and store it in the state
4. Print the results to the console
The state’s unique ID and stored data can be useful for tracking flow executions and maintaining context between tasks.
**Note:** Ensure you have set up your `.env` file to store your `OPENAI_API_KEY`. This key is necessary for authenticating requests to the OpenAI API.
###
[](#%40start)
@start()
The `@start()` decorator is used to mark a method as the starting point of a Flow. When a Flow is started, all the methods decorated with `@start()` are executed in parallel. You can have multiple start methods in a Flow, and they will all be executed when the Flow is started.
###
[](#%40listen)
@listen()
The `@listen()` decorator is used to mark a method as a listener for the output of another task in the Flow. The method decorated with `@listen()` will be executed when the specified task emits an output. The method can access the output of the task it is listening to as an argument.
####
[](#usage)
Usage
The `@listen()` decorator can be used in several ways:
1. **Listening to a Method by Name**: You can pass the name of the method you want to listen to as a string. When that method completes, the listener method will be triggered.
Code
@listen("generate_city")
def generate_fun_fact(self, random_city):
# Implementation
2. **Listening to a Method Directly**: You can pass the method itself. When that method completes, the listener method will be triggered.
Code
@listen(generate_city)
def generate_fun_fact(self, random_city):
# Implementation
###
[](#flow-output)
Flow Output
Accessing and handling the output of a Flow is essential for integrating your AI workflows into larger applications or systems. CrewAI Flows provide straightforward mechanisms to retrieve the final output, access intermediate results, and manage the overall state of your Flow.
####
[](#retrieving-the-final-output)
Retrieving the Final Output
When you run a Flow, the final output is determined by the last method that completes. The `kickoff()` method returns the output of this final method.
Here’s how you can access the final output:
Code
Output
from crewai.flow.flow import Flow, listen, start
class OutputExampleFlow(Flow):
@start()
def first_method(self):
return "Output from first_method"
@listen(first_method)
def second_method(self, first_output):
return f"Second method received: {first_output}"
flow = OutputExampleFlow()
final_output = flow.kickoff()
print("---- Final Output ----")
print(final_output)
In this example, the `second_method` is the last method to complete, so its output will be the final output of the Flow. The `kickoff()` method will return the final output, which is then printed to the console.
####
[](#accessing-and-updating-state)
Accessing and Updating State
In addition to retrieving the final output, you can also access and update the state within your Flow. The state can be used to store and share data between different methods in the Flow. After the Flow has run, you can access the state to retrieve any information that was added or updated during the execution.
Here’s an example of how to update and access the state:
Code
Output
from crewai.flow.flow import Flow, listen, start
from pydantic import BaseModel
class ExampleState(BaseModel):
counter: int = 0
message: str = ""
class StateExampleFlow(Flow[ExampleState]):
@start()
def first_method(self):
self.state.message = "Hello from first_method"
self.state.counter += 1
@listen(first_method)
def second_method(self):
self.state.message += " - updated by second_method"
self.state.counter += 1
return self.state.message
flow = StateExampleFlow()
final_output = flow.kickoff()
print(f"Final Output: {final_output}")
print("Final State:")
print(flow.state)
In this example, the state is updated by both `first_method` and `second_method`. After the Flow has run, you can access the final state to see the updates made by these methods.
By ensuring that the final method’s output is returned and providing access to the state, CrewAI Flows make it easy to integrate the results of your AI workflows into larger applications or systems, while also maintaining and accessing the state throughout the Flow’s execution.
[](#flow-state-management)
Flow State Management
----------------------------------------------------
Managing state effectively is crucial for building reliable and maintainable AI workflows. CrewAI Flows provides robust mechanisms for both unstructured and structured state management, allowing developers to choose the approach that best fits their application’s needs.
###
[](#unstructured-state-management)
Unstructured State Management
In unstructured state management, all state is stored in the `state` attribute of the `Flow` class. This approach offers flexibility, enabling developers to add or modify state attributes on the fly without defining a strict schema. Even with unstructured states, CrewAI Flows automatically generates and maintains a unique identifier (UUID) for each state instance.
Code
from crewai.flow.flow import Flow, listen, start
class UnstructuredExampleFlow(Flow):
@start()
def first_method(self):
# The state automatically includes an 'id' field
print(f"State ID: {self.state['id']}")
self.state['counter'] = 0
self.state['message'] = "Hello from structured flow"
@listen(first_method)
def second_method(self):
self.state['counter'] += 1
self.state['message'] += " - updated"
@listen(second_method)
def third_method(self):
self.state['counter'] += 1
self.state['message'] += " - updated again"
print(f"State after third_method: {self.state}")
flow = UnstructuredExampleFlow()
flow.kickoff()
**Note:** The `id` field is automatically generated and preserved throughout the flow’s execution. You don’t need to manage or set it manually, and it will be maintained even when updating the state with new data.
**Key Points:**
* **Flexibility:** You can dynamically add attributes to `self.state` without predefined constraints.
* **Simplicity:** Ideal for straightforward workflows where state structure is minimal or varies significantly.
###
[](#structured-state-management)
Structured State Management
Structured state management leverages predefined schemas to ensure consistency and type safety across the workflow. By using models like Pydantic’s `BaseModel`, developers can define the exact shape of the state, enabling better validation and auto-completion in development environments.
Each state in CrewAI Flows automatically receives a unique identifier (UUID) to help track and manage state instances. This ID is automatically generated and managed by the Flow system.
Code
from crewai.flow.flow import Flow, listen, start
from pydantic import BaseModel
class ExampleState(BaseModel):
# Note: 'id' field is automatically added to all states
counter: int = 0
message: str = ""
class StructuredExampleFlow(Flow[ExampleState]):
@start()
def first_method(self):
# Access the auto-generated ID if needed
print(f"State ID: {self.state.id}")
self.state.message = "Hello from structured flow"
@listen(first_method)
def second_method(self):
self.state.counter += 1
self.state.message += " - updated"
@listen(second_method)
def third_method(self):
self.state.counter += 1
self.state.message += " - updated again"
print(f"State after third_method: {self.state}")
flow = StructuredExampleFlow()
flow.kickoff()
**Key Points:**
* **Defined Schema:** `ExampleState` clearly outlines the state structure, enhancing code readability and maintainability.
* **Type Safety:** Leveraging Pydantic ensures that state attributes adhere to the specified types, reducing runtime errors.
* **Auto-Completion:** IDEs can provide better auto-completion and error checking based on the defined state model.
###
[](#choosing-between-unstructured-and-structured-state-management)
Choosing Between Unstructured and Structured State Management
* **Use Unstructured State Management when:**
* The workflow’s state is simple or highly dynamic.
* Flexibility is prioritized over strict state definitions.
* Rapid prototyping is required without the overhead of defining schemas.
* **Use Structured State Management when:**
* The workflow requires a well-defined and consistent state structure.
* Type safety and validation are important for your application’s reliability.
* You want to leverage IDE features like auto-completion and type checking for better developer experience.
By providing both unstructured and structured state management options, CrewAI Flows empowers developers to build AI workflows that are both flexible and robust, catering to a wide range of application requirements.
[](#flow-persistence)
Flow Persistence
------------------------------------------
The @persist decorator enables automatic state persistence in CrewAI Flows, allowing you to maintain flow state across restarts or different workflow executions. This decorator can be applied at either the class level or method level, providing flexibility in how you manage state persistence.
###
[](#class-level-persistence)
Class-Level Persistence
When applied at the class level, the @persist decorator automatically persists all flow method states:
@persist # Using SQLiteFlowPersistence by default
class MyFlow(Flow[MyState]):
@start()
def initialize_flow(self):
# This method will automatically have its state persisted
self.state.counter = 1
print("Initialized flow. State ID:", self.state.id)
@listen(initialize_flow)
def next_step(self):
# The state (including self.state.id) is automatically reloaded
self.state.counter += 1
print("Flow state is persisted. Counter:", self.state.counter)
###
[](#method-level-persistence)
Method-Level Persistence
For more granular control, you can apply @persist to specific methods:
class AnotherFlow(Flow[dict]):
@persist # Persists only this method's state
@start()
def begin(self):
if "runs" not in self.state:
self.state["runs"] = 0
self.state["runs"] += 1
print("Method-level persisted runs:", self.state["runs"])
###
[](#how-it-works)
How It Works
1. **Unique State Identification**
* Each flow state automatically receives a unique UUID
* The ID is preserved across state updates and method calls
* Supports both structured (Pydantic BaseModel) and unstructured (dictionary) states
2. **Default SQLite Backend**
* SQLiteFlowPersistence is the default storage backend
* States are automatically saved to a local SQLite database
* Robust error handling ensures clear messages if database operations fail
3. **Error Handling**
* Comprehensive error messages for database operations
* Automatic state validation during save and load
* Clear feedback when persistence operations encounter issues
###
[](#important-considerations)
Important Considerations
* **State Types**: Both structured (Pydantic BaseModel) and unstructured (dictionary) states are supported
* **Automatic ID**: The `id` field is automatically added if not present
* **State Recovery**: Failed or restarted flows can automatically reload their previous state
* **Custom Implementation**: You can provide your own FlowPersistence implementation for specialized storage needs
###
[](#technical-advantages)
Technical Advantages
1. **Precise Control Through Low-Level Access**
* Direct access to persistence operations for advanced use cases
* Fine-grained control via method-level persistence decorators
* Built-in state inspection and debugging capabilities
* Full visibility into state changes and persistence operations
2. **Enhanced Reliability**
* Automatic state recovery after system failures or restarts
* Transaction-based state updates for data integrity
* Comprehensive error handling with clear error messages
* Robust validation during state save and load operations
3. **Extensible Architecture**
* Customizable persistence backend through FlowPersistence interface
* Support for specialized storage solutions beyond SQLite
* Compatible with both structured (Pydantic) and unstructured (dict) states
* Seamless integration with existing CrewAI flow patterns
The persistence system’s architecture emphasizes technical precision and customization options, allowing developers to maintain full control over state management while benefiting from built-in reliability features.
[](#flow-control)
Flow Control
----------------------------------
###
[](#conditional-logic%3A-or)
Conditional Logic: `or`
The `or_` function in Flows allows you to listen to multiple methods and trigger the listener method when any of the specified methods emit an output.
Code
Output
from crewai.flow.flow import Flow, listen, or_, start
class OrExampleFlow(Flow):
@start()
def start_method(self):
return "Hello from the start method"
@listen(start_method)
def second_method(self):
return "Hello from the second method"
@listen(or_(start_method, second_method))
def logger(self, result):
print(f"Logger: {result}")
flow = OrExampleFlow()
flow.kickoff()
When you run this Flow, the `logger` method will be triggered by the output of either the `start_method` or the `second_method`. The `or_` function is used to listen to multiple methods and trigger the listener method when any of the specified methods emit an output.
###
[](#conditional-logic%3A-and)
Conditional Logic: `and`
The `and_` function in Flows allows you to listen to multiple methods and trigger the listener method only when all the specified methods emit an output.
Code
Output
from crewai.flow.flow import Flow, and_, listen, start
class AndExampleFlow(Flow):
@start()
def start_method(self):
self.state["greeting"] = "Hello from the start method"
@listen(start_method)
def second_method(self):
self.state["joke"] = "What do computers eat? Microchips."
@listen(and_(start_method, second_method))
def logger(self):
print("---- Logger ----")
print(self.state)
flow = AndExampleFlow()
flow.kickoff()
When you run this Flow, the `logger` method will be triggered only when both the `start_method` and the `second_method` emit an output. The `and_` function is used to listen to multiple methods and trigger the listener method only when all the specified methods emit an output.
###
[](#router)
Router
The `@router()` decorator in Flows allows you to define conditional routing logic based on the output of a method. You can specify different routes based on the output of the method, allowing you to control the flow of execution dynamically.
Code
Output
import random
from crewai.flow.flow import Flow, listen, router, start
from pydantic import BaseModel
class ExampleState(BaseModel):
success_flag: bool = False
class RouterFlow(Flow[ExampleState]):
@start()
def start_method(self):
print("Starting the structured flow")
random_boolean = random.choice([True, False])
self.state.success_flag = random_boolean
@router(start_method)
def second_method(self):
if self.state.success_flag:
return "success"
else:
return "failed"
@listen("success")
def third_method(self):
print("Third method running")
@listen("failed")
def fourth_method(self):
print("Fourth method running")
flow = RouterFlow()
flow.kickoff()
In the above example, the `start_method` generates a random boolean value and sets it in the state. The `second_method` uses the `@router()` decorator to define conditional routing logic based on the value of the boolean. If the boolean is `True`, the method returns `"success"`, and if it is `False`, the method returns `"failed"`. The `third_method` and `fourth_method` listen to the output of the `second_method` and execute based on the returned value.
When you run this Flow, the output will change based on the random boolean value generated by the `start_method`.
[](#adding-crews-to-flows)
Adding Crews to Flows
----------------------------------------------------
Creating a flow with multiple crews in CrewAI is straightforward.
You can generate a new CrewAI project that includes all the scaffolding needed to create a flow with multiple crews by running the following command:
crewai create flow name_of_flow
This command will generate a new CrewAI project with the necessary folder structure. The generated project includes a prebuilt crew called `poem_crew` that is already working. You can use this crew as a template by copying, pasting, and editing it to create other crews.
###
[](#folder-structure)
Folder Structure
After running the `crewai create flow name_of_flow` command, you will see a folder structure similar to the following:
| Directory/File | Description |
| --- | --- |
| `name_of_flow/` | Root directory for the flow. |
| ├── `crews/` | Contains directories for specific crews. |
| │ └── `poem_crew/` | Directory for the “poem\_crew” with its configurations and scripts. |
| │ ├── `config/` | Configuration files directory for the “poem\_crew”. |
| │ │ ├── `agents.yaml` | YAML file defining the agents for “poem\_crew”. |
| │ │ └── `tasks.yaml` | YAML file defining the tasks for “poem\_crew”. |
| │ ├── `poem_crew.py` | Script for “poem\_crew” functionality. |
| ├── `tools/` | Directory for additional tools used in the flow. |
| │ └── `custom_tool.py` | Custom tool implementation. |
| ├── `main.py` | Main script for running the flow. |
| ├── `README.md` | Project description and instructions. |
| ├── `pyproject.toml` | Configuration file for project dependencies and settings. |
| └── `.gitignore` | Specifies files and directories to ignore in version control. |
###
[](#building-your-crews)
Building Your Crews
In the `crews` folder, you can define multiple crews. Each crew will have its own folder containing configuration files and the crew definition file. For example, the `poem_crew` folder contains:
* `config/agents.yaml`: Defines the agents for the crew.
* `config/tasks.yaml`: Defines the tasks for the crew.
* `poem_crew.py`: Contains the crew definition, including agents, tasks, and the crew itself.
You can copy, paste, and edit the `poem_crew` to create other crews.
###
[](#connecting-crews-in-main-py)
Connecting Crews in `main.py`
The `main.py` file is where you create your flow and connect the crews together. You can define your flow by using the `Flow` class and the decorators `@start` and `@listen` to specify the flow of execution.
Here’s an example of how you can connect the `poem_crew` in the `main.py` file:
Code
#!/usr/bin/env python
from random import randint
from pydantic import BaseModel
from crewai.flow.flow import Flow, listen, start
from .crews.poem_crew.poem_crew import PoemCrew
class PoemState(BaseModel):
sentence_count: int = 1
poem: str = ""
class PoemFlow(Flow[PoemState]):
@start()
def generate_sentence_count(self):
print("Generating sentence count")
self.state.sentence_count = randint(1, 5)
@listen(generate_sentence_count)
def generate_poem(self):
print("Generating poem")
result = PoemCrew().crew().kickoff(inputs={"sentence_count": self.state.sentence_count})
print("Poem generated", result.raw)
self.state.poem = result.raw
@listen(generate_poem)
def save_poem(self):
print("Saving poem")
with open("poem.txt", "w") as f:
f.write(self.state.poem)
def kickoff():
poem_flow = PoemFlow()
poem_flow.kickoff()
def plot():
poem_flow = PoemFlow()
poem_flow.plot()
if __name__ == "__main__":
kickoff()
In this example, the `PoemFlow` class defines a flow that generates a sentence count, uses the `PoemCrew` to generate a poem, and then saves the poem to a file. The flow is kicked off by calling the `kickoff()` method.
###
[](#running-the-flow)
Running the Flow
(Optional) Before running the flow, you can install the dependencies by running:
crewai install
Once all of the dependencies are installed, you need to activate the virtual environment by running:
source .venv/bin/activate
After activating the virtual environment, you can run the flow by executing one of the following commands:
crewai flow kickoff
or
uv run kickoff
The flow will execute, and you should see the output in the console.
[](#plot-flows)
Plot Flows
------------------------------
Visualizing your AI workflows can provide valuable insights into the structure and execution paths of your flows. CrewAI offers a powerful visualization tool that allows you to generate interactive plots of your flows, making it easier to understand and optimize your AI workflows.
###
[](#what-are-plots%3F)
What are Plots?
Plots in CrewAI are graphical representations of your AI workflows. They display the various tasks, their connections, and the flow of data between them. This visualization helps in understanding the sequence of operations, identifying bottlenecks, and ensuring that the workflow logic aligns with your expectations.
###
[](#how-to-generate-a-plot)
How to Generate a Plot
CrewAI provides two convenient methods to generate plots of your flows:
####
[](#option-1%3A-using-the-plot-method)
Option 1: Using the `plot()` Method
If you are working directly with a flow instance, you can generate a plot by calling the `plot()` method on your flow object. This method will create an HTML file containing the interactive plot of your flow.
Code
# Assuming you have a flow instance
flow.plot("my_flow_plot")
This will generate a file named `my_flow_plot.html` in your current directory. You can open this file in a web browser to view the interactive plot.
####
[](#option-2%3A-using-the-command-line)
Option 2: Using the Command Line
If you are working within a structured CrewAI project, you can generate a plot using the command line. This is particularly useful for larger projects where you want to visualize the entire flow setup.
crewai flow plot
This command will generate an HTML file with the plot of your flow, similar to the `plot()` method. The file will be saved in your project directory, and you can open it in a web browser to explore the flow.
###
[](#understanding-the-plot)
Understanding the Plot
The generated plot will display nodes representing the tasks in your flow, with directed edges indicating the flow of execution. The plot is interactive, allowing you to zoom in and out, and hover over nodes to see additional details.
By visualizing your flows, you can gain a clearer understanding of the workflow’s structure, making it easier to debug, optimize, and communicate your AI processes to others.
###
[](#conclusion)
Conclusion
Plotting your flows is a powerful feature of CrewAI that enhances your ability to design and manage complex AI workflows. Whether you choose to use the `plot()` method or the command line, generating plots will provide you with a visual representation of your workflows, aiding in both development and presentation.
[](#next-steps)
Next Steps
------------------------------
If you’re interested in exploring additional examples of flows, we have a variety of recommendations in our examples repository. Here are four specific flow examples, each showcasing unique use cases to help you match your current problem type to a specific example:
1. **Email Auto Responder Flow**: This example demonstrates an infinite loop where a background job continually runs to automate email responses. It’s a great use case for tasks that need to be performed repeatedly without manual intervention. [View Example](https://github.com/crewAIInc/crewAI-examples/tree/main/email_auto_responder_flow)
2. **Lead Score Flow**: This flow showcases adding human-in-the-loop feedback and handling different conditional branches using the router. It’s an excellent example of how to incorporate dynamic decision-making and human oversight into your workflows. [View Example](https://github.com/crewAIInc/crewAI-examples/tree/main/lead-score-flow)
3. **Write a Book Flow**: This example excels at chaining multiple crews together, where the output of one crew is used by another. Specifically, one crew outlines an entire book, and another crew generates chapters based on the outline. Eventually, everything is connected to produce a complete book. This flow is perfect for complex, multi-step processes that require coordination between different tasks. [View Example](https://github.com/crewAIInc/crewAI-examples/tree/main/write_a_book_with_flows)
4. **Meeting Assistant Flow**: This flow demonstrates how to broadcast one event to trigger multiple follow-up actions. For instance, after a meeting is completed, the flow can update a Trello board, send a Slack message, and save the results. It’s a great example of handling multiple outcomes from a single event, making it ideal for comprehensive task management and notification systems. [View Example](https://github.com/crewAIInc/crewAI-examples/tree/main/meeting_assistant_flow)
By exploring these examples, you can gain insights into how to leverage CrewAI Flows for various use cases, from automating repetitive tasks to managing complex, multi-step processes with dynamic decision-making and human feedback.
Also, check out our YouTube video on how to use flows in CrewAI below!
Was this page helpful?
YesNo
[Crews](/concepts/crews)
[Knowledge](/concepts/knowledge)
On this page
* [Introduction](#introduction)
* [Getting Started](#getting-started)
* [@start()](#%40start)
* [@listen()](#%40listen)
* [Usage](#usage)
* [Flow Output](#flow-output)
* [Retrieving the Final Output](#retrieving-the-final-output)
* [Accessing and Updating State](#accessing-and-updating-state)
* [Flow State Management](#flow-state-management)
* [Unstructured State Management](#unstructured-state-management)
* [Structured State Management](#structured-state-management)
* [Choosing Between Unstructured and Structured State Management](#choosing-between-unstructured-and-structured-state-management)
* [Flow Persistence](#flow-persistence)
* [Class-Level Persistence](#class-level-persistence)
* [Method-Level Persistence](#method-level-persistence)
* [How It Works](#how-it-works)
* [Important Considerations](#important-considerations)
* [Technical Advantages](#technical-advantages)
* [Flow Control](#flow-control)
* [Conditional Logic: or](#conditional-logic%3A-or)
* [Conditional Logic: and](#conditional-logic%3A-and)
* [Router](#router)
* [Adding Crews to Flows](#adding-crews-to-flows)
* [Folder Structure](#folder-structure)
* [Building Your Crews](#building-your-crews)
* [Connecting Crews in main.py](#connecting-crews-in-main-py)
* [Running the Flow](#running-the-flow)
* [Plot Flows](#plot-flows)
* [What are Plots?](#what-are-plots%3F)
* [How to Generate a Plot](#how-to-generate-a-plot)
* [Option 1: Using the plot() Method](#option-1%3A-using-the-plot-method)
* [Option 2: Using the Command Line](#option-2%3A-using-the-command-line)
* [Understanding the Plot](#understanding-the-plot)
* [Conclusion](#conclusion)
* [Next Steps](#next-steps)
---
# Processes - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Core Concepts
Processes
[Get Started](/introduction)
[Examples](/examples/example)
[](#understanding-processes)
Understanding Processes
--------------------------------------------------------
Processes orchestrate the execution of tasks by agents, akin to project management in human teams. These processes ensure tasks are distributed and executed efficiently, in alignment with a predefined strategy.
[](#process-implementations)
Process Implementations
--------------------------------------------------------
* **Sequential**: Executes tasks sequentially, ensuring tasks are completed in an orderly progression.
* **Hierarchical**: Organizes tasks in a managerial hierarchy, where tasks are delegated and executed based on a structured chain of command. A manager language model (`manager_llm`) or a custom manager agent (`manager_agent`) must be specified in the crew to enable the hierarchical process, facilitating the creation and management of tasks by the manager.
* **Consensual Process (Planned)**: Aiming for collaborative decision-making among agents on task execution, this process type introduces a democratic approach to task management within CrewAI. It is planned for future development and is not currently implemented in the codebase.
[](#the-role-of-processes-in-teamwork)
The Role of Processes in Teamwork
----------------------------------------------------------------------------
Processes enable individual agents to operate as a cohesive unit, streamlining their efforts to achieve common objectives with efficiency and coherence.
[](#assigning-processes-to-a-crew)
Assigning Processes to a Crew
--------------------------------------------------------------------
To assign a process to a crew, specify the process type upon crew creation to set the execution strategy. For a hierarchical process, ensure to define `manager_llm` or `manager_agent` for the manager agent.
from crewai import Crew, Process
# Example: Creating a crew with a sequential process
crew = Crew(
agents=my_agents,
tasks=my_tasks,
process=Process.sequential
)
# Example: Creating a crew with a hierarchical process
# Ensure to provide a manager_llm or manager_agent
crew = Crew(
agents=my_agents,
tasks=my_tasks,
process=Process.hierarchical,
manager_llm="gpt-4o"
# or
# manager_agent=my_manager_agent
)
**Note:** Ensure `my_agents` and `my_tasks` are defined prior to creating a `Crew` object, and for the hierarchical process, either `manager_llm` or `manager_agent` is also required.
[](#sequential-process)
Sequential Process
----------------------------------------------
This method mirrors dynamic team workflows, progressing through tasks in a thoughtful and systematic manner. Task execution follows the predefined order in the task list, with the output of one task serving as context for the next.
To customize task context, utilize the `context` parameter in the `Task` class to specify outputs that should be used as context for subsequent tasks.
[](#hierarchical-process)
Hierarchical Process
--------------------------------------------------
Emulates a corporate hierarchy, CrewAI allows specifying a custom manager agent or automatically creates one, requiring the specification of a manager language model (`manager_llm`). This agent oversees task execution, including planning, delegation, and validation. Tasks are not pre-assigned; the manager allocates tasks to agents based on their capabilities, reviews outputs, and assesses task completion.
[](#process-class%3A-detailed-overview)
Process Class: Detailed Overview
----------------------------------------------------------------------------
The `Process` class is implemented as an enumeration (`Enum`), ensuring type safety and restricting process values to the defined types (`sequential`, `hierarchical`). The consensual process is planned for future inclusion, emphasizing our commitment to continuous development and innovation.
[](#conclusion)
Conclusion
------------------------------
The structured collaboration facilitated by processes within CrewAI is crucial for enabling systematic teamwork among agents. This documentation has been updated to reflect the latest features, enhancements, and the planned integration of the Consensual Process, ensuring users have access to the most current and comprehensive information.
Was this page helpful?
YesNo
[LLMs](/concepts/llms)
[Collaboration](/concepts/collaboration)
On this page
* [Understanding Processes](#understanding-processes)
* [Process Implementations](#process-implementations)
* [The Role of Processes in Teamwork](#the-role-of-processes-in-teamwork)
* [Assigning Processes to a Crew](#assigning-processes-to-a-crew)
* [Sequential Process](#sequential-process)
* [Hierarchical Process](#hierarchical-process)
* [Process Class: Detailed Overview](#process-class%3A-detailed-overview)
* [Conclusion](#conclusion)
---
# Collaboration - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Core Concepts
Collaboration
[Get Started](/introduction)
[Examples](/examples/example)
[](#collaboration-fundamentals)
Collaboration Fundamentals
--------------------------------------------------------------
Collaboration in CrewAI is fundamental, enabling agents to combine their skills, share information, and assist each other in task execution, embodying a truly cooperative ecosystem.
* **Information Sharing**: Ensures all agents are well-informed and can contribute effectively by sharing data and findings.
* **Task Assistance**: Allows agents to seek help from peers with the required expertise for specific tasks.
* **Resource Allocation**: Optimizes task execution through the efficient distribution and sharing of resources among agents.
[](#enhanced-attributes-for-improved-collaboration)
Enhanced Attributes for Improved Collaboration
------------------------------------------------------------------------------------------------------
The `Crew` class has been enriched with several attributes to support advanced functionalities:
| Feature | Description |
| --- | --- |
| **Language Model Management** (`manager_llm`, `function_calling_llm`) | Manages language models for executing tasks and tools. `manager_llm` is required for hierarchical processes, while `function_calling_llm` is optional with a default value for streamlined interactions. |
| **Custom Manager Agent** (`manager_agent`) | Specifies a custom agent as the manager, replacing the default CrewAI manager. |
| **Process Flow** (`process`) | Defines execution logic (e.g., sequential, hierarchical) for task distribution. |
| **Verbose Logging** (`verbose`) | Provides detailed logging for monitoring and debugging. Accepts integer and boolean values to control verbosity level. |
| **Rate Limiting** (`max_rpm`) | Limits requests per minute to optimize resource usage. Setting guidelines depend on task complexity and load. |
| **Internationalization / Customization** (`language`, `prompt_file`) | Supports prompt customization for global usability. [Example of file](https://github.com/joaomdmoura/crewAI/blob/main/src/crewai/translations/en.json) |
| **Execution and Output Handling** (`full_output`) | Controls output granularity, distinguishing between full and final outputs. |
| **Callback and Telemetry** (`step_callback`, `task_callback`) | Enables step-wise and task-level execution monitoring and telemetry for performance analytics. |
| **Crew Sharing** (`share_crew`) | Allows sharing crew data with CrewAI for model improvement. Privacy implications and benefits should be considered. |
| **Usage Metrics** (`usage_metrics`) | Logs all LLM usage metrics during task execution for performance insights. |
| **Memory Usage** (`memory`) | Enables memory for storing execution history, aiding in agent learning and task efficiency. |
| **Embedder Configuration** (`embedder`) | Configures the embedder for language understanding and generation, with support for provider customization. |
| **Cache Management** (`cache`) | Specifies whether to cache tool execution results, enhancing performance. |
| **Output Logging** (`output_log_file`) | Defines the file path for logging crew execution output. |
| **Planning Mode** (`planning`) | Enables action planning before task execution. Set `planning=True` to activate. |
| **Replay Feature** (`replay`) | Provides CLI for listing tasks from the last run and replaying from specific tasks, aiding in task management and troubleshooting. |
[](#delegation-dividing-to-conquer)
Delegation (Dividing to Conquer)
------------------------------------------------------------------------
Delegation enhances functionality by allowing agents to intelligently assign tasks or seek help, thereby amplifying the crew’s overall capability.
[](#implementing-collaboration-and-delegation)
Implementing Collaboration and Delegation
--------------------------------------------------------------------------------------------
Setting up a crew involves defining the roles and capabilities of each agent. CrewAI seamlessly manages their interactions, ensuring efficient collaboration and delegation, with enhanced customization and monitoring features to adapt to various operational needs.
[](#example-scenario)
Example Scenario
------------------------------------------
Consider a crew with a researcher agent tasked with data gathering and a writer agent responsible for compiling reports. The integration of advanced language model management and process flow attributes allows for more sophisticated interactions, such as the writer delegating complex research tasks to the researcher or querying specific information, thereby facilitating a seamless workflow.
[](#conclusion)
Conclusion
------------------------------
The integration of advanced attributes and functionalities into the CrewAI framework significantly enriches the agent collaboration ecosystem. These enhancements not only simplify interactions but also offer unprecedented flexibility and control, paving the way for sophisticated AI-driven solutions capable of tackling complex tasks through intelligent collaboration and delegation.
Was this page helpful?
YesNo
[Processes](/concepts/processes)
[Training](/concepts/training)
On this page
* [Collaboration Fundamentals](#collaboration-fundamentals)
* [Enhanced Attributes for Improved Collaboration](#enhanced-attributes-for-improved-collaboration)
* [Delegation (Dividing to Conquer)](#delegation-dividing-to-conquer)
* [Implementing Collaboration and Delegation](#implementing-collaboration-and-delegation)
* [Example Scenario](#example-scenario)
* [Conclusion](#conclusion)
---
# Planning - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Core Concepts
Planning
[Get Started](/introduction)
[Examples](/examples/example)
[](#introduction)
Introduction
----------------------------------
The planning feature in CrewAI allows you to add planning capability to your crew. When enabled, before each Crew iteration, all Crew information is sent to an AgentPlanner that will plan the tasks step by step, and this plan will be added to each task description.
###
[](#using-the-planning-feature)
Using the Planning Feature
Getting started with the planning feature is very easy, the only step required is to add `planning=True` to your Crew:
Code
from crewai import Crew, Agent, Task, Process
# Assemble your crew with planning capabilities
my_crew = Crew(
agents=self.agents,
tasks=self.tasks,
process=Process.sequential,
planning=True,
)
From this point on, your crew will have planning enabled, and the tasks will be planned before each iteration.
####
[](#planning-llm)
Planning LLM
Now you can define the LLM that will be used to plan the tasks.
When running the base case example, you will see something like the output below, which represents the output of the `AgentPlanner` responsible for creating the step-by-step logic to add to the Agents’ tasks.
Code
Result
from crewai import Crew, Agent, Task, Process
# Assemble your crew with planning capabilities and custom LLM
my_crew = Crew(
agents=self.agents,
tasks=self.tasks,
process=Process.sequential,
planning=True,
planning_llm="gpt-4o"
)
# Run the crew
my_crew.kickoff()
Was this page helpful?
YesNo
[Memory](/concepts/memory)
[Testing](/concepts/testing)
On this page
* [Introduction](#introduction)
* [Using the Planning Feature](#using-the-planning-feature)
* [Planning LLM](#planning-llm)
---
# Memory - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Core Concepts
Memory
[Get Started](/introduction)
[Examples](/examples/example)
[](#introduction-to-memory-systems-in-crewai)
Introduction to Memory Systems in CrewAI
------------------------------------------------------------------------------------------
The crewAI framework introduces a sophisticated memory system designed to significantly enhance the capabilities of AI agents. This system comprises `short-term memory`, `long-term memory`, `entity memory`, and `contextual memory`, each serving a unique purpose in aiding agents to remember, reason, and learn from past interactions.
[](#memory-system-components)
Memory System Components
----------------------------------------------------------
| Component | Description |
| --- | --- |
| **Short-Term Memory** | Temporarily stores recent interactions and outcomes using `RAG`, enabling agents to recall and utilize information relevant to their current context during the current executions. |
| **Long-Term Memory** | Preserves valuable insights and learnings from past executions, allowing agents to build and refine their knowledge over time. |
| **Entity Memory** | Captures and organizes information about entities (people, places, concepts) encountered during tasks, facilitating deeper understanding and relationship mapping. Uses `RAG` for storing entity information. |
| **Contextual Memory** | Maintains the context of interactions by combining `ShortTermMemory`, `LongTermMemory`, and `EntityMemory`, aiding in the coherence and relevance of agent responses over a sequence of tasks or a conversation. |
| **User Memory** | Stores user-specific information and preferences, enhancing personalization and user experience. |
[](#how-memory-systems-empower-agents)
How Memory Systems Empower Agents
----------------------------------------------------------------------------
1. **Contextual Awareness**: With short-term and contextual memory, agents gain the ability to maintain context over a conversation or task sequence, leading to more coherent and relevant responses.
2. **Experience Accumulation**: Long-term memory allows agents to accumulate experiences, learning from past actions to improve future decision-making and problem-solving.
3. **Entity Understanding**: By maintaining entity memory, agents can recognize and remember key entities, enhancing their ability to process and interact with complex information.
[](#implementing-memory-in-your-crew)
Implementing Memory in Your Crew
--------------------------------------------------------------------------
When configuring a crew, you can enable and customize each memory component to suit the crew’s objectives and the nature of tasks it will perform. By default, the memory system is disabled, and you can ensure it is active by setting `memory=True` in the crew configuration. The memory will use OpenAI embeddings by default, but you can change it by setting `embedder` to a different model. It’s also possible to initialize the memory instance with your own instance.
The ‘embedder’ only applies to **Short-Term Memory** which uses Chroma for RAG. The **Long-Term Memory** uses SQLite3 to store task results. Currently, there is no way to override these storage implementations. The data storage files are saved into a platform-specific location found using the appdirs package, and the name of the project can be overridden using the **CREWAI\_STORAGE\_DIR** environment variable.
###
[](#example%3A-configuring-memory-for-a-crew)
Example: Configuring Memory for a Crew
Code
from crewai import Crew, Agent, Task, Process
# Assemble your crew with memory capabilities
my_crew = Crew(
agents=[...],
tasks=[...],
process=Process.sequential,
memory=True,
verbose=True
)
###
[](#example%3A-use-custom-memory-instances-e-g-faiss-as-the-vectordb)
Example: Use Custom Memory Instances e.g FAISS as the VectorDB
Code
from crewai import Crew, Process
from crewai.memory import LongTermMemory, ShortTermMemory, EntityMemory
from crewai.memory.storage import LTMSQLiteStorage, RAGStorage
from typing import List, Optional
# Assemble your crew with memory capabilities
my_crew: Crew = Crew(
agents = [...],
tasks = [...],
process = Process.sequential,
memory = True,
# Long-term memory for persistent storage across sessions
long_term_memory = LongTermMemory(
storage=LTMSQLiteStorage(
db_path="/my_crew1/long_term_memory_storage.db"
)
),
# Short-term memory for current context using RAG
short_term_memory = ShortTermMemory(
storage = RAGStorage(
embedder_config={
"provider": "openai",
"config": {
"model": 'text-embedding-3-small'
}
},
type="short_term",
path="/my_crew1/"
)
),
),
# Entity memory for tracking key information about entities
entity_memory = EntityMemory(
storage=RAGStorage(
embedder_config={
"provider": "openai",
"config": {
"model": 'text-embedding-3-small'
}
},
type="short_term",
path="/my_crew1/"
)
),
verbose=True,
)
[](#security-considerations)
Security Considerations
--------------------------------------------------------
When configuring memory storage:
* Use environment variables for storage paths (e.g., `CREWAI_STORAGE_DIR`)
* Never hardcode sensitive information like database credentials
* Consider access permissions for storage directories
* Use relative paths when possible to maintain portability
Example using environment variables:
import os
from crewai import Crew
from crewai.memory import LongTermMemory
from crewai.memory.storage import LTMSQLiteStorage
# Configure storage path using environment variable
storage_path = os.getenv("CREWAI_STORAGE_DIR", "./storage")
crew = Crew(
memory=True,
long_term_memory=LongTermMemory(
storage=LTMSQLiteStorage(
db_path="{storage_path}/memory.db".format(storage_path=storage_path)
)
)
)
[](#configuration-examples)
Configuration Examples
------------------------------------------------------
###
[](#basic-memory-configuration)
Basic Memory Configuration
from crewai import Crew
from crewai.memory import LongTermMemory
# Simple memory configuration
crew = Crew(memory=True) # Uses default storage locations
###
[](#custom-storage-configuration)
Custom Storage Configuration
from crewai import Crew
from crewai.memory import LongTermMemory
from crewai.memory.storage import LTMSQLiteStorage
# Configure custom storage paths
crew = Crew(
memory=True,
long_term_memory=LongTermMemory(
storage=LTMSQLiteStorage(db_path="./memory.db")
)
)
[](#integrating-mem0-for-enhanced-user-memory)
Integrating Mem0 for Enhanced User Memory
--------------------------------------------------------------------------------------------
[Mem0](https://mem0.ai/)
is a self-improving memory layer for LLM applications, enabling personalized AI experiences.
To include user-specific memory you can get your API key [here](https://app.mem0.ai/dashboard/api-keys)
and refer the [docs](https://docs.mem0.ai/platform/quickstart#4-1-create-memories)
for adding user preferences.
Code
import os
from crewai import Crew, Process
from mem0 import MemoryClient
# Set environment variables for Mem0
os.environ["MEM0_API_KEY"] = "m0-xx"
# Step 1: Record preferences based on past conversation or user input
client = MemoryClient()
messages = [\
{"role": "user", "content": "Hi there! I'm planning a vacation and could use some advice."},\
{"role": "assistant", "content": "Hello! I'd be happy to help with your vacation planning. What kind of destination do you prefer?"},\
{"role": "user", "content": "I am more of a beach person than a mountain person."},\
{"role": "assistant", "content": "That's interesting. Do you like hotels or Airbnb?"},\
{"role": "user", "content": "I like Airbnb more."},\
]
client.add(messages, user_id="john")
# Step 2: Create a Crew with User Memory
crew = Crew(
agents=[...],
tasks=[...],
verbose=True,
process=Process.sequential,
memory=True,
memory_config={
"provider": "mem0",
"config": {"user_id": "john"},
},
)
[](#memory-configuration-options)
Memory Configuration Options
------------------------------------------------------------------
If you want to access a specific organization and project, you can set the `org_id` and `project_id` parameters in the memory configuration.
Code
from crewai import Crew
crew = Crew(
agents=[...],
tasks=[...],
verbose=True,
memory=True,
memory_config={
"provider": "mem0",
"config": {"user_id": "john", "org_id": "my_org_id", "project_id": "my_project_id"},
},
)
[](#additional-embedding-providers)
Additional Embedding Providers
----------------------------------------------------------------------
###
[](#using-openai-embeddings-already-default)
Using OpenAI embeddings (already default)
Code
from crewai import Crew, Agent, Task, Process
my_crew = Crew(
agents=[...],
tasks=[...],
process=Process.sequential,
memory=True,
verbose=True,
embedder={
"provider": "openai",
"config": {
"model": 'text-embedding-3-small'
}
}
)
Alternatively, you can directly pass the OpenAIEmbeddingFunction to the embedder parameter.
Example:
Code
from crewai import Crew, Agent, Task, Process
from chromadb.utils.embedding_functions import OpenAIEmbeddingFunction
my_crew = Crew(
agents=[...],
tasks=[...],
process=Process.sequential,
memory=True,
verbose=True,
embedder={
"provider": "openai",
"config": {
"model": 'text-embedding-3-small'
}
}
)
###
[](#using-ollama-embeddings)
Using Ollama embeddings
Code
from crewai import Crew, Agent, Task, Process
my_crew = Crew(
agents=[...],
tasks=[...],
process=Process.sequential,
memory=True,
verbose=True,
embedder={
"provider": "ollama",
"config": {
"model": "mxbai-embed-large"
}
}
)
###
[](#using-google-ai-embeddings)
Using Google AI embeddings
####
[](#prerequisites)
Prerequisites
Before using Google AI embeddings, ensure you have:
* Access to the Gemini API
* The necessary API keys and permissions
You will need to update your _pyproject.toml_ dependencies:
dependencies = [\
"google-generativeai>=0.8.4", #main version in January/2025 - crewai v.0.100.0 and crewai-tools 0.33.0\
"crewai[tools]>=0.100.0,<1.0.0"\
]
Code
from crewai import Crew, Agent, Task, Process
my_crew = Crew(
agents=[...],
tasks=[...],
process=Process.sequential,
memory=True,
verbose=True,
embedder={
"provider": "google",
"config": {
"api_key": "",
"model": ""
}
}
)
###
[](#using-azure-openai-embeddings)
Using Azure OpenAI embeddings
Code
from chromadb.utils.embedding_functions import OpenAIEmbeddingFunction
from crewai import Crew, Agent, Task, Process
my_crew = Crew(
agents=[...],
tasks=[...],
process=Process.sequential,
memory=True,
verbose=True,
embedder={
"provider": "openai",
"config": {
"api_key": "YOUR_API_KEY",
"api_base": "YOUR_API_BASE_PATH",
"api_version": "YOUR_API_VERSION",
"model_name": 'text-embedding-3-small'
}
}
)
###
[](#using-vertex-ai-embeddings)
Using Vertex AI embeddings
Code
from chromadb.utils.embedding_functions import GoogleVertexEmbeddingFunction
from crewai import Crew, Agent, Task, Process
my_crew = Crew(
agents=[...],
tasks=[...],
process=Process.sequential,
memory=True,
verbose=True,
embedder={
"provider": "vertexai",
"config": {
"project_id"="YOUR_PROJECT_ID",
"region"="YOUR_REGION",
"api_key"="YOUR_API_KEY",
"model_name"="textembedding-gecko"
}
}
)
###
[](#using-cohere-embeddings)
Using Cohere embeddings
Code
from crewai import Crew, Agent, Task, Process
my_crew = Crew(
agents=[...],
tasks=[...],
process=Process.sequential,
memory=True,
verbose=True,
embedder={
"provider": "cohere",
"config": {
"api_key": "YOUR_API_KEY",
"model": ""
}
}
)
###
[](#using-voyageai-embeddings)
Using VoyageAI embeddings
Code
from crewai import Crew, Agent, Task, Process
my_crew = Crew(
agents=[...],
tasks=[...],
process=Process.sequential,
memory=True,
verbose=True,
embedder={
"provider": "voyageai",
"config": {
"api_key": "YOUR_API_KEY",
"model": ""
}
}
)
###
[](#using-huggingface-embeddings)
Using HuggingFace embeddings
Code
from crewai import Crew, Agent, Task, Process
my_crew = Crew(
agents=[...],
tasks=[...],
process=Process.sequential,
memory=True,
verbose=True,
embedder={
"provider": "huggingface",
"config": {
"api_url": "",
}
}
)
###
[](#using-watson-embeddings)
Using Watson embeddings
Code
from crewai import Crew, Agent, Task, Process
# Note: Ensure you have installed and imported `ibm_watsonx_ai` for Watson embeddings to work.
my_crew = Crew(
agents=[...],
tasks=[...],
process=Process.sequential,
memory=True,
verbose=True,
embedder={
"provider": "watson",
"config": {
"model": "",
"api_url": "",
"api_key": "",
"project_id": "",
}
}
)
###
[](#using-amazon-bedrock-embeddings)
Using Amazon Bedrock embeddings
Code
# Note: Ensure you have installed `boto3` for Bedrock embeddings to work.
import os
import boto3
from crewai import Crew, Agent, Task, Process
boto3_session = boto3.Session(
region_name=os.environ.get("AWS_REGION_NAME"),
aws_access_key_id=os.environ.get("AWS_ACCESS_KEY_ID"),
aws_secret_access_key=os.environ.get("AWS_SECRET_ACCESS_KEY")
)
my_crew = Crew(
agents=[...],
tasks=[...],
process=Process.sequential,
memory=True,
embedder={
"provider": "bedrock",
"config":{
"session": boto3_session,
"model": "amazon.titan-embed-text-v2:0",
"vector_dimension": 1024
}
}
verbose=True
)
###
[](#adding-custom-embedding-function)
Adding Custom Embedding Function
Code
from crewai import Crew, Agent, Task, Process
from chromadb import Documents, EmbeddingFunction, Embeddings
# Create a custom embedding function
class CustomEmbedder(EmbeddingFunction):
def __call__(self, input: Documents) -> Embeddings:
# generate embeddings
return [1, 2, 3] # this is a dummy embedding
my_crew = Crew(
agents=[...],
tasks=[...],
process=Process.sequential,
memory=True,
verbose=True,
embedder={
"provider": "custom",
"config": {
"embedder": CustomEmbedder()
}
}
)
###
[](#resetting-memory)
Resetting Memory
crewai reset-memories [OPTIONS]
####
[](#resetting-memory-options)
Resetting Memory Options
| Option | Description | Type | Default |
| --- | --- | --- | --- |
| `-l`, `--long` | Reset LONG TERM memory. | Flag (boolean) | False |
| `-s`, `--short` | Reset SHORT TERM memory. | Flag (boolean) | False |
| `-e`, `--entities` | Reset ENTITIES memory. | Flag (boolean) | False |
| `-k`, `--kickoff-outputs` | Reset LATEST KICKOFF TASK OUTPUTS. | Flag (boolean) | False |
| `-a`, `--all` | Reset ALL memories. | Flag (boolean) | False |
[](#benefits-of-using-crewai%E2%80%99s-memory-system)
Benefits of Using CrewAI’s Memory System
--------------------------------------------------------------------------------------------------
* 🦾 **Adaptive Learning:** Crews become more efficient over time, adapting to new information and refining their approach to tasks.
* 🫡 **Enhanced Personalization:** Memory enables agents to remember user preferences and historical interactions, leading to personalized experiences.
* 🧠 **Improved Problem Solving:** Access to a rich memory store aids agents in making more informed decisions, drawing on past learnings and contextual insights.
[](#conclusion)
Conclusion
------------------------------
Integrating CrewAI’s memory system into your projects is straightforward. By leveraging the provided memory components and configurations, you can quickly empower your agents with the ability to remember, reason, and learn from their interactions, unlocking new levels of intelligence and capability.
Was this page helpful?
YesNo
[Training](/concepts/training)
[Planning](/concepts/planning)
On this page
* [Introduction to Memory Systems in CrewAI](#introduction-to-memory-systems-in-crewai)
* [Memory System Components](#memory-system-components)
* [How Memory Systems Empower Agents](#how-memory-systems-empower-agents)
* [Implementing Memory in Your Crew](#implementing-memory-in-your-crew)
* [Example: Configuring Memory for a Crew](#example%3A-configuring-memory-for-a-crew)
* [Example: Use Custom Memory Instances e.g FAISS as the VectorDB](#example%3A-use-custom-memory-instances-e-g-faiss-as-the-vectordb)
* [Security Considerations](#security-considerations)
* [Configuration Examples](#configuration-examples)
* [Basic Memory Configuration](#basic-memory-configuration)
* [Custom Storage Configuration](#custom-storage-configuration)
* [Integrating Mem0 for Enhanced User Memory](#integrating-mem0-for-enhanced-user-memory)
* [Memory Configuration Options](#memory-configuration-options)
* [Additional Embedding Providers](#additional-embedding-providers)
* [Using OpenAI embeddings (already default)](#using-openai-embeddings-already-default)
* [Using Ollama embeddings](#using-ollama-embeddings)
* [Using Google AI embeddings](#using-google-ai-embeddings)
* [Prerequisites](#prerequisites)
* [Using Azure OpenAI embeddings](#using-azure-openai-embeddings)
* [Using Vertex AI embeddings](#using-vertex-ai-embeddings)
* [Using Cohere embeddings](#using-cohere-embeddings)
* [Using VoyageAI embeddings](#using-voyageai-embeddings)
* [Using HuggingFace embeddings](#using-huggingface-embeddings)
* [Using Watson embeddings](#using-watson-embeddings)
* [Using Amazon Bedrock embeddings](#using-amazon-bedrock-embeddings)
* [Adding Custom Embedding Function](#adding-custom-embedding-function)
* [Resetting Memory](#resetting-memory)
* [Resetting Memory Options](#resetting-memory-options)
* [Benefits of Using CrewAI’s Memory System](#benefits-of-using-crewai%E2%80%99s-memory-system)
* [Conclusion](#conclusion)
---
# LLMs - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Core Concepts
LLMs
[Get Started](/introduction)
[Examples](/examples/example)
CrewAI integrates with multiple LLM providers through LiteLLM, giving you the flexibility to choose the right model for your specific use case. This guide will help you understand how to configure and use different LLM providers in your CrewAI projects.
[](#what-are-llms%3F)
What are LLMs?
----------------------------------------
Large Language Models (LLMs) are the core intelligence behind CrewAI agents. They enable agents to understand context, make decisions, and generate human-like responses. Here’s what you need to know:
LLM Basics
----------
Large Language Models are AI systems trained on vast amounts of text data. They power the intelligence of your CrewAI agents, enabling them to understand and generate human-like text.
Context Window
--------------
The context window determines how much text an LLM can process at once. Larger windows (e.g., 128K tokens) allow for more context but may be more expensive and slower.
Temperature
-----------
Temperature (0.0 to 1.0) controls response randomness. Lower values (e.g., 0.2) produce more focused, deterministic outputs, while higher values (e.g., 0.8) increase creativity and variability.
Provider Selection
------------------
Each LLM provider (e.g., OpenAI, Anthropic, Google) offers different models with varying capabilities, pricing, and features. Choose based on your needs for accuracy, speed, and cost.
[](#setting-up-your-llm)
Setting Up Your LLM
------------------------------------------------
There are three ways to configure LLMs in CrewAI. Choose the method that best fits your workflow:
* 1\. Environment Variables
* 2\. YAML Configuration
* 3\. Direct Code
The simplest way to get started. Set these variables in your environment:
# Required: Your API key for authentication
OPENAI_API_KEY=
# Optional: Default model selection
OPENAI_MODEL_NAME=gpt-4o-mini # Default if not set
# Optional: Organization ID (if applicable)
OPENAI_ORGANIZATION_ID=
Never commit API keys to version control. Use environment files (.env) or your system’s secret management.
[](#provider-configuration-examples)
Provider Configuration Examples
------------------------------------------------------------------------
CrewAI supports a multitude of LLM providers, each offering unique features, authentication methods, and model capabilities. In this section, you’ll find detailed examples that help you select, configure, and optimize the LLM that best fits your project’s needs.
OpenAI
Set the following environment variables in your `.env` file:
Code
# Required
OPENAI_API_KEY=sk-...
# Optional
OPENAI_API_BASE=
OPENAI_ORGANIZATION=
Example usage in your CrewAI project:
Code
from crewai import LLM
llm = LLM(
model="openai/gpt-4", # call model by provider/model_name
temperature=0.8,
max_tokens=150,
top_p=0.9,
frequency_penalty=0.1,
presence_penalty=0.1,
stop=["END"],
seed=42
)
OpenAI is one of the leading providers of LLMs with a wide range of models and features.
| Model | Context Window | Best For |
| --- | --- | --- |
| GPT-4 | 8,192 tokens | High-accuracy tasks, complex reasoning |
| GPT-4 Turbo | 128,000 tokens | Long-form content, document analysis |
| GPT-4o & GPT-4o-mini | 128,000 tokens | Cost-effective large context processing |
| o3-mini | 200,000 tokens | Fast reasoning, complex reasoning |
| o1-mini | 128,000 tokens | Fast reasoning, complex reasoning |
| o1-preview | 128,000 tokens | Fast reasoning, complex reasoning |
| o1 | 200,000 tokens | Fast reasoning, complex reasoning |
Anthropic
Code
ANTHROPIC_API_KEY=sk-ant-...
Example usage in your CrewAI project:
Code
llm = LLM(
model="anthropic/claude-3-sonnet-20240229-v1:0",
temperature=0.7
)
Google
Set the following environment variables in your `.env` file:
Code
# Option 1: Gemini accessed with an API key.
# https://ai.google.dev/gemini-api/docs/api-key
GEMINI_API_KEY=
# Option 2: Vertex AI IAM credentials for Gemini, Anthropic, and Model Garden.
# https://cloud.google.com/vertex-ai/generative-ai/docs/overview
Get credentials from your Google Cloud Console and save it to a JSON file with the following code:
Code
import json
file_path = 'path/to/vertex_ai_service_account.json'
# Load the JSON file
with open(file_path, 'r') as file:
vertex_credentials = json.load(file)
# Convert the credentials to a JSON string
vertex_credentials_json = json.dumps(vertex_credentials)
Example usage in your CrewAI project:
Code
from crewai import LLM
llm = LLM(
model="gemini/gemini-1.5-pro-latest",
temperature=0.7,
vertex_credentials=vertex_credentials_json
)
Google offers a range of powerful models optimized for different use cases:
| Model | Context Window | Best For |
| --- | --- | --- |
| gemini-2.0-flash-exp | 1M tokens | Higher quality at faster speed, multimodal model, good for most tasks |
| gemini-1.5-flash | 1M tokens | Balanced multimodal model, good for most tasks |
| gemini-1.5-flash-8B | 1M tokens | Fastest, most cost-efficient, good for high-frequency tasks |
| gemini-1.5-pro | 2M tokens | Best performing, wide variety of reasoning tasks including logical reasoning, coding, and creative collaboration |
Azure
Code
# Required
AZURE_API_KEY=
AZURE_API_BASE=
AZURE_API_VERSION=
# Optional
AZURE_AD_TOKEN=
AZURE_API_TYPE=
Example usage in your CrewAI project:
Code
llm = LLM(
model="azure/gpt-4",
api_version="2023-05-15"
)
AWS Bedrock
Code
AWS_ACCESS_KEY_ID=
AWS_SECRET_ACCESS_KEY=
AWS_DEFAULT_REGION=
Example usage in your CrewAI project:
Code
llm = LLM(
model="bedrock/anthropic.claude-3-sonnet-20240229-v1:0"
)
Amazon SageMaker
Code
AWS_ACCESS_KEY_ID=
AWS_SECRET_ACCESS_KEY=
AWS_DEFAULT_REGION=
Example usage in your CrewAI project:
Code
llm = LLM(
model="sagemaker/"
)
Mistral
Set the following environment variables in your `.env` file:
Code
MISTRAL_API_KEY=
Example usage in your CrewAI project:
Code
llm = LLM(
model="mistral/mistral-large-latest",
temperature=0.7
)
Nvidia NIM
Set the following environment variables in your `.env` file:
Code
NVIDIA_API_KEY=
Example usage in your CrewAI project:
Code
llm = LLM(
model="nvidia_nim/meta/llama3-70b-instruct",
temperature=0.7
)
Nvidia NIM provides a comprehensive suite of models for various use cases, from general-purpose tasks to specialized applications.
| Model | Context Window | Best For |
| --- | --- | --- |
| nvidia/mistral-nemo-minitron-8b-8k-instruct | 8,192 tokens | State-of-the-art small language model delivering superior accuracy for chatbot, virtual assistants, and content generation. |
| nvidia/nemotron-4-mini-hindi-4b-instruct | 4,096 tokens | A bilingual Hindi-English SLM for on-device inference, tailored specifically for Hindi Language. |
| nvidia/llama-3.1-nemotron-70b-instruct | 128k tokens | Customized for enhanced helpfulness in responses |
| nvidia/llama3-chatqa-1.5-8b | 128k tokens | Advanced LLM to generate high-quality, context-aware responses for chatbots and search engines. |
| nvidia/llama3-chatqa-1.5-70b | 128k tokens | Advanced LLM to generate high-quality, context-aware responses for chatbots and search engines. |
| nvidia/vila | 128k tokens | Multi-modal vision-language model that understands text/img/video and creates informative responses |
| nvidia/neva-22 | 4,096 tokens | Multi-modal vision-language model that understands text/images and generates informative responses |
| nvidia/nemotron-mini-4b-instruct | 8,192 tokens | General-purpose tasks |
| nvidia/usdcode-llama3-70b-instruct | 128k tokens | State-of-the-art LLM that answers OpenUSD knowledge queries and generates USD-Python code. |
| nvidia/nemotron-4-340b-instruct | 4,096 tokens | Creates diverse synthetic data that mimics the characteristics of real-world data. |
| meta/codellama-70b | 100k tokens | LLM capable of generating code from natural language and vice versa. |
| meta/llama2-70b | 4,096 tokens | Cutting-edge large language AI model capable of generating text and code in response to prompts. |
| meta/llama3-8b-instruct | 8,192 tokens | Advanced state-of-the-art LLM with language understanding, superior reasoning, and text generation. |
| meta/llama3-70b-instruct | 8,192 tokens | Powers complex conversations with superior contextual understanding, reasoning and text generation. |
| meta/llama-3.1-8b-instruct | 128k tokens | Advanced state-of-the-art model with language understanding, superior reasoning, and text generation. |
| meta/llama-3.1-70b-instruct | 128k tokens | Powers complex conversations with superior contextual understanding, reasoning and text generation. |
| meta/llama-3.1-405b-instruct | 128k tokens | Advanced LLM for synthetic data generation, distillation, and inference for chatbots, coding, and domain-specific tasks. |
| meta/llama-3.2-1b-instruct | 128k tokens | Advanced state-of-the-art small language model with language understanding, superior reasoning, and text generation. |
| meta/llama-3.2-3b-instruct | 128k tokens | Advanced state-of-the-art small language model with language understanding, superior reasoning, and text generation. |
| meta/llama-3.2-11b-vision-instruct | 128k tokens | Advanced state-of-the-art small language model with language understanding, superior reasoning, and text generation. |
| meta/llama-3.2-90b-vision-instruct | 128k tokens | Advanced state-of-the-art small language model with language understanding, superior reasoning, and text generation. |
| google/gemma-7b | 8,192 tokens | Cutting-edge text generation model text understanding, transformation, and code generation. |
| google/gemma-2b | 8,192 tokens | Cutting-edge text generation model text understanding, transformation, and code generation. |
| google/codegemma-7b | 8,192 tokens | Cutting-edge model built on Google’s Gemma-7B specialized for code generation and code completion. |
| google/codegemma-1.1-7b | 8,192 tokens | Advanced programming model for code generation, completion, reasoning, and instruction following. |
| google/recurrentgemma-2b | 8,192 tokens | Novel recurrent architecture based language model for faster inference when generating long sequences. |
| google/gemma-2-9b-it | 8,192 tokens | Cutting-edge text generation model text understanding, transformation, and code generation. |
| google/gemma-2-27b-it | 8,192 tokens | Cutting-edge text generation model text understanding, transformation, and code generation. |
| google/gemma-2-2b-it | 8,192 tokens | Cutting-edge text generation model text understanding, transformation, and code generation. |
| google/deplot | 512 tokens | One-shot visual language understanding model that translates images of plots into tables. |
| google/paligemma | 8,192 tokens | Vision language model adept at comprehending text and visual inputs to produce informative responses. |
| mistralai/mistral-7b-instruct-v0.2 | 32k tokens | This LLM follows instructions, completes requests, and generates creative text. |
| mistralai/mixtral-8x7b-instruct-v0.1 | 8,192 tokens | An MOE LLM that follows instructions, completes requests, and generates creative text. |
| mistralai/mistral-large | 4,096 tokens | Creates diverse synthetic data that mimics the characteristics of real-world data. |
| mistralai/mixtral-8x22b-instruct-v0.1 | 8,192 tokens | Creates diverse synthetic data that mimics the characteristics of real-world data. |
| mistralai/mistral-7b-instruct-v0.3 | 32k tokens | This LLM follows instructions, completes requests, and generates creative text. |
| nv-mistralai/mistral-nemo-12b-instruct | 128k tokens | Most advanced language model for reasoning, code, multilingual tasks; runs on a single GPU. |
| mistralai/mamba-codestral-7b-v0.1 | 256k tokens | Model for writing and interacting with code across a wide range of programming languages and tasks. |
| microsoft/phi-3-mini-128k-instruct | 128K tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
| microsoft/phi-3-mini-4k-instruct | 4,096 tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
| microsoft/phi-3-small-8k-instruct | 8,192 tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
| microsoft/phi-3-small-128k-instruct | 128K tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
| microsoft/phi-3-medium-4k-instruct | 4,096 tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
| microsoft/phi-3-medium-128k-instruct | 128K tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
| microsoft/phi-3.5-mini-instruct | 128K tokens | Lightweight multilingual LLM powering AI applications in latency bound, memory/compute constrained environments |
| microsoft/phi-3.5-moe-instruct | 128K tokens | Advanced LLM based on Mixture of Experts architecure to deliver compute efficient content generation |
| microsoft/kosmos-2 | 1,024 tokens | Groundbreaking multimodal model designed to understand and reason about visual elements in images. |
| microsoft/phi-3-vision-128k-instruct | 128k tokens | Cutting-edge open multimodal model exceling in high-quality reasoning from images. |
| microsoft/phi-3.5-vision-instruct | 128k tokens | Cutting-edge open multimodal model exceling in high-quality reasoning from images. |
| databricks/dbrx-instruct | 12k tokens | A general-purpose LLM with state-of-the-art performance in language understanding, coding, and RAG. |
| snowflake/arctic | 1,024 tokens | Delivers high efficiency inference for enterprise applications focused on SQL generation and coding. |
| aisingapore/sea-lion-7b-instruct | 4,096 tokens | LLM to represent and serve the linguistic and cultural diversity of Southeast Asia |
| ibm/granite-8b-code-instruct | 4,096 tokens | Software programming LLM for code generation, completion, explanation, and multi-turn conversion. |
| ibm/granite-34b-code-instruct | 8,192 tokens | Software programming LLM for code generation, completion, explanation, and multi-turn conversion. |
| ibm/granite-3.0-8b-instruct | 4,096 tokens | Advanced Small Language Model supporting RAG, summarization, classification, code, and agentic AI |
| ibm/granite-3.0-3b-a800m-instruct | 4,096 tokens | Highly efficient Mixture of Experts model for RAG, summarization, entity extraction, and classification |
| mediatek/breeze-7b-instruct | 4,096 tokens | Creates diverse synthetic data that mimics the characteristics of real-world data. |
| upstage/solar-10.7b-instruct | 4,096 tokens | Excels in NLP tasks, particularly in instruction-following, reasoning, and mathematics. |
| writer/palmyra-med-70b-32k | 32k tokens | Leading LLM for accurate, contextually relevant responses in the medical domain. |
| writer/palmyra-med-70b | 32k tokens | Leading LLM for accurate, contextually relevant responses in the medical domain. |
| writer/palmyra-fin-70b-32k | 32k tokens | Specialized LLM for financial analysis, reporting, and data processing |
| 01-ai/yi-large | 32k tokens | Powerful model trained on English and Chinese for diverse tasks including chatbot and creative writing. |
| deepseek-ai/deepseek-coder-6.7b-instruct | 2k tokens | Powerful coding model offering advanced capabilities in code generation, completion, and infilling |
| rakuten/rakutenai-7b-instruct | 1,024 tokens | Advanced state-of-the-art LLM with language understanding, superior reasoning, and text generation. |
| rakuten/rakutenai-7b-chat | 1,024 tokens | Advanced state-of-the-art LLM with language understanding, superior reasoning, and text generation. |
| baichuan-inc/baichuan2-13b-chat | 4,096 tokens | Support Chinese and English chat, coding, math, instruction following, solving quizzes |
Groq
Set the following environment variables in your `.env` file:
Code
GROQ_API_KEY=
Example usage in your CrewAI project:
Code
llm = LLM(
model="groq/llama-3.2-90b-text-preview",
temperature=0.7
)
| Model | Context Window | Best For |
| --- | --- | --- |
| Llama 3.1 70B/8B | 131,072 tokens | High-performance, large context tasks |
| Llama 3.2 Series | 8,192 tokens | General-purpose tasks |
| Mixtral 8x7B | 32,768 tokens | Balanced performance and context |
IBM watsonx.ai
Set the following environment variables in your `.env` file:
Code
# Required
WATSONX_URL=
WATSONX_APIKEY=
WATSONX_PROJECT_ID=
# Optional
WATSONX_TOKEN=
WATSONX_DEPLOYMENT_SPACE_ID=
Example usage in your CrewAI project:
Code
llm = LLM(
model="watsonx/meta-llama/llama-3-1-70b-instruct",
base_url="https://api.watsonx.ai/v1"
)
Ollama (Local LLMs)
1. Install Ollama: [ollama.ai](https://ollama.ai/)
2. Run a model: `ollama run llama2`
3. Configure:
Code
llm = LLM(
model="ollama/llama3:70b",
base_url="http://localhost:11434"
)
Fireworks AI
Set the following environment variables in your `.env` file:
Code
FIREWORKS_API_KEY=
Example usage in your CrewAI project:
Code
llm = LLM(
model="fireworks_ai/accounts/fireworks/models/llama-v3-70b-instruct",
temperature=0.7
)
Perplexity AI
Set the following environment variables in your `.env` file:
Code
PERPLEXITY_API_KEY=
Example usage in your CrewAI project:
Code
llm = LLM(
model="llama-3.1-sonar-large-128k-online",
base_url="https://api.perplexity.ai/"
)
Hugging Face
Set the following environment variables in your `.env` file:
Code
HUGGINGFACE_API_KEY=
Example usage in your CrewAI project:
Code
llm = LLM(
model="huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct",
base_url="your_api_endpoint"
)
SambaNova
Set the following environment variables in your `.env` file:
Code
SAMBANOVA_API_KEY=
Example usage in your CrewAI project:
Code
llm = LLM(
model="sambanova/Meta-Llama-3.1-8B-Instruct",
temperature=0.7
)
| Model | Context Window | Best For |
| --- | --- | --- |
| Llama 3.1 70B/8B | Up to 131,072 tokens | High-performance, large context tasks |
| Llama 3.1 405B | 8,192 tokens | High-performance and output quality |
| Llama 3.2 Series | 8,192 tokens | General-purpose, multimodal tasks |
| Llama 3.3 70B | Up to 131,072 tokens | High-performance and output quality |
| Qwen2 familly | 8,192 tokens | High-performance and output quality |
Cerebras
Set the following environment variables in your `.env` file:
Code
# Required
CEREBRAS_API_KEY=
Example usage in your CrewAI project:
Code
llm = LLM(
model="cerebras/llama3.1-70b",
temperature=0.7,
max_tokens=8192
)
Cerebras features:
* Fast inference speeds
* Competitive pricing
* Good balance of speed and quality
* Support for long context windows
Open Router
Set the following environment variables in your `.env` file:
Code
OPENROUTER_API_KEY=
Example usage in your CrewAI project:
Code
llm = LLM(
model="openrouter/deepseek/deepseek-r1",
base_url="https://openrouter.ai/api/v1",
api_key=OPENROUTER_API_KEY
)
Open Router models:
* openrouter/deepseek/deepseek-r1
* openrouter/deepseek/deepseek-chat
[](#structured-llm-calls)
Structured LLM Calls
--------------------------------------------------
CrewAI supports structured responses from LLM calls by allowing you to define a `response_format` using a Pydantic model. This enables the framework to automatically parse and validate the output, making it easier to integrate the response into your application without manual post-processing.
For example, you can define a Pydantic model to represent the expected response structure and pass it as the `response_format` when instantiating the LLM. The model will then be used to convert the LLM output into a structured Python object.
Code
from crewai import LLM
class Dog(BaseModel):
name: str
age: int
breed: str
llm = LLM(model="gpt-4o", response_format=Dog)
response = llm.call(
"Analyze the following messages and return the name, age, and breed. "
"Meet Kona! She is 3 years old and is a black german shepherd."
)
print(response)
# Output:
# Dog(name='Kona', age=3, breed='black german shepherd')
[](#advanced-features-and-optimization)
Advanced Features and Optimization
------------------------------------------------------------------------------
Learn how to get the most out of your LLM configuration:
Context Window Management
CrewAI includes smart context management features:
from crewai import LLM
# CrewAI automatically handles:
# 1. Token counting and tracking
# 2. Content summarization when needed
# 3. Task splitting for large contexts
llm = LLM(
model="gpt-4",
max_tokens=4000, # Limit response length
)
Best practices for context management:
1. Choose models with appropriate context windows
2. Pre-process long inputs when possible
3. Use chunking for large documents
4. Monitor token usage to optimize costs
Performance Optimization
1
Token Usage Optimization
Choose the right context window for your task:
* Small tasks (up to 4K tokens): Standard models
* Medium tasks (between 4K-32K): Enhanced models
* Large tasks (over 32K): Large context models
# Configure model with appropriate settings
llm = LLM(
model="openai/gpt-4-turbo-preview",
temperature=0.7, # Adjust based on task
max_tokens=4096, # Set based on output needs
timeout=300 # Longer timeout for complex tasks
)
* Lower temperature (0.1 to 0.3) for factual responses
* Higher temperature (0.7 to 0.9) for creative tasks
2
Best Practices
1. Monitor token usage
2. Implement rate limiting
3. Use caching when possible
4. Set appropriate max\_tokens limits
Remember to regularly monitor your token usage and adjust your configuration as needed to optimize costs and performance.
[](#common-issues-and-solutions)
Common Issues and Solutions
----------------------------------------------------------------
* Authentication
* Model Names
* Context Length
Most authentication issues can be resolved by checking API key format and environment variable names.
# OpenAI
OPENAI_API_KEY=sk-...
# Anthropic
ANTHROPIC_API_KEY=sk-ant-...
[](#getting-help)
Getting Help
----------------------------------
If you need assistance, these resources are available:
[LiteLLM Documentation\
---------------------\
\
Comprehensive documentation for LiteLLM integration and troubleshooting common issues.](https://docs.litellm.ai/docs/)
[GitHub Issues\
-------------\
\
Report bugs, request features, or browse existing issues for solutions.](https://github.com/joaomdmoura/crewAI/issues)
[Community Forum\
---------------\
\
Connect with other CrewAI users, share experiences, and get help from the community.](https://community.crewai.com)
Best Practices for API Key Security:
* Use environment variables or secure vaults
* Never commit keys to version control
* Rotate keys regularly
* Use separate keys for development and production
* Monitor key usage for unusual patterns
Was this page helpful?
YesNo
[Knowledge](/concepts/knowledge)
[Processes](/concepts/processes)
On this page
* [What are LLMs?](#what-are-llms%3F)
* [Setting Up Your LLM](#setting-up-your-llm)
* [Provider Configuration Examples](#provider-configuration-examples)
* [Structured LLM Calls](#structured-llm-calls)
* [Advanced Features and Optimization](#advanced-features-and-optimization)
* [Common Issues and Solutions](#common-issues-and-solutions)
* [Getting Help](#getting-help)
---
# Knowledge - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Core Concepts
Knowledge
[Get Started](/introduction)
[Examples](/examples/example)
[](#what-is-knowledge%3F)
What is Knowledge?
------------------------------------------------
Knowledge in CrewAI is a powerful system that allows AI agents to access and utilize external information sources during their tasks. Think of it as giving your agents a reference library they can consult while working.
Key benefits of using Knowledge:
* Enhance agents with domain-specific information
* Support decisions with real-world data
* Maintain context across conversations
* Ground responses in factual information
[](#supported-knowledge-sources)
Supported Knowledge Sources
----------------------------------------------------------------
CrewAI supports various types of knowledge sources out of the box:
Text Sources
------------
* Raw strings
* Text files (.txt)
* PDF documents
Structured Data
---------------
* CSV files
* Excel spreadsheets
* JSON documents
[](#supported-knowledge-parameters)
Supported Knowledge Parameters
----------------------------------------------------------------------
| Parameter | Type | Required | Description |
| --- | --- | --- | --- |
| `sources` | **List\[BaseKnowledgeSource\]** | Yes | List of knowledge sources that provide content to be stored and queried. Can include PDF, CSV, Excel, JSON, text files, or string content. |
| `collection_name` | **str** | No | Name of the collection where the knowledge will be stored. Used to identify different sets of knowledge. Defaults to “knowledge” if not provided. |
| `storage` | **Optional\[KnowledgeStorage\]** | No | Custom storage configuration for managing how the knowledge is stored and retrieved. If not provided, a default storage will be created. |
[](#quickstart-example)
Quickstart Example
----------------------------------------------
For file-Based Knowledge Sources, make sure to place your files in a `knowledge` directory at the root of your project. Also, use relative paths from the `knowledge` directory when creating the source.
Here’s an example using string-based knowledge:
Code
from crewai import Agent, Task, Crew, Process, LLM
from crewai.knowledge.source.string_knowledge_source import StringKnowledgeSource
# Create a knowledge source
content = "Users name is John. He is 30 years old and lives in San Francisco."
string_source = StringKnowledgeSource(
content=content,
)
# Create an LLM with a temperature of 0 to ensure deterministic outputs
llm = LLM(model="gpt-4o-mini", temperature=0)
# Create an agent with the knowledge store
agent = Agent(
role="About User",
goal="You know everything about the user.",
backstory="""You are a master at understanding people and their preferences.""",
verbose=True,
allow_delegation=False,
llm=llm,
)
task = Task(
description="Answer the following questions about the user: {question}",
expected_output="An answer to the question.",
agent=agent,
)
crew = Crew(
agents=[agent],
tasks=[task],
verbose=True,
process=Process.sequential,
knowledge_sources=[string_source], # Enable knowledge by adding the sources here. You can also add more sources to the sources list.
)
result = crew.kickoff(inputs={"question": "What city does John live in and how old is he?"})
Here’s another example with the `CrewDoclingSource`. The CrewDoclingSource is actually quite versatile and can handle multiple file formats including MD, PDF, DOCX, HTML, and more.
You need to install `docling` for the following example to work: `uv add docling`
Code
from crewai import LLM, Agent, Crew, Process, Task
from crewai.knowledge.source.crew_docling_source import CrewDoclingSource
# Create a knowledge source
content_source = CrewDoclingSource(
file_paths=[\
"https://lilianweng.github.io/posts/2024-11-28-reward-hacking",\
"https://lilianweng.github.io/posts/2024-07-07-hallucination",\
],
)
# Create an LLM with a temperature of 0 to ensure deterministic outputs
llm = LLM(model="gpt-4o-mini", temperature=0)
# Create an agent with the knowledge store
agent = Agent(
role="About papers",
goal="You know everything about the papers.",
backstory="""You are a master at understanding papers and their content.""",
verbose=True,
allow_delegation=False,
llm=llm,
)
task = Task(
description="Answer the following questions about the papers: {question}",
expected_output="An answer to the question.",
agent=agent,
)
crew = Crew(
agents=[agent],
tasks=[task],
verbose=True,
process=Process.sequential,
knowledge_sources=[\
content_source\
], # Enable knowledge by adding the sources here. You can also add more sources to the sources list.
)
result = crew.kickoff(
inputs={
"question": "What is the reward hacking paper about? Be sure to provide sources."
}
)
[](#more-examples)
More Examples
------------------------------------
Here are examples of how to use different types of knowledge sources:
###
[](#text-file-knowledge-source)
Text File Knowledge Source
from crewai.knowledge.source.text_file_knowledge_source import TextFileKnowledgeSource
# Create a text file knowledge source
text_source = TextFileKnowledgeSource(
file_paths=["document.txt", "another.txt"]
)
# Create crew with text file source on agents or crew level
agent = Agent(
...
knowledge_sources=[text_source]
)
crew = Crew(
...
knowledge_sources=[text_source]
)
###
[](#pdf-knowledge-source)
PDF Knowledge Source
from crewai.knowledge.source.pdf_knowledge_source import PDFKnowledgeSource
# Create a PDF knowledge source
pdf_source = PDFKnowledgeSource(
file_paths=["document.pdf", "another.pdf"]
)
# Create crew with PDF knowledge source on agents or crew level
agent = Agent(
...
knowledge_sources=[pdf_source]
)
crew = Crew(
...
knowledge_sources=[pdf_source]
)
###
[](#csv-knowledge-source)
CSV Knowledge Source
from crewai.knowledge.source.csv_knowledge_source import CSVKnowledgeSource
# Create a CSV knowledge source
csv_source = CSVKnowledgeSource(
file_paths=["data.csv"]
)
# Create crew with CSV knowledge source or on agent level
agent = Agent(
...
knowledge_sources=[csv_source]
)
crew = Crew(
...
knowledge_sources=[csv_source]
)
###
[](#excel-knowledge-source)
Excel Knowledge Source
from crewai.knowledge.source.excel_knowledge_source import ExcelKnowledgeSource
# Create an Excel knowledge source
excel_source = ExcelKnowledgeSource(
file_paths=["spreadsheet.xlsx"]
)
# Create crew with Excel knowledge source on agents or crew level
agent = Agent(
...
knowledge_sources=[excel_source]
)
crew = Crew(
...
knowledge_sources=[excel_source]
)
###
[](#json-knowledge-source)
JSON Knowledge Source
from crewai.knowledge.source.json_knowledge_source import JSONKnowledgeSource
# Create a JSON knowledge source
json_source = JSONKnowledgeSource(
file_paths=["data.json"]
)
# Create crew with JSON knowledge source on agents or crew level
agent = Agent(
...
knowledge_sources=[json_source]
)
crew = Crew(
...
knowledge_sources=[json_source]
)
[](#knowledge-configuration)
Knowledge Configuration
--------------------------------------------------------
###
[](#chunking-configuration)
Chunking Configuration
Knowledge sources automatically chunk content for better processing. You can configure chunking behavior in your knowledge sources:
from crewai.knowledge.source.string_knowledge_source import StringKnowledgeSource
source = StringKnowledgeSource(
content="Your content here",
chunk_size=4000, # Maximum size of each chunk (default: 4000)
chunk_overlap=200 # Overlap between chunks (default: 200)
)
The chunking configuration helps in:
* Breaking down large documents into manageable pieces
* Maintaining context through chunk overlap
* Optimizing retrieval accuracy
###
[](#embeddings-configuration)
Embeddings Configuration
You can also configure the embedder for the knowledge store. This is useful if you want to use a different embedder for the knowledge store than the one used for the agents. The `embedder` parameter supports various embedding model providers that include:
* `openai`: OpenAI’s embedding models
* `google`: Google’s text embedding models
* `azure`: Azure OpenAI embeddings
* `ollama`: Local embeddings with Ollama
* `vertexai`: Google Cloud VertexAI embeddings
* `cohere`: Cohere’s embedding models
* `voyageai`: VoyageAI’s embedding models
* `bedrock`: AWS Bedrock embeddings
* `huggingface`: Hugging Face models
* `watson`: IBM Watson embeddings
Here’s an example of how to configure the embedder for the knowledge store using Google’s `text-embedding-004` model:
Example
Output
from crewai import Agent, Task, Crew, Process, LLM
from crewai.knowledge.source.string_knowledge_source import StringKnowledgeSource
import os
# Get the GEMINI API key
GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
# Create a knowledge source
content = "Users name is John. He is 30 years old and lives in San Francisco."
string_source = StringKnowledgeSource(
content=content,
)
# Create an LLM with a temperature of 0 to ensure deterministic outputs
gemini_llm = LLM(
model="gemini/gemini-1.5-pro-002",
api_key=GEMINI_API_KEY,
temperature=0,
)
# Create an agent with the knowledge store
agent = Agent(
role="About User",
goal="You know everything about the user.",
backstory="""You are a master at understanding people and their preferences.""",
verbose=True,
allow_delegation=False,
llm=gemini_llm,
embedder={
"provider": "google",
"config": {
"model": "models/text-embedding-004",
"api_key": GEMINI_API_KEY,
}
}
)
task = Task(
description="Answer the following questions about the user: {question}",
expected_output="An answer to the question.",
agent=agent,
)
crew = Crew(
agents=[agent],
tasks=[task],
verbose=True,
process=Process.sequential,
knowledge_sources=[string_source],
embedder={
"provider": "google",
"config": {
"model": "models/text-embedding-004",
"api_key": GEMINI_API_KEY,
}
}
)
result = crew.kickoff(inputs={"question": "What city does John live in and how old is he?"})
[](#clearing-knowledge)
Clearing Knowledge
----------------------------------------------
If you need to clear the knowledge stored in CrewAI, you can use the `crewai reset-memories` command with the `--knowledge` option.
Command
crewai reset-memories --knowledge
This is useful when you’ve updated your knowledge sources and want to ensure that the agents are using the most recent information.
[](#agent-specific-knowledge)
Agent-Specific Knowledge
----------------------------------------------------------
While knowledge can be provided at the crew level using `crew.knowledge_sources`, individual agents can also have their own knowledge sources using the `knowledge_sources` parameter:
Code
from crewai import Agent, Task, Crew
from crewai.knowledge.source.string_knowledge_source import StringKnowledgeSource
# Create agent-specific knowledge about a product
product_specs = StringKnowledgeSource(
content="""The XPS 13 laptop features:
- 13.4-inch 4K display
- Intel Core i7 processor
- 16GB RAM
- 512GB SSD storage
- 12-hour battery life""",
metadata={"category": "product_specs"}
)
# Create a support agent with product knowledge
support_agent = Agent(
role="Technical Support Specialist",
goal="Provide accurate product information and support.",
backstory="You are an expert on our laptop products and specifications.",
knowledge_sources=[product_specs] # Agent-specific knowledge
)
# Create a task that requires product knowledge
support_task = Task(
description="Answer this customer question: {question}",
agent=support_agent
)
# Create and run the crew
crew = Crew(
agents=[support_agent],
tasks=[support_task]
)
# Get answer about the laptop's specifications
result = crew.kickoff(
inputs={"question": "What is the storage capacity of the XPS 13?"}
)
Benefits of agent-specific knowledge:
* Give agents specialized information for their roles
* Maintain separation of concerns between agents
* Combine with crew-level knowledge for layered information access
[](#custom-knowledge-sources)
Custom Knowledge Sources
----------------------------------------------------------
CrewAI allows you to create custom knowledge sources for any type of data by extending the `BaseKnowledgeSource` class. Let’s create a practical example that fetches and processes space news articles.
####
[](#space-news-knowledge-source-example)
Space News Knowledge Source Example
Code
Output
from crewai import Agent, Task, Crew, Process, LLM
from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
import requests
from datetime import datetime
from typing import Dict, Any
from pydantic import BaseModel, Field
class SpaceNewsKnowledgeSource(BaseKnowledgeSource):
"""Knowledge source that fetches data from Space News API."""
api_endpoint: str = Field(description="API endpoint URL")
limit: int = Field(default=10, description="Number of articles to fetch")
def load_content(self) -> Dict[Any, str]:
"""Fetch and format space news articles."""
try:
response = requests.get(
f"{self.api_endpoint}?limit={self.limit}"
)
response.raise_for_status()
data = response.json()
articles = data.get('results', [])
formatted_data = self._format_articles(articles)
return {self.api_endpoint: formatted_data}
except Exception as e:
raise ValueError(f"Failed to fetch space news: {str(e)}")
def _format_articles(self, articles: list) -> str:
"""Format articles into readable text."""
formatted = "Space News Articles:\n\n"
for article in articles:
formatted += f"""
Title: {article['title']}
Published: {article['published_at']}
Summary: {article['summary']}
News Site: {article['news_site']}
URL: {article['url']}
-------------------"""
return formatted
def add(self) -> None:
"""Process and store the articles."""
content = self.load_content()
for _, text in content.items():
chunks = self._chunk_text(text)
self.chunks.extend(chunks)
self._save_documents()
# Create knowledge source
recent_news = SpaceNewsKnowledgeSource(
api_endpoint="https://api.spaceflightnewsapi.net/v4/articles",
limit=10,
)
# Create specialized agent
space_analyst = Agent(
role="Space News Analyst",
goal="Answer questions about space news accurately and comprehensively",
backstory="""You are a space industry analyst with expertise in space exploration,
satellite technology, and space industry trends. You excel at answering questions
about space news and providing detailed, accurate information.""",
knowledge_sources=[recent_news],
llm=LLM(model="gpt-4", temperature=0.0)
)
# Create task that handles user questions
analysis_task = Task(
description="Answer this question about space news: {user_question}",
expected_output="A detailed answer based on the recent space news articles",
agent=space_analyst
)
# Create and run the crew
crew = Crew(
agents=[space_analyst],
tasks=[analysis_task],
verbose=True,
process=Process.sequential
)
# Example usage
result = crew.kickoff(
inputs={"user_question": "What are the latest developments in space exploration?"}
)
####
[](#key-components-explained)
Key Components Explained
1. **Custom Knowledge Source (`SpaceNewsKnowledgeSource`)**:
* Extends `BaseKnowledgeSource` for integration with CrewAI
* Configurable API endpoint and article limit
* Implements three key methods:
* `load_content()`: Fetches articles from the API
* `_format_articles()`: Structures the articles into readable text
* `add()`: Processes and stores the content
2. **Agent Configuration**:
* Specialized role as a Space News Analyst
* Uses the knowledge source to access space news
3. **Task Setup**:
* Takes a user question as input through `{user_question}`
* Designed to provide detailed answers based on the knowledge source
4. **Crew Orchestration**:
* Manages the workflow between agent and task
* Handles input/output through the kickoff method
This example demonstrates how to:
* Create a custom knowledge source that fetches real-time data
* Process and format external data for AI consumption
* Use the knowledge source to answer specific user questions
* Integrate everything seamlessly with CrewAI’s agent system
####
[](#about-the-spaceflight-news-api)
About the Spaceflight News API
The example uses the [Spaceflight News API](https://api.spaceflightnewsapi.net/v4/docs/)
, which:
* Provides free access to space-related news articles
* Requires no authentication
* Returns structured data about space news
* Supports pagination and filtering
You can customize the API query by modifying the endpoint URL:
# Fetch more articles
recent_news = SpaceNewsKnowledgeSource(
api_endpoint="https://api.spaceflightnewsapi.net/v4/articles",
limit=20, # Increase the number of articles
)
# Add search parameters
recent_news = SpaceNewsKnowledgeSource(
api_endpoint="https://api.spaceflightnewsapi.net/v4/articles?search=NASA", # Search for NASA news
limit=10,
)
[](#best-practices)
Best Practices
--------------------------------------
Content Organization
* Keep chunk sizes appropriate for your content type
* Consider content overlap for context preservation
* Organize related information into separate knowledge sources
Performance Tips
* Adjust chunk sizes based on content complexity
* Configure appropriate embedding models
* Consider using local embedding providers for faster processing
Was this page helpful?
YesNo
[Flows](/concepts/flows)
[LLMs](/concepts/llms)
On this page
* [What is Knowledge?](#what-is-knowledge%3F)
* [Supported Knowledge Sources](#supported-knowledge-sources)
* [Supported Knowledge Parameters](#supported-knowledge-parameters)
* [Quickstart Example](#quickstart-example)
* [More Examples](#more-examples)
* [Text File Knowledge Source](#text-file-knowledge-source)
* [PDF Knowledge Source](#pdf-knowledge-source)
* [CSV Knowledge Source](#csv-knowledge-source)
* [Excel Knowledge Source](#excel-knowledge-source)
* [JSON Knowledge Source](#json-knowledge-source)
* [Knowledge Configuration](#knowledge-configuration)
* [Chunking Configuration](#chunking-configuration)
* [Embeddings Configuration](#embeddings-configuration)
* [Clearing Knowledge](#clearing-knowledge)
* [Agent-Specific Knowledge](#agent-specific-knowledge)
* [Custom Knowledge Sources](#custom-knowledge-sources)
* [Space News Knowledge Source Example](#space-news-knowledge-source-example)
* [Key Components Explained](#key-components-explained)
* [About the Spaceflight News API](#about-the-spaceflight-news-api)
* [Best Practices](#best-practices)
---
# Training - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Core Concepts
Training
[Get Started](/introduction)
[Examples](/examples/example)
[](#introduction)
Introduction
----------------------------------
The training feature in CrewAI allows you to train your AI agents using the command-line interface (CLI). By running the command `crewai train -n `, you can specify the number of iterations for the training process.
During training, CrewAI utilizes techniques to optimize the performance of your agents along with human feedback. This helps the agents improve their understanding, decision-making, and problem-solving abilities.
###
[](#training-your-crew-using-the-cli)
Training Your Crew Using the CLI
To use the training feature, follow these steps:
1. Open your terminal or command prompt.
2. Navigate to the directory where your CrewAI project is located.
3. Run the following command:
crewai train -n (optional)
Replace `` with the desired number of training iterations and `` with the appropriate filename ending with `.pkl`.
###
[](#training-your-crew-programmatically)
Training Your Crew Programmatically
To train your crew programmatically, use the following steps:
1. Define the number of iterations for training.
2. Specify the input parameters for the training process.
3. Execute the training command within a try-except block to handle potential errors.
Code
n_iterations = 2
inputs = {"topic": "CrewAI Training"}
filename = "your_model.pkl"
try:
YourCrewName_Crew().crew().train(
n_iterations=n_iterations,
inputs=inputs,
filename=filename
)
except Exception as e:
raise Exception(f"An error occurred while training the crew: {e}")
###
[](#key-points-to-note)
Key Points to Note
* **Positive Integer Requirement:** Ensure that the number of iterations (`n_iterations`) is a positive integer. The code will raise a `ValueError` if this condition is not met.
* **Filename Requirement:** Ensure that the filename ends with `.pkl`. The code will raise a `ValueError` if this condition is not met.
* **Error Handling:** The code handles subprocess errors and unexpected exceptions, providing error messages to the user.
It is important to note that the training process may take some time, depending on the complexity of your agents and will also require your feedback on each iteration.
Once the training is complete, your agents will be equipped with enhanced capabilities and knowledge, ready to tackle complex tasks and provide more consistent and valuable insights.
Remember to regularly update and retrain your agents to ensure they stay up-to-date with the latest information and advancements in the field.
Happy training with CrewAI! 🚀
Was this page helpful?
YesNo
[Collaboration](/concepts/collaboration)
[Memory](/concepts/memory)
On this page
* [Introduction](#introduction)
* [Training Your Crew Using the CLI](#training-your-crew-using-the-cli)
* [Training Your Crew Programmatically](#training-your-crew-programmatically)
* [Key Points to Note](#key-points-to-note)
---
# CLI - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Core Concepts
CLI
[Get Started](/introduction)
[Examples](/examples/example)
[](#crewai-cli-documentation)
CrewAI CLI Documentation
==========================================================
The CrewAI CLI provides a set of commands to interact with CrewAI, allowing you to create, train, run, and manage crews & flows.
[](#installation)
Installation
----------------------------------
To use the CrewAI CLI, make sure you have CrewAI installed:
Terminal
pip install crewai
[](#basic-usage)
Basic Usage
--------------------------------
The basic structure of a CrewAI CLI command is:
Terminal
crewai [COMMAND] [OPTIONS] [ARGUMENTS]
[](#available-commands)
Available Commands
----------------------------------------------
###
[](#1-create)
1\. Create
Create a new crew or flow.
Terminal
crewai create [OPTIONS] TYPE NAME
* `TYPE`: Choose between “crew” or “flow”
* `NAME`: Name of the crew or flow
Example:
Terminal
crewai create crew my_new_crew
crewai create flow my_new_flow
###
[](#2-version)
2\. Version
Show the installed version of CrewAI.
Terminal
crewai version [OPTIONS]
* `--tools`: (Optional) Show the installed version of CrewAI tools
Example:
Terminal
crewai version
crewai version --tools
###
[](#3-train)
3\. Train
Train the crew for a specified number of iterations.
Terminal
crewai train [OPTIONS]
* `-n, --n_iterations INTEGER`: Number of iterations to train the crew (default: 5)
* `-f, --filename TEXT`: Path to a custom file for training (default: “trained\_agents\_data.pkl”)
Example:
Terminal
crewai train -n 10 -f my_training_data.pkl
###
[](#4-replay)
4\. Replay
Replay the crew execution from a specific task.
Terminal
crewai replay [OPTIONS]
* `-t, --task_id TEXT`: Replay the crew from this task ID, including all subsequent tasks
Example:
Terminal
crewai replay -t task_123456
###
[](#5-log-tasks-outputs)
5\. Log-tasks-outputs
Retrieve your latest crew.kickoff() task outputs.
Terminal
crewai log-tasks-outputs
###
[](#6-reset-memories)
6\. Reset-memories
Reset the crew memories (long, short, entity, latest\_crew\_kickoff\_outputs).
Terminal
crewai reset-memories [OPTIONS]
* `-l, --long`: Reset LONG TERM memory
* `-s, --short`: Reset SHORT TERM memory
* `-e, --entities`: Reset ENTITIES memory
* `-k, --kickoff-outputs`: Reset LATEST KICKOFF TASK OUTPUTS
* `-a, --all`: Reset ALL memories
Example:
Terminal
crewai reset-memories --long --short
crewai reset-memories --all
###
[](#7-test)
7\. Test
Test the crew and evaluate the results.
Terminal
crewai test [OPTIONS]
* `-n, --n_iterations INTEGER`: Number of iterations to test the crew (default: 3)
* `-m, --model TEXT`: LLM Model to run the tests on the Crew (default: “gpt-4o-mini”)
Example:
Terminal
crewai test -n 5 -m gpt-3.5-turbo
###
[](#8-run)
8\. Run
Run the crew.
Terminal
crewai run
Make sure to run these commands from the directory where your CrewAI project is set up. Some commands may require additional configuration or setup within your project structure.
###
[](#9-chat)
9\. Chat
Starting in version `0.98.0`, when you run the `crewai chat` command, you start an interactive session with your crew. The AI assistant will guide you by asking for necessary inputs to execute the crew. Once all inputs are provided, the crew will execute its tasks.
After receiving the results, you can continue interacting with the assistant for further instructions or questions.
Terminal
crewai chat
Ensure you execute these commands from your CrewAI project’s root directory.
IMPORTANT: Set the `chat_llm` property in your `crew.py` file to enable this command.
@crew
def crew(self) -> Crew:
return Crew(
agents=self.agents,
tasks=self.tasks,
process=Process.sequential,
verbose=True,
chat_llm="gpt-4o", # LLM for chat orchestration
)
###
[](#10-api-keys)
10\. API Keys
When running `crewai create crew` command, the CLI will first show you the top 5 most common LLM providers and ask you to select one.
Once you’ve selected an LLM provider, you will be prompted for API keys.
####
[](#initial-api-key-providers)
Initial API key providers
The CLI will initially prompt for API keys for the following services:
* OpenAI
* Groq
* Anthropic
* Google Gemini
* SambaNova
When you select a provider, the CLI will prompt you to enter your API key.
####
[](#other-options)
Other Options
If you select option 6, you will be able to select from a list of LiteLLM supported providers.
When you select a provider, the CLI will prompt you to enter the Key name and the API key.
See the following link for each provider’s key name:
* [LiteLLM Providers](https://docs.litellm.ai/docs/providers)
Was this page helpful?
YesNo
[Testing](/concepts/testing)
[Tools](/concepts/tools)
On this page
* [CrewAI CLI Documentation](#crewai-cli-documentation)
* [Installation](#installation)
* [Basic Usage](#basic-usage)
* [Available Commands](#available-commands)
* [1\. Create](#1-create)
* [2\. Version](#2-version)
* [3\. Train](#3-train)
* [4\. Replay](#4-replay)
* [5\. Log-tasks-outputs](#5-log-tasks-outputs)
* [6\. Reset-memories](#6-reset-memories)
* [7\. Test](#7-test)
* [8\. Run](#8-run)
* [9\. Chat](#9-chat)
* [10\. API Keys](#10-api-keys)
* [Initial API key providers](#initial-api-key-providers)
* [Other Options](#other-options)
---
# Testing - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Core Concepts
Testing
[Get Started](/introduction)
[Examples](/examples/example)
[](#introduction)
Introduction
----------------------------------
Testing is a crucial part of the development process, and it is essential to ensure that your crew is performing as expected. With crewAI, you can easily test your crew and evaluate its performance using the built-in testing capabilities.
###
[](#using-the-testing-feature)
Using the Testing Feature
We added the CLI command `crewai test` to make it easy to test your crew. This command will run your crew for a specified number of iterations and provide detailed performance metrics. The parameters are `n_iterations` and `model`, which are optional and default to 2 and `gpt-4o-mini` respectively. For now, the only provider available is OpenAI.
crewai test
If you want to run more iterations or use a different model, you can specify the parameters like this:
crewai test --n_iterations 5 --model gpt-4o
or using the short forms:
crewai test -n 5 -m gpt-4o
When you run the `crewai test` command, the crew will be executed for the specified number of iterations, and the performance metrics will be displayed at the end of the run.
A table of scores at the end will show the performance of the crew in terms of the following metrics:
| Tasks/Crew/Agents | Run 1 | Run 2 | Avg. Total | Agents | Additional Info |
| --- | --- | --- | --- | --- | --- |
| Task 1 | 9.0 | 9.5 | **9.2** | Professional Insights | |
| | | | | Researcher | |
| Task 2 | 9.0 | 10.0 | **9.5** | Company Profile Investigator | |
| Task 3 | 9.0 | 9.0 | **9.0** | Automation Insights | |
| | | | | Specialist | |
| Task 4 | 9.0 | 9.0 | **9.0** | Final Report Compiler | Automation Insights Specialist |
| Crew | 9.00 | 9.38 | **9.2** | | |
| Execution Time (s) | 126 | 145 | **135** | | |
The example above shows the test results for two runs of the crew with two tasks, with the average total score for each task and the crew as a whole.
Was this page helpful?
YesNo
[Planning](/concepts/planning)
[CLI](/concepts/cli)
On this page
* [Introduction](#introduction)
* [Using the Testing Feature](#using-the-testing-feature)
---
# Using LangChain Tools - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Core Concepts
Using LangChain Tools
[Get Started](/introduction)
[Examples](/examples/example)
[](#using-langchain-tools)
Using LangChain Tools
----------------------------------------------------
CrewAI seamlessly integrates with LangChain’s comprehensive [list of tools](https://python.langchain.com/docs/integrations/tools/)
, all of which can be used with CrewAI.
Code
import os
from dotenv import load_dotenv
from crewai import Agent, Task, Crew
from crewai.tools import BaseTool
from pydantic import Field
from langchain_community.utilities import GoogleSerperAPIWrapper
# Set up your SERPER_API_KEY key in an .env file, eg:
# SERPER_API_KEY=
load_dotenv()
search = GoogleSerperAPIWrapper()
class SearchTool(BaseTool):
name: str = "Search"
description: str = "Useful for search-based queries. Use this to find current information about markets, companies, and trends."
search: GoogleSerperAPIWrapper = Field(default_factory=GoogleSerperAPIWrapper)
def _run(self, query: str) -> str:
"""Execute the search query and return results"""
try:
return self.search.run(query)
except Exception as e:
return f"Error performing search: {str(e)}"
# Create Agents
researcher = Agent(
role='Research Analyst',
goal='Gather current market data and trends',
backstory="""You are an expert research analyst with years of experience in
gathering market intelligence. You're known for your ability to find
relevant and up-to-date market information and present it in a clear,
actionable format.""",
tools=[SearchTool()],
verbose=True
)
# rest of the code ...
[](#conclusion)
Conclusion
------------------------------
Tools are pivotal in extending the capabilities of CrewAI agents, enabling them to undertake a broad spectrum of tasks and collaborate effectively. When building solutions with CrewAI, leverage both custom and existing tools to empower your agents and enhance the AI ecosystem. Consider utilizing error handling, caching mechanisms, and the flexibility of tool arguments to optimize your agents’ performance and capabilities.
Was this page helpful?
YesNo
[Tools](/concepts/tools)
[Using LlamaIndex Tools](/concepts/llamaindex-tools)
On this page
* [Using LangChain Tools](#using-langchain-tools)
* [Conclusion](#conclusion)
---
# Tools - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Core Concepts
Tools
[Get Started](/introduction)
[Examples](/examples/example)
[](#introduction)
Introduction
----------------------------------
CrewAI tools empower agents with capabilities ranging from web searching and data analysis to collaboration and delegating tasks among coworkers. This documentation outlines how to create, integrate, and leverage these tools within the CrewAI framework, including a new focus on collaboration tools.
[](#what-is-a-tool%3F)
What is a Tool?
------------------------------------------
A tool in CrewAI is a skill or function that agents can utilize to perform various actions. This includes tools from the [CrewAI Toolkit](https://github.com/joaomdmoura/crewai-tools)
and [LangChain Tools](https://python.langchain.com/docs/integrations/tools)
, enabling everything from simple searches to complex interactions and effective teamwork among agents.
[](#key-characteristics-of-tools)
Key Characteristics of Tools
------------------------------------------------------------------
* **Utility**: Crafted for tasks such as web searching, data analysis, content generation, and agent collaboration.
* **Integration**: Boosts agent capabilities by seamlessly integrating tools into their workflow.
* **Customizability**: Provides the flexibility to develop custom tools or utilize existing ones, catering to the specific needs of agents.
* **Error Handling**: Incorporates robust error handling mechanisms to ensure smooth operation.
* **Caching Mechanism**: Features intelligent caching to optimize performance and reduce redundant operations.
[](#using-crewai-tools)
Using CrewAI Tools
----------------------------------------------
To enhance your agents’ capabilities with crewAI tools, begin by installing our extra tools package:
pip install 'crewai[tools]'
Here’s an example demonstrating their use:
Code
import os
from crewai import Agent, Task, Crew
# Importing crewAI tools
from crewai_tools import (
DirectoryReadTool,
FileReadTool,
SerperDevTool,
WebsiteSearchTool
)
# Set up API keys
os.environ["SERPER_API_KEY"] = "Your Key" # serper.dev API key
os.environ["OPENAI_API_KEY"] = "Your Key"
# Instantiate tools
docs_tool = DirectoryReadTool(directory='./blog-posts')
file_tool = FileReadTool()
search_tool = SerperDevTool()
web_rag_tool = WebsiteSearchTool()
# Create 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
)
# Define 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 formatted in markdown with engaging, informative, and accessible content, avoiding complex jargon.',
agent=writer,
output_file='blog-posts/new_post.md' # The final blog post will be saved here
)
# Assemble a crew with planning enabled
crew = Crew(
agents=[researcher, writer],
tasks=[research, write],
verbose=True,
planning=True, # Enable planning feature
)
# Execute tasks
crew.kickoff()
[](#available-crewai-tools)
Available CrewAI Tools
------------------------------------------------------
* **Error Handling**: All tools are built with error handling capabilities, allowing agents to gracefully manage exceptions and continue their tasks.
* **Caching Mechanism**: All tools support caching, enabling agents to efficiently reuse previously obtained results, reducing the load on external resources and speeding up the execution time. You can also define finer control over the caching mechanism using the `cache_function` attribute on the tool.
Here is a list of the available tools and their descriptions:
| Tool | Description |
| --- | --- |
| **BrowserbaseLoadTool** | A tool for interacting with and extracting data from web browsers. |
| **CodeDocsSearchTool** | A RAG tool optimized for searching through code documentation and related technical documents. |
| **CodeInterpreterTool** | A tool for interpreting python code. |
| **ComposioTool** | Enables use of Composio tools. |
| **CSVSearchTool** | A RAG tool designed for searching within CSV files, tailored to handle structured data. |
| **DALL-E Tool** | A tool for generating images using the DALL-E API. |
| **DirectorySearchTool** | A RAG tool for searching within directories, useful for navigating through file systems. |
| **DOCXSearchTool** | A RAG tool aimed at searching within DOCX documents, ideal for processing Word files. |
| **DirectoryReadTool** | Facilitates reading and processing of directory structures and their contents. |
| **EXASearchTool** | A tool designed for performing exhaustive searches across various data sources. |
| **FileReadTool** | Enables reading and extracting data from files, supporting various file formats. |
| **FirecrawlSearchTool** | A tool to search webpages using Firecrawl and return the results. |
| **FirecrawlCrawlWebsiteTool** | A tool for crawling webpages using Firecrawl. |
| **FirecrawlScrapeWebsiteTool** | A tool for scraping webpages URL using Firecrawl and returning its contents. |
| **GithubSearchTool** | A RAG tool for searching within GitHub repositories, useful for code and documentation search. |
| **SerperDevTool** | A specialized tool for development purposes, with specific functionalities under development. |
| **TXTSearchTool** | A RAG tool focused on searching within text (.txt) files, suitable for unstructured data. |
| **JSONSearchTool** | A RAG tool designed for searching within JSON files, catering to structured data handling. |
| **LlamaIndexTool** | Enables the use of LlamaIndex tools. |
| **MDXSearchTool** | A RAG tool tailored for searching within Markdown (MDX) files, useful for documentation. |
| **PDFSearchTool** | A RAG tool aimed at searching within PDF documents, ideal for processing scanned documents. |
| **PGSearchTool** | A RAG tool optimized for searching within PostgreSQL databases, suitable for database queries. |
| **Vision Tool** | A tool for generating images using the DALL-E API. |
| **RagTool** | A general-purpose RAG tool capable of handling various data sources and types. |
| **ScrapeElementFromWebsiteTool** | Enables scraping specific elements from websites, useful for targeted data extraction. |
| **ScrapeWebsiteTool** | Facilitates scraping entire websites, ideal for comprehensive data collection. |
| **WebsiteSearchTool** | A RAG tool for searching website content, optimized for web data extraction. |
| **XMLSearchTool** | A RAG tool designed for searching within XML files, suitable for structured data formats. |
| **YoutubeChannelSearchTool** | A RAG tool for searching within YouTube channels, useful for video content analysis. |
| **YoutubeVideoSearchTool** | A RAG tool aimed at searching within YouTube videos, ideal for video data extraction. |
[](#creating-your-own-tools)
Creating your own Tools
--------------------------------------------------------
Developers can craft `custom tools` tailored for their agent’s needs or utilize pre-built options.
There are two main ways for one to create a CrewAI tool:
###
[](#subclassing-basetool)
Subclassing `BaseTool`
Code
from crewai.tools import BaseTool
from pydantic import BaseModel, Field
class MyToolInput(BaseModel):
"""Input schema for MyCustomTool."""
argument: str = Field(..., description="Description of the argument.")
class MyCustomTool(BaseTool):
name: str = "Name of my 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's logic here
return "Tool's result"
###
[](#utilizing-the-tool-decorator)
Utilizing the `tool` Decorator
Code
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, your agent will need this information to use it."""
# Function logic here
return "Result from your custom tool"
###
[](#structured-tools)
Structured Tools
The `StructuredTool` class wraps functions as tools, providing flexibility and validation while reducing boilerplate. It supports custom schemas and dynamic logic for seamless integration of complex functionalities.
####
[](#example%3A)
Example:
Using `StructuredTool.from_function`, you can wrap a function that interacts with an external API or system, providing a structured interface. This enables robust validation and consistent execution, making it easier to integrate complex functionalities into your applications as demonstrated in the following example:
from crewai.tools.structured_tool import CrewStructuredTool
from pydantic import BaseModel
# Define the schema for the tool's input using Pydantic
class APICallInput(BaseModel):
endpoint: str
parameters: dict
# Wrapper function to execute the API call
def tool_wrapper(*args, **kwargs):
# Here, you would typically call the API using the parameters
# For demonstration, we'll return a placeholder string
return f"Call the API at {kwargs['endpoint']} with parameters {kwargs['parameters']}"
# Create and return the structured tool
def create_structured_tool():
return CrewStructuredTool.from_function(
name='Wrapper API',
description="A tool to wrap API calls with structured input.",
args_schema=APICallInput,
func=tool_wrapper,
)
# Example usage
structured_tool = create_structured_tool()
# Execute the tool with structured input
result = structured_tool._run(**{
"endpoint": "https://example.com/api",
"parameters": {"key1": "value1", "key2": "value2"}
})
print(result) # Output: Call the API at https://example.com/api with parameters {'key1': 'value1', 'key2': 'value2'}
###
[](#custom-caching-mechanism)
Custom Caching Mechanism
Tools can optionally implement a `cache_function` to fine-tune caching behavior. This function determines when to cache results based on specific conditions, offering granular control over caching logic.
Code
from crewai.tools import tool
@tool
def multiplication_tool(first_number: int, second_number: int) -> str:
"""Useful for when you need to multiply two numbers together."""
return first_number * second_number
def cache_func(args, result):
# In this case, we only cache the result if it's a multiple of 2
cache = result % 2 == 0
return cache
multiplication_tool.cache_function = cache_func
writer1 = 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,
)
#...
[](#conclusion)
Conclusion
------------------------------
Tools are pivotal in extending the capabilities of CrewAI agents, enabling them to undertake a broad spectrum of tasks and collaborate effectively. When building solutions with CrewAI, leverage both custom and existing tools to empower your agents and enhance the AI ecosystem. Consider utilizing error handling, caching mechanisms, and the flexibility of tool arguments to optimize your agents’ performance and capabilities.
Was this page helpful?
YesNo
[CLI](/concepts/cli)
[Using LangChain Tools](/concepts/langchain-tools)
On this page
* [Introduction](#introduction)
* [What is a Tool?](#what-is-a-tool%3F)
* [Key Characteristics of Tools](#key-characteristics-of-tools)
* [Using CrewAI Tools](#using-crewai-tools)
* [Available CrewAI Tools](#available-crewai-tools)
* [Creating your own Tools](#creating-your-own-tools)
* [Subclassing BaseTool](#subclassing-basetool)
* [Utilizing the tool Decorator](#utilizing-the-tool-decorator)
* [Structured Tools](#structured-tools)
* [Example:](#example%3A)
* [Custom Caching Mechanism](#custom-caching-mechanism)
* [Conclusion](#conclusion)
---
# Using LlamaIndex Tools - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
Core Concepts
Using LlamaIndex Tools
[Get Started](/introduction)
[Examples](/examples/example)
[](#using-llamaindex-tools)
Using LlamaIndex Tools
------------------------------------------------------
CrewAI seamlessly integrates with LlamaIndex’s comprehensive toolkit for RAG (Retrieval-Augmented Generation) and agentic pipelines, enabling advanced search-based queries and more.
Here are the available built-in tools offered by LlamaIndex.
Code
from crewai import Agent
from crewai_tools import LlamaIndexTool
# Example 1: Initialize from FunctionTool
from llama_index.core.tools import FunctionTool
your_python_function = lambda ...: ...
og_tool = FunctionTool.from_defaults(
your_python_function,
name="",
description=''
)
tool = LlamaIndexTool.from_tool(og_tool)
# Example 2: Initialize from LlamaHub Tools
from llama_index.tools.wolfram_alpha import WolframAlphaToolSpec
wolfram_spec = WolframAlphaToolSpec(app_id="")
wolfram_tools = wolfram_spec.to_tool_list()
tools = [LlamaIndexTool.from_tool(t) for t in wolfram_tools]
# Example 3: Initialize Tool from a LlamaIndex Query Engine
query_engine = index.as_query_engine()
query_tool = LlamaIndexTool.from_query_engine(
query_engine,
name="Uber 2019 10K Query Tool",
description="Use this tool to lookup the 2019 Uber 10K Annual Report"
)
# Create and assign the tools to an agent
agent = Agent(
role='Research Analyst',
goal='Provide up-to-date market analysis',
backstory='An expert analyst with a keen eye for market trends.',
tools=[tool, *tools, query_tool]
)
# rest of the code ...
[](#steps-to-get-started)
Steps to Get Started
--------------------------------------------------
To effectively use the LlamaIndexTool, follow these steps:
1
Package Installation
Make sure that `crewai[tools]` package is installed in your Python environment:
Terminal
pip install 'crewai[tools]'
2
Install and Use LlamaIndex
Follow the LlamaIndex documentation [LlamaIndex Documentation](https://docs.llamaindex.ai/)
to set up a RAG/agent pipeline.
Was this page helpful?
YesNo
[Using LangChain Tools](/concepts/langchain-tools)
[Create Custom Tools](/how-to/create-custom-tools)
On this page
* [Using LlamaIndex Tools](#using-llamaindex-tools)
* [Steps to Get Started](#steps-to-get-started)
---
# Create Custom Tools - CrewAI
[CrewAI home page](/)
Search CrewAI docs
Search...
Navigation
How to Guides
Create Custom Tools
[Get Started](/introduction)
[Examples](/examples/example)
[](#creating-and-utilizing-tools-in-crewai)
Creating and Utilizing Tools in CrewAI
--------------------------------------------------------------------------------------
This guide provides detailed instructions on creating custom tools for the CrewAI framework and how to efficiently manage and utilize these tools, incorporating the latest functionalities such as tool delegation, error handling, and dynamic tool calling. It also highlights the importance of collaboration tools, enabling agents to perform a wide range of actions.
###
[](#subclassing-basetool)
Subclassing `BaseTool`
To create a personalized tool, inherit from `BaseTool` and define the necessary attributes, including the `args_schema` for input validation, and the `_run` method.
Code
from typing import Type
from crewai.tools import BaseTool
from pydantic import BaseModel, Field
class MyToolInput(BaseModel):
"""Input schema for MyCustomTool."""
argument: str = Field(..., description="Description of the argument.")
class MyCustomTool(BaseTool):
name: str = "Name of my 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's logic here
return "Tool's result"
###
[](#using-the-tool-decorator)
Using the `tool` Decorator
Alternatively, you can use the tool decorator `@tool`. This approach allows you to define the tool’s attributes and functionality directly within a function, offering a concise and efficient way to create specialized tools tailored to your needs.
Code
from crewai.tools import tool
@tool("Tool Name")
def my_simple_tool(question: str) -> str:
"""Tool description for clarity."""
# Tool logic here
return "Tool output"
###
[](#defining-a-cache-function-for-the-tool)
Defining a Cache Function for the Tool
To optimize tool performance with caching, define custom caching strategies using the `cache_function` attribute.
Code
@tool("Tool with Caching")
def cached_tool(argument: str) -> str:
"""Tool functionality description."""
return "Cacheable result"
def my_cache_strategy(arguments: dict, result: str) -> bool:
# Define custom caching logic
return True if some_condition else False
cached_tool.cache_function = my_cache_strategy
By adhering to these guidelines and incorporating new functionalities and collaboration tools into your tool creation and management processes, you can leverage the full capabilities of the CrewAI framework, enhancing both the development experience and the efficiency of your AI agents.
Was this page helpful?
YesNo
[Using LlamaIndex Tools](/concepts/llamaindex-tools)
[Sequential Processes](/how-to/sequential-process)
On this page
* [Creating and Utilizing Tools in CrewAI](#creating-and-utilizing-tools-in-crewai)
* [Subclassing BaseTool](#subclassing-basetool)
* [Using the tool Decorator](#using-the-tool-decorator)
* [Defining a Cache Function for the Tool](#defining-a-cache-function-for-the-tool)
---