Advanced AI Collaboration: Develop a Multi-Agent System with CrewAI

Advanced AI Collaboration: Developing a Multi-Agent System with CrewAI

Introduction
Hello! I'm Tommy, and we will navigate the advanced realm of Multi-Agent Systems, a topic that extends the capabilities of individual AI agents into powerful, cooperative units that can tackle complex, real-world problems.

In this guide, we'll explore how to coordinate multiple AI agents to solve complex tasks, emphasizing scalability, orchestration, and collaboration. Whether you're developing autonomous customer support systems or complex problem-solving applications, this tutorial will provide you with the tools and knowledge you need to succeed. Stick around to see it all come together with a hands-on implementation in Google Colab at the end!

Overview of Multi-Agent System and Framework

Multi-agent systems represent a significant leap from traditional AI paradigms. Instead of relying on a single AI entity to manage all tasks, Multi-Agent Systems allow for specialized agents, each designed for specific roles. This specialization enables more efficient processing, parallel task execution, and the ability to tackle more complex problems.

Benefits:

• Scalability: Each agent can be optimized and scaled independently, allowing the system to handle increasing workloads by adding more agents.
• Robustness: If one agent fails, others can continue functioning, providing a failover mechanism that enhances system reliability.
• Efficiency: Agents can work in parallel or hierarchy, speeding up the overall task completion time, particularly in scenarios where tasks are independent or can be broken down into smaller subtasks.
• Modularity: The modular nature of Multi-Agent Systems means that agents can be reused across different systems, reducing development time for new projects.

Challenges:

• Coordination Complexity: Ensuring that agents work together seamlessly can be difficult, especially as the number of agents increases.
• Communication Overhead: The need for agents to communicate adds overhead, particularly if they rely on different models or frameworks.
• Error Handling: Failures in one agent can propagate or cause issues in others, requiring sophisticated error-handling mechanisms.

Introduction to CrewAI

CrewAI is an excellent framework for managing and orchestrating multiple agents. It simplifies the complex concepts of Multi-Agent Systems into manageable structures, providing tools for building, deploying, and managing multi-agent systems in production environments.

Some key features of CrewAI include:

• Sequential, Parallel, and Hierarchical Task Execution: By default, tasks are processed sequentially, but CrewAI also supports parallel and hierarchical execution, which is crucial for large-scale systems.
• Custom Tool Integration: CrewAI allows developers to create and integrate custom tools tailored to specific agent tasks, enhancing the versatility and effectiveness of the system for their use case.
• Memory Management: CrewAI provides mechanisms for short-term, long-term, and entity memory, enabling agents to learn from past experiences and improve over time.
• Role-Based Agent Configuration: By focusing agents on specific roles and goals, CrewAI ensures that each agent is optimized for its task, improving overall system efficiency.

Setup and Dependencies

Before defining the agents, let's ensure that your environment is correctly set up. For this tutorial, we'll be using Google Colab. Follow these steps to install the necessary dependencies and set up your environment variables:

Install Dependencies:

Since we're working on Google Colab, installing dependencies is straightforward. We'll be using the crewai, crewai_tools, langchain_community, and pymongo packages. These libraries provide the core functionality for creating and managing AI agents, integrating external tools, and connecting to a MongoDB database.

The command above was run in a Google Colab notebook, but if you are running it locally, remove the exclamation mark (!) at the beginning.

Set Environment Variables:

Next, you'll need to set up your environment variables. For this tutorial, we'll use the gpt-3.5-turbo model from OpenAI, as it's widely accessible. If you have access to GPT-4, you can skip this step or modify the environment variable accordingly.

Add the following code to your Colab notebook:

Replace the placeholder values with your actual API keys and credentials. This setup allows your agents to interact with external services and databases securely.

Designing a Multi-Agent System

Designing a multi-agent system begins with clearly defining the roles and responsibilities of each agent. Let’s walk through a practical example: building a Customer Support System where different agents handle distinct tasks such as data retrieval, inquiry resolution, and quality assurance review.

STEP 1: Define the Agents

