​
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.

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.

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 2024.
  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:

8

Lock and install the dependencies

Lock the dependencies and install them by using the CLI command but first, navigate to your project directory:

9

Run your crew

To run your crew, execute the following command in the root of your project:

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:

​
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

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: mixtal_llm

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:

Here are examples of how to use each annotation in your CrewAI project, and when you should use them:

​
@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
    )

​
@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"
    )

​
@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
    )

​
@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)]

​
@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

​
@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

​
@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)

​
@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

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 <task_id>

Replace <task_id> with the ID of the task you want to replay.

​
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

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.

Join the Community

Join our open source community to discuss ideas, share your projects, and connect with other CrewAI developers.

Was this page helpful?

InstallationAgents