In this post, I will cover:

• What are AI Agents?
• What is a Multi AI-Agent system?
• What is CrewAI?
• AI Agent using CrewAI.
• Creating a Project with CrewAI.
• Practical: Writing a Person’s Biography.

What are AI Agents?

An AI Agent is essentially an LLM (Large Language Model) with access to Tools. These Tools allow the Agent to interact with the external world, performing Tasks such as web searches, web scraping, using APIs, among others.

When given a specific Task, the Agent can decide whether and how to use the available Tools to achieve its goal. In the future, I will cover more details about Tools in another post.

What is a Multi AI-Agent system?

In a Multi AI-Agent system, two or more Agents cooperate to achieve a final goal. This system can be orchestrated in different ways, with three of the most common being: Sequential, Hierarchical, and Hybrid.

• Sequential Process: Tasks are executed linearly, meaning one after another. Imagine you want to generate a Marketing Email for a Lead. You can create three Agents and run them in sequence:
  1. The first Agent researches the Lead.
  2. The second Agent generates a summary based on the research.
  3. A third Agent writes the Email using the summary.
• Hierarchical Process: One Agent acts as a Manager, supervising and delegating improvements for each Task executed by the other Agents. Applying the same example above:
  1. The Manager reviews the research done by the first Agent, suggesting improvements or approving the task.
  2. Next, they review the summary generated by the second Agent, also suggesting adjustments or approving it.
  3. Finally, they evaluate the email created by the third agent, ensuring it is suitable before finalizing.
• Hybrid Process: It is the combination of both approaches, meaning you can use either the Sequential or the Hierarchical process as needed.

What is CrewAI?

CrewAI is a Python framework that simplifies the creation of Multi AI-Agent systems. One of its main advantages is its ease of use and the wide range of available Tools.

Additionally, CrewAI provides caching and memory layers, support for Agent training and testing, Flows creation, and many other features. This means that when developing a Multi AI-Agent system with this platform, you don’t need to worry about these complexities.

AI Agent using CrewAI

To create an AI Agent in CrewAI, you need to define a Role, a Goal, and a Backstory.

• Role: The Agent’s function and responsibility.
• Goal: The goal the Agent must achieve.
• Backstory: The Agent’s historical context and experiences.

In addition to creating the Agent itself, it’s necessary to define the Task the Agent will perform. In CrewAI, every task needs to have a Description, the Expected Output, and the Agent responsible for executing it.

When your Agents and Tasks are defined, you can build a Crew. A Crew combines all the Agents and Tasks and executes them according to the defined process type—sequential, hierarchical, among others.

Now, let’s get our hands dirty! 🚀

Creating a Project with CrewAI

To install CrewAI and the Tools, use the following command in the terminal:

pip install crewai crewai-tools

To create a base project with CrewAI, use the following command:

crewai create crew <crew_name>

When you run this command in the terminal, you will need to select the provider (OpenAI, Anthropic, Gemini, among others) and one of the LLM models from the chosen provider. If the selected options require an API Key, you can provide it directly in the terminal.

After creating the project, CrewAI takes care of setting up the entire structure for you. The image below illustrates the structure created for the project I created, called biography.

• config/: contains YAML files with the definitions of Agents and Tasks.
• tools/: contains the custom_tool.py file where you can create custom Tools.
• crew.py: file where you actually create your Agents, Tasks, and group them into a Crew.
• main.py: main file for running your application.

Let’s dive into a practical example 🚀, where I will detail the creation of a Multi AI-Agent system.

Practical: Writing a Person’s Biography.

For this system, two Agents were created: a writer and a biographer. As mentioned in the previous section, these Agents are defined in the agents.yaml file, located in the config folder. In the file, the placeholder {person} is used, which will be replaced by the value provided—in this case, Lionel Messi, as part of our practical example. This same concept of placeholders applies to the YAML file for the Tasks as well. Below is the YAML file content for the Agents.

writer:
  role: >
    Specialist Writer
  goal: >
    Generate a summary containing detailed information about {person}.
  backstory: >
    You are a highly skilled professional with over 10 years of experience, 
    specialized in creating detailed summaries about individuals. Your goal is 
    to provide accurate and well-structured content, gathering relevant 
    information in a clear and concise manner, adapting to the context and needs.

specialist_biographer:
  role: >
    Specialist Biographer
  goal: >
    Generate a complete and well-structured biography about {person}, including 
    their main achievements, experiences, and milestones.
  backstory: >
    You are a professional with extensive experience in creating detailed 
    biographies that capture the essence and journey of a person. You use 
    reliable sources and in-depth research techniques to gather information 
    about key achievements, experiences, and life milestones. With a refined 
    ability to structure clear and engaging narratives, your goal is to present 
    a comprehensive and accurate view of each individual, highlighting their 
    contributions and impact over time.