When creating AI agents, it's crucial to establish a strong mental framework. Start by asking yourself key questions that mirror the thought process of a manager:

• Goal Orientation: What is the agent's primary objective? What processes will the agent need to accomplish this goal effectively?
• Team Building Analogy: If this were a human task, what type of people would you hire to get the job done? Consider the roles and expertise needed, then map these qualities onto the AI agent's capabilities.

Each agent can run on a different language model (LLM) in a multi-agent system. Since we're using CrewAI for this tutorial, it's worth noting that agents can also integrate models from Hugging Face Hub. This flexibility lets you fine-tune the agents to meet specific needs, providing more customized responses.

For example, you can fine-tune models like phi-3, tinyLLama, or Llama-3 to better suit your use case. If you're unfamiliar with this process, you can refer to my previous tutorials on fine-tuning these models:

• Fine-tuning Phi-3
• Fine-tuning tinyllama
• Fine-tuning Llama-3

To use a model from Hugging Face Hub, you can load it into your agent as follows:

  # Load your custom model from Hugging Face Hub
  from huggingface_hub import from_pretrained
  model = from_pretrained('your_model')

Now, let’s look at a practical example of defining an agent for a specific role.

The first agent we’ll define is the Data Retrieval Specialist. This agent's main responsibility is to fetch all relevant information about a customer from the database, ensuring the support team has the data they need to provide accurate responses.

Understanding the Data Retrieval Agent

• role: Defined as a "Data Retrieval Specialist," focused on fetching data.
• goal: The agent's objective is to retrieve all relevant information about a customer from the database.
• backstory: Provides context, helping the agent understand its role within the broader system.
• allow_delegation: Set to False, meaning this agent will not delegate its tasks to others.
• verbose: Enables detailed logging of the agent's actions.

Next, we have the Senior Support Representative, whose goal is to provide the most friendly and helpful support using the data provided by the Data Retrieval Specialist.

Understanding the Support Agent

• role: Responsible for delivering exceptional customer support.
• goal: Aims to provide friendly and helpful support.
• backstory: Uses data from the Data Retrieval Specialist to assist the customer.
• allow_delegation: Set to False to keep the responsibility of the task within this agent.
• verbose: Detailed logging helps track performance.

Finally, we’ll create the Support Quality Assurance Specialist, who ensures that the support provided by the Senior Support Representative meets the highest standards.

Understanding the Support QA Agent

• role: Ensures the quality of support provided.
• goal: Achieve recognition for maintaining high support quality.
• backstory: Focuses on ensuring the Senior Support Representative's responses are thorough and accurate.
• verbose: Verbose logging is enabled to monitor activities.

Step 2: Define the Tasks

With our agents defined, the next step is to create the tasks they will perform. Tasks are central to how agents operate, providing a clear set of actions to be carried out using specific tools. The tools parameter is key, as it dictates which resources or utilities the agent will use to accomplish the task.

Key Elements of Effective Tools:

• Versatility: The tool should handle different inputs from the agent, adapting to various scenarios.
• Fault Tolerance: It should fail gracefully, either by querying further, sending error messages, or prompting specific input ranges.
• Caching: This prevents unnecessary repeated requests by using a cross-agent caching layer, optimizing efficiency.

Before we define the tasks, let's initialize the tools we'll use.

Tool Initialization

Tools can be built-in or custom-made, depending on the task's requirements. In this tutorial, we’ll use several tools, including DirectoryReadTool and FileReadTool for reading files from a specified directory, and a custom tool for database retrieval.

First, let's initialize the built-in tools:

  # Initialize built-in tools
  directory_read_tool = DirectoryReadTool()
  file_read_tool = FileReadTool()

Next, we’ll define a custom tool for retrieving data from a MongoDB database:

class MongoDBRetrievalTool:
    def __init__(self: Type[Self], mongo_uri: str) -> None:
        self.client = pymongo.MongoClient(mongo_uri)
        self.collection = self.client.your_database.your_collection

    def retrieve_data(self: Type[Self], customer_name: str):
        return self.collection.find_one({'name': customer_name})

Now, with our tools initialized, we can move on to defining the tasks.

Defining the Tasks

Tasks represent specific objectives that agents must achieve. Each task is defined by a description, an expected_output, the tools it will use, and the agent responsible for carrying out the task.

Data Retrieval Task

This task is assigned to our data_retrieval_agent, whose job is to gather all relevant information about the customer from the database. The data collected here will be crucial for addressing the customer's inquiry in subsequent tasks.

data_retrieval_task = Task(
    description="Gather all relevant {customer} data from the database, focusing on crucial information.",
    expected_output="A dataset containing all relevant information about the customer.",
    tools=[retrieval_tool],
    agent=data_retrieval_agent,
)

Inquiry Resolution Task

Once the data is retrieved, the support_agent will use this information to address the customer’s inquiry. This task involves searching through relevant files and generating a detailed response.

inquiry_resolution = Task(
    description="{customer} just reached out with an important ask: {inquiry}. Provide a clear and accurate response.",
    expected_output="A detailed response addressing all aspects of the customer's inquiry.",
    tools=[directory_read_tool, file_read_tool],
    agent=support_agent,
)

Quality Assurance Review Task

The support_quality_assurance_agent reviews the response generated by the support agent, ensuring that it meets high standards.

quality_assurance_review = Task(
    description="Review the response for {customer}'s inquiry. Ensure thoroughness and accuracy.",
    expected_output="A final response ready for the customer.",
    agent=support_quality_assurance_agent,
    output_file="response.md",
    human_input=True,
)

Step 3: Initialize the Crew

Now that we've defined our agents and tasks, it's time to bring everything together by initializing a Crew. The Crew is the central entity that manages the execution of tasks by the agents.

Process Options

The process parameter controls how tasks are executed by the crew:

• Sequential (Default): Tasks are performed one after the other.
• Hierarchical: One agent acts as a manager, delegating tasks to others.
• Parallel: Tasks are executed concurrently.

Memory Types

Memory enhances agents' ability to recall past interactions. The memory parameter, when set to True, activates various types of memory:

• Short Memory: Cleared after the crew finishes execution.
• Long Memory: Stores responses for future use.
• Entity Memory: Recognizes entities and provides contextual responses.

Here's how we initialize the crew:

crew = Crew(
    agents=[data_retrieval_agent, support_agent, support_quality_assurance_agent],
    tasks=[data_retrieval_task, inquiry_resolution, quality_assurance_review],
    verbose=2,
    memory=True,
)

Step 4: Kick Off the Crew

After initializing the crew, the next step is to kick it off by providing necessary inputs.

inputs = {
    "customer": "Tommy Ade",
    "inquiry": "How to fine-tune the Llama 3 model?"
}
crew.start(inputs)

Step 5: Reviewing the Crew's Execution

Once the kickoff method is invoked, the crew begins executing the tasks. The verbose setting ensures detailed logs are produced, showing how agents collaborate to achieve the goal.

You should see the Data Retrieval Specialist begin the retrieval task with logs and outputs. The agents will communicate and share information seamlessly.

Final Output in Markdown Format

After the crew completes all tasks, it generates the final result in a markdown format, useful for documentation purposes.

Since we set an output_file for our QA task, the file containing the response will be available in our current directory.

Generalizing Across Use Cases

Adaptation to Multiple Domains

While this tutorial focuses on customer support, the principles of multi-agent systems can be adapted to various industries, from supply chain management to personalized AI-driven services.

Modular and Reusable Design

Prioritize modularity in your system's design. Structure agents and interactions so that they can easily adapt or reuse in different projects.

Conclusion

In this tutorial, we've built a sophisticated multi-agent system using CrewAI, demonstrating how to automate customer support tasks effectively. We started by setting up the environment, defining specialized agents, and creating tasks leveraging various tools. By initializing and kicking off the crew, we saw how agents collaborate to retrieve data, draft responses, and ensure quality.

To dive deeper into the capabilities and possibilities of multi-agent systems, check out the CrewAI documentation.