Each Agent will perform a Task. Two Tasks have been defined: write and biography. The Tasks are specified in the tasks.yaml file, located in the config folder. Below is the YAML file content for the tasks.

write_task:
  description: >
    Your goal is to generate a detailed summary about {person}, covering as many 
    of the following topics as possible:

    - Full name, date of birth, and place of residence.
    - Main academic qualifications and educational institutions attended.
    - Key jobs, positions held, companies or organizations, career milestones.
    - Awards, publications, significant achievements.
    - Important projects or contributions in specific fields.
    - Influence in their field, lasting contributions.
    - Information about hobbies, interests, social or cultural activities.
    - Notable quotes or relevant interviews.

    Important: Search the internet for information you do not know about {person} 
    or to update your knowledge about them.
  expected_output: >
    A clear summary containing as many of the listed topics as possible.

    Return only the summary, without additional information.
  agent: writer

biography_task:
  description: >
    Using the summary of {person} provided by the Specialist Researcher, 
    generate a complete biography. Use the collected information to create a 
    cohesive and well-structured text that covers all relevant aspects of 
    {person}'s life and career. The goal is to produce a detailed biography, 
    highlighting their achievements, experiences, impact in their field, 
    significant contributions, as well as personal aspects that help build a 
    complete picture of the person. The biography should be clear, objective, 
    and well-organized, without redundancies.

    Important: Topics for which you have no information should not be created, 
    as you must not make assumptions.
  expected_output: >
    A clear, objective, and well-organized biography in markdown format.

    Return only the biography, without additional information and without 
    including '```' or '```markdown' or any other code block.
  agent: specialist_biographer

The crew.py file is responsible for creating and structuring Agents and Tasks, ensuring their execution in CrewAI. This file contains the Biography class, which defines functions to configure Agents, Tasks, and the Crew. Below are the key elements of this file and their functions:

• Using YAML files: The config parameter is used to reference Agents and Tasks defined in YAML files.
• Agent creation: The @agent decorator is applied to methods responsible for creating Agents, which return Agent objects.
• Task definition: The @task decorator is used on methods that create Tasks, which return Task objects.
• Crew structuring: A crew method is created to group Agents and Tasks, using the @crew decorator, which returns a Crew object. The chosen process is Sequential, and the order in which Tasks are created in the code is crucial to ensuring correct execution, making sure each Task is processed at the right time.
• Verbose mode (verbose): Allows visualizing the Agent’s thought process during execution, including its decisions, Tool usage, and reasoning flow.
• Tool usage: The writer Agent uses the SerperDevTool to perform internet searches. I will discuss tools in more detail in another post.
• File generation: The biography creation Task includes the output_file parameter, which allows saving the final result in a Markdown file.

Abaixo está o código do arquivo crew.py:

from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from crewai_tools import SerperDevTool
from dotenv import load_dotenv

load_dotenv()


@CrewBase
class Biography():

    agents_config = 'config/agents.yaml'
    tasks_config = 'config/tasks.yaml'

    @agent
    def writer(self) -> Agent:

        return Agent(
            config=self.agents_config['writer'],
            tools=[SerperDevTool()],
            verbose=True
        )
    

    @agent
    def specialist_biographer(self) -> Agent:

        return Agent(
            config=self.agents_config['specialist_biographer'],
            verbose=True
        )


    @task
    def write_task(self) -> Task:

        return Task(
            config=self.tasks_config['write_task']
        )
    

    @task
    def biography_task(self) -> Task:

        return Task(
            config=self.tasks_config['biography_task'],
            output_file='biography.md'
        )


    @crew
    def crew(self) -> Crew:

        return Crew(
            agents=self.agents,
            tasks=self.tasks,
            process=Process.sequential,
            verbose=True
        )

Finally, the main.py file is responsible for executing the process. The inputs variable, which is a dictionary, is necessary because, in the YAML files for the Agents and Tasks, the key {person} acts as a placeholder, being replaced by the corresponding value from the dictionary, which in this case is Lionel Messi. To start the process, the kickoff() method of the crew function in the Biography class is used.

Even though the process saves the results in a Markdown file, I decided to return this result to a variable and print it with the raw method, just as additional information. It’s important to note that all of this was defined inside a function called run(), which is then called for execution directly in the main.py file. Below is the code for the main.py file.

from crew import Biography
from warnings import filterwarnings

filterwarnings("ignore")


def run():

    inputs = {
        "person": "Lionel Messi"
    }

    results = Biography().crew().kickoff(
        inputs=inputs
    )

    print(results.raw)
    

if __name__ == "__main__":
    run()

Creating Multi AI-Agent systems has never been so easy and practical 🚀. Leave your thoughts in the comments!💬