preparing verison 0.5.5

* Update README.MD

* Update examples section in README.md

.github/workflows/black.yml

@@ -1,10 +1,10 @@
 name: Lint
 
-on: [push, pull_request]
+on: [pull_request]
 
 jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - uses: psf/black@stable
+      - uses: psf/black@stable

.github/workflows/mkdocs.yml

@@ -1,7 +1,7 @@
 name: Deploy MkDocs
 
 on:
-  workflow_dispatch:    
+  workflow_dispatch:
   push:
     branches:
       - main
@@ -22,11 +22,23 @@ jobs:
         with:
           python-version: '3.10'
 
+      - name: Calculate requirements hash
+        id: req-hash
+        run: echo "::set-output name=hash::$(sha256sum requirements-doc.txt | awk '{print $1}')"
+
+      - name: Setup cache
+        uses: actions/cache@v3
+        with:
+          key: mkdocs-material-${{ steps.req-hash.outputs.hash }}
+          path: .cache
+          restore-keys: |
+            mkdocs-material-
+
       - name: Install Requirements
         run: |
           sudo apt-get update &&
           sudo apt-get install pngquant &&
-          pip install mkdocs-material
+          pip install mkdocs-material mkdocs-material-extensions pillow cairosvg
 
         env:
           GH_TOKEN: ${{ secrets.GH_TOKEN }}

.github/workflows/tests.yml

@@ -1,6 +1,6 @@
 name: Run Tests
 
-on: [push, pull_request]
+on: [pull_request]
 
 permissions:
   contents: write

.github/workflows/type-checker.yml

@@ -0,0 +1,30 @@
+
+name: Run Type Checks
+
+on: [pull_request]
+
+permissions:
+  contents: write
+
+jobs:
+  type-checker:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Setup Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+
+      - name: Install Requirements
+        run: |
+          sudo apt-get update &&
+          pip install poetry &&
+          poetry lock &&
+          poetry install
+
+      - name: Run type checks
+        run: poetry run pyright

README.md

@@ -1,70 +1,75 @@
-# crewAI
+<div align="center">
 
-![Logo of crewAI, tow people rowing on a boat](./docs/crewai_logo.png)
+![Logo of crewAI, two people rowing on a boat](./docs/crewai_logo.png)
 
-🤖 Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.
+# **crewAI**
 
-- [crewAI](#crewai)
-  - [Why CrewAI?](#why-crewai)
-  - [Getting Started](#getting-started)
-  - [Key Features](#key-features)
-  - [Examples](#examples)
-    - [Code](#code)
-    - [Video](#video)
-      - [Quick Tutorial](#quick-tutorial)
-      - [Trip Planner](#trip-planner)
-      - [Stock Analysis](#stock-analysis)
-  - [Connecting Your Crew to a Model](#connecting-your-crew-to-a-model)
-  - [How CrewAI Compares](#how-crewai-compares)
-  - [Contribution](#contribution)
-    - [Installing Dependencies](#installing-dependencies)
-    - [Virtual Env](#virtual-env)
-    - [Pre-commit hooks](#pre-commit-hooks)
-    - [Running Tests](#running-tests)
-    - [Packaging](#packaging)
-    - [Installing Locally](#installing-locally)
-  - [Hire CrewAI](#hire-crewai)
-  - [License](#license)
+🤖 **crewAI**: Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.
+
+<h3>
+
+[Homepage](https://www.crewai.io/) | [Documentation](https://docs.crewai.com/) | [Chat with Docs](https://chatg.pt/DWjSBZn) | [Examples](https://github.com/joaomdmoura/crewai-examples) | [Discord](https://discord.com/invite/X4JWnZnxPb)
+
+</h3>
+
+[![GitHub Repo stars](https://img.shields.io/github/stars/joaomdmoura/crewAI)](https://github.com/joaomdmoura/crewAI)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+
+</div>
+
+## Table of contents
+
+- [Why CrewAI?](#why-crewai)
+- [Getting Started](#getting-started)
+- [Key Features](#key-features)
+- [Examples](#examples)
+  - [Quick Tutorial](#quick-tutorial)
+  - [Trip Planner](#trip-planner)
+  - [Stock Analysis](#stock-analysis)
+- [Connecting Your Crew to a Model](#connecting-your-crew-to-a-model)
+- [How CrewAI Compares](#how-crewai-compares)
+- [Contribution](#contribution)
+- [Hire CrewAI](#hire-crewai)
+- [Telemetry](#telemetry)
+- [License](#license)
 
 ## Why CrewAI?
 
 The power of AI collaboration has too much to offer.
 CrewAI is designed to enable AI agents to assume roles, share goals, and operate in a cohesive unit - much like a well-oiled crew. Whether you're building a smart assistant platform, an automated customer service ensemble, or a multi-agent research team, CrewAI provides the backbone for sophisticated multi-agent interactions.
 
-- 🤖 [Talk with the Docs](https://chatg.pt/DWjSBZn)
-- 📄 [Documentation Wiki](https://joaomdmoura.github.io/crewAI/)
-
 ## Getting Started
 
 To get started with CrewAI, follow these simple steps:
 
-1. **Installation**:
+### 1. Installation
 
 ```shell
 pip install crewai
 ```
 
-The example below also uses duckduckgo, so also install that
+The example below also uses DuckDuckGo's Search. You can install it with `pip` too:
+
 ```shell
 pip install duckduckgo-search
 ```
 
-2. **Setting Up Your Crew**:
+### 2. Setting Up Your Crew
 
 ```python
 import os
 from crewai import Agent, Task, Crew, Process
 
-os.environ["OPENAI_API_KEY"] = "YOUR KEY"
+os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"
 
-# You can choose to use a local model through Ollama for example. See ./docs/llm-connections.md for more information.
-# from langchain.llms import Ollama
+# You can choose to use a local model through Ollama for example. See ./docs/how-to/llm-connections.md for more information.
+# from langchain_community.llms import Ollama
 # ollama_llm = Ollama(model="openhermes")
 
 # Install duckduckgo-search for this example:
 # !pip install -U duckduckgo-search
 
-from langchain.tools import DuckDuckGoSearchRun
+from langchain_community.tools import DuckDuckGoSearchRun
 search_tool = DuckDuckGoSearchRun()
 
 # Define your agents with roles and goals
@@ -73,8 +78,7 @@ researcher = Agent(
   goal='Uncover cutting-edge developments in AI and data science',
   backstory="""You work at a leading tech think tank.
   Your expertise lies in identifying emerging trends.
-  You have a knack for dissecting complex data and presenting
-  actionable insights.""",
+  You have a knack for dissecting complex data and presenting actionable insights.""",
   verbose=True,
   allow_delegation=False,
   tools=[search_tool]
@@ -83,16 +87,17 @@ researcher = Agent(
   # model like OpenAI, Mistral, Antrophic or others (https://python.langchain.com/docs/integrations/llms/)
   #
   # Examples:
+  #
+  # from langchain_community.llms import Ollama
   # llm=ollama_llm # was defined above in the file
-  # llm=OpenAI(model_name="gpt-3.5", temperature=0.7)
-  # For the OpenAI model you would need to import
-  # from langchain_openai import OpenAI
+  #
+  # from langchain_openai import ChatOpenAI
+  # llm=ChatOpenAI(model_name="gpt-3.5", temperature=0.7)
 )
 writer = Agent(
   role='Tech Content Strategist',
   goal='Craft compelling content on tech advancements',
-  backstory="""You are a renowned Content Strategist, known for
-  your insightful and engaging articles.
+  backstory="""You are a renowned Content Strategist, known for your insightful and engaging articles.
   You transform complex concepts into compelling narratives.""",
   verbose=True,
   allow_delegation=True,
@@ -130,43 +135,48 @@ print("######################")
 print(result)
 ```
 
-Currently the only supported process is `Process.sequential`, where one task is executed after the other and the outcome of one is passed as extra content into this next.
-
+In addition to the sequential process, you can use the hierarchical process, which automatically assigns a manager to the defined crew to properly coordinate the planning and execution of tasks through delegation and validation of results. [See more about the processes here](https://docs.crewai.com/core-concepts/Processes/).
 
 ## Key Features
 
 - **Role-Based Agent Design**: Customize agents with specific roles, goals, and tools.
 - **Autonomous Inter-Agent Delegation**: Agents can autonomously delegate tasks and inquire amongst themselves, enhancing problem-solving efficiency.
 - **Flexible Task Management**: Define tasks with customizable tools and assign them to agents dynamically.
-- **Processes Driven**: Currently only supports `sequential` task execution but more complex processes like consensual and hierarchical being worked on.
-- **Works with Open Source Models**: Run your crew using Open AI or open source models refer to the [Connect crewAI to LLMs](./docs/llm-connections.md) page for details on configuring you agents' connections to models, even ones running locally!
+- **Processes Driven**: Currently only supports `sequential` task execution and `hierarchical` processes, but more complex processes like consensual and autonomous are being worked on.
+- **Works with Open Source Models**: Run your crew using Open AI or open source models refer to the [Connect crewAI to LLMs](https://docs.crewai.com/how-to/LLM-Connections/) page for details on configuring you agents' connections to models, even ones running locally!
 
 ![CrewAI Mind Map](./docs/crewAI-mindmap.png "CrewAI Mind Map")
 
 ## Examples
-You can test different real life examples of AI crews [in the examples repo](https://github.com/joaomdmoura/crewAI-examples?tab=readme-ov-file)
 
-### Code
+You can test different real life examples of AI crews in the [crewAI-examples repo](https://github.com/joaomdmoura/crewAI-examples?tab=readme-ov-file):
+
+- [Landing Page Generator](https://github.com/joaomdmoura/crewAI-examples/tree/main/landing_page_generator)
+- [Having Human input on the execution](https://docs.crewai.com/how-to/Human-Input-on-Execution)
 - [Trip Planner](https://github.com/joaomdmoura/crewAI-examples/tree/main/trip_planner)
 - [Stock Analysis](https://github.com/joaomdmoura/crewAI-examples/tree/main/stock_analysis)
-- [Landing Page Generator](https://github.com/joaomdmoura/crewAI-examples/tree/main/landing_page_generator)
-- [Having Human input on the execution](./docs/how-to/Human-Input-on-Execution.md)
 
-### Video
-#### Quick Tutorial
-[![CrewAI Tutorial](https://img.youtube.com/vi/tnejrr-0a94/0.jpg)](https://www.youtube.com/watch?v=tnejrr-0a94 "CrewAI Tutorial")
+### Quick Tutorial
 
-#### Trip Planner
-[![Trip Planner](https://img.youtube.com/vi/xis7rWp-hjs/0.jpg)](https://www.youtube.com/watch?v=xis7rWp-hjs "Trip Planner")
+[![CrewAI Tutorial](https://img.youtube.com/vi/tnejrr-0a94/maxresdefault.jpg)](https://www.youtube.com/watch?v=tnejrr-0a94 "CrewAI Tutorial")
 
-#### Stock Analysis
-[![Stock Analysis](https://img.youtube.com/vi/e0Uj4yWdaAg/0.jpg)](https://www.youtube.com/watch?v=e0Uj4yWdaAg "Stock Analysis")
+### Trip Planner
+
+[Check out code for this example](https://github.com/joaomdmoura/crewAI-examples/tree/main/trip_planner) or watch a video below:
+
+[![Trip Planner](https://img.youtube.com/vi/xis7rWp-hjs/maxresdefault.jpg)](https://www.youtube.com/watch?v=xis7rWp-hjs "Trip Planner")
+
+### Stock Analysis
+
+[Check out code for this example](https://github.com/joaomdmoura/crewAI-examples/tree/main/stock_analysis) or watch a video below:
+
+[![Stock Analysis](https://img.youtube.com/vi/e0Uj4yWdaAg/maxresdefault.jpg)](https://www.youtube.com/watch?v=e0Uj4yWdaAg "Stock Analysis")
 
 ## Connecting Your Crew to a Model
 
 crewAI supports using various LLMs through a variety of connection options. By default your agents will use the OpenAI API when querying the model. However, there are several other ways to allow your agents to connect to models. For example, you can configure your agents to use a local model via the Ollama tool.
 
-Please refer to the [Connect crewAI to LLMs](./docs/how-to/llm-connections.md) page for details on configuring you agents' connections to models.
+Please refer to the [Connect crewAI to LLMs](https://docs.crewai.com/how-to/LLM-Connections/) page for details on configuring you agents' connections to models.
 
 ## How CrewAI Compares
 
@@ -187,12 +197,14 @@ CrewAI is open-source and we welcome contributions. If you're looking to contrib
 - We appreciate your input!
 
 ### Installing Dependencies
+
 ```bash
 poetry lock
 poetry install
 ```
 
 ### Virtual Env
+
 ```bash
 poetry shell
 ```
@@ -204,25 +216,52 @@ pre-commit install
 ```
 
 ### Running Tests
+
 ```bash
 poetry run pytest
 ```
 
+### Running static type checks
+
+```bash
+poetry run pyright
+```
+
 ### Packaging
+
 ```bash
 poetry build
 ```
 
 ### Installing Locally
+
 ```bash
 pip install dist/*.tar.gz
 ```
 
 ## Hire CrewAI
+
 We're a company developing crewAI and crewAI Enterprise, we for a limited time are offer consulting with selected customers, to get them early access to our enterprise solution
-If you are interested on having access to it and hiring weekly hours with our team, feel free to email us at [sales@crewai.io](mailto:sales@crewai.io)
+If you are interested on having access to it and hiring weekly hours with our team, feel free to email us at [joao@crewai.com](mailto:joao@crewai.com).
+
+## Telemetry
+
+CrewAI uses anonymous telemetry to collect usage data with the main purpose of helping us improve the library by focusing our efforts on the most used features, integrations and tools.
+
+There is NO data being collected on the prompts, tasks descriptions agents backstories or goals nor tools usage, no API calls, nor responses nor any data that is being processed by the agents, nor any secrets and env vars.
+
+Data collected includes:
+- Version of crewAI
+- Version of Python
+- General OS (e.g. number of CPUs, macOS/Windows/Linux)
+- Number of agents and tasks in a crew
+- Crew Process being used
+- If Agents are using memory or allowing delegation
+- If Tasks are being executed in parallel or sequentially
+- Language model being used
+- Roles of agents in a crew
+- Tools names available
 
 ## License
-CrewAI is released under the MIT License
-
 
+CrewAI is released under the MIT License.

docs/core-concepts/Agent-Tools.md

@@ -1,90 +0,0 @@
-# What is a Tool?
-
-A tool in CrewAI is a function or capability that an agent can utilize to perform actions, gather information, or interact with external systems, behind the scenes tools are [LangChain Tools](https://python.langchain.com/docs/modules/agents/tools/).
-These tools can be as straightforward as a search function or as sophisticated as integrations with other chains or APIs.
-
-## Key Characteristics of Tools
-
-- **Utility**: Tools are designed to serve specific purposes, such as searching the web, analyzing data, or generating content.
-- **Integration**: Tools can be integrated into agents to extend their capabilities beyond their basic functions.
-- **Customizability**: Developers can create custom tools tailored to the specific needs of their agents or use pre-built LangChain ones available in the ecosystem.
-
-# Creating your own Tools
-
-You can easily create your own tool using [LangChain Tool Custom Tool Creation](https://python.langchain.com/docs/modules/agents/tools/custom_tools).
-
-Example:
-```python
-import json
-import requests
-
-from crewai import Agent
-from langchain.tools import tool
-from unstructured.partition.html import partition_html
-
-class BrowserTools():
-  @tool("Scrape website content")
-  def scrape_website(website):
-    """Useful to scrape a website content"""
-    url = f"https://chrome.browserless.io/content?token={config('BROWSERLESS_API_KEY')}"
-    payload = json.dumps({"url": website})
-    headers = {
-      'cache-control': 'no-cache',
-      'content-type': 'application/json'
-    }
-    response = requests.request("POST", url, headers=headers, data=payload)
-    elements = partition_html(text=response.text)
-    content = "\n\n".join([str(el) for el in elements])
-
-    # Return only the first 5k characters
-    return content[:5000]
-
-
-# Create an agent and assign the scrapping tool
-agent = Agent(
-  role='Research Analyst',
-  goal='Provide up-to-date market analysis',
-  backstory='An expert analyst with a keen eye for market trends.',
-  tools=[BrowserTools().scrape_website]
-)
-```
-
-# Using Existing Tools
-
-Check [LangChain Integration](https://python.langchain.com/docs/integrations/tools/) for a set of useful existing tools.
-To assign a tool to an agent, you'd provide it as part of the agent's properties during initialization.
-
-```python
-from crewai import Agent
-from langchain.agents import Tool
-from langchain.utilities import GoogleSerperAPIWrapper
-
-# Initialize SerpAPI tool with your API key
-os.environ["OPENAI_API_KEY"] = "Your Key"
-os.environ["SERPER_API_KEY"] = "Your Key"
-
-search = GoogleSerperAPIWrapper()
-
-# Create tool to be used by agent
-serper_tool = Tool(
-  name="Intermediate Answer",
-  func=search.run,
-  description="useful for when you need to ask with search",
-)
-
-# Create an agent and assign the search tool
-agent = Agent(
-  role='Research Analyst',
-  goal='Provide up-to-date market analysis',
-  backstory='An expert analyst with a keen eye for market trends.',
-  tools=[serper_tool]
-)
-```
-
-# Tool Interaction
-
-Tools enhance an agent's ability to perform tasks autonomously or in collaboration with other agents. For instance, an agent might use a search tool to gather information, then pass that data to another agent specialized in analysis.
-
-# Conclusion
-
-Tools are vital components that expand the functionality of agents within the CrewAI framework. They enable agents to perform a wide range of actions and collaborate effectively with one another. As you build with CrewAI, consider the array of tools you can leverage to empower your agents and how they can be interwoven to create a robust AI ecosystem.

docs/core-concepts/Agents.md

@@ -0,0 +1,58 @@
+---
+title: crewAI Agents
+description: What are crewAI Agents and how to use them.
+---
+
+## What is an Agent?
+!!! note "What is an Agent?"
+    An agent is an **autonomous unit** programmed to:
+    <ul>
+      <li class='leading-3'>Perform tasks</li>
+      <li class='leading-3'>Make decisions</li>
+      <li class='leading-3'>Communicate with other agents</li>
+      <br/>
+    Think of an agent as a member of a team, with specific skills and a particular job to do. Agents can have different roles like 'Researcher', 'Writer', or 'Customer Support', each contributing to the overall goal of the crew.
+
+## Agent Attributes
+
+| Attribute      | Description                          |
+| :---------- | :----------------------------------- |
+| **Role**       | Defines the agent's function within the crew. It determines the kind of tasks the agent is best suited for.  |
+| **Goal**       | The individual objective that the agent aims to achieve. It guides the agent's decision-making process. |
+| **Backstory**    | Provides context to the agent's role and goal, enriching the interaction and collaboration dynamics. |
+| **Tools**    | Set of capabilities or functions that the agent can use to perform tasks. Tools can be shared or exclusive to specific agents. |
+| **Max Iter**    | The maximum number of iterations the agent can perform before forced to give its best answer |
+| **Max RPM**    | The maximum number of requests per minute the agent can perform to avoid rate limits |
+| **Verbose**    | This allow you to actually see what is going on during the Crew execution. |
+| **Allow Delegation**    | Agents can delegate tasks or questions to one another, ensuring that each task is handled by the most suitable agent. |
+
+
+## Creating an Agent
+
+!!! note "Agent Interaction"
+    Agents can interact with each other using the CrewAI's built-in delegation and communication mechanisms.<br/>This allows for dynamic task management and problem-solving within the crew.
+
+To create an agent, you would typically initialize an instance of the `Agent` class with the desired properties. Here's a conceptual example:
+
+```python
+# Example: Creating an agent with all attributes
+from crewai import Agent
+
+agent = Agent(
+  role='Data Analyst',
+  goal='Extract actionable insights',
+  backstory="""You're a data analyst at a large company.
+  You're responsible for analyzing data and providing insights
+  to the business.
+  You're currently working on a project to analyze the
+  performance of our marketing campaigns.""",
+  tools=[my_tool1, my_tool2],
+  max_iter=10,
+  max_rpm=10,
+  verbose=True,
+  allow_delegation=True
+)
+```
+
+## Conclusion
+Agents are the building blocks of the CrewAI framework. By understanding how to define and interact with agents, you can create sophisticated AI systems that leverage the power of collaborative intelligence.

docs/core-concepts/Collaboration.md

@@ -0,0 +1,24 @@
+---
+title: How Agents Collaborate in CrewAI
+description: Exploring the dynamics of agent collaboration within the CrewAI framework.
+---
+
+## Collaboration Fundamentals
+!!! note "Core of Agent Interaction"
+    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.
+
+## 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
+Setting up a crew involves defining the roles and capabilities of each agent. CrewAI seamlessly manages their interactions, ensuring efficient collaboration and delegation.
+
+## Example Scenario
+Imagine a crew with a researcher agent tasked with data gathering and a writer agent responsible for compiling reports. The writer can delegate research tasks or ask questions to the researcher, facilitating a seamless workflow.
+
+## Conclusion
+Collaboration and delegation are pivotal, transforming individual AI agents into a coherent, intelligent crew capable of tackling complex tasks. CrewAI's framework not only simplifies these interactions but enhances their effectiveness, paving the way for sophisticated AI-driven solutions.

docs/core-concepts/Creating-Tasks.md

@@ -1,50 +0,0 @@
-# What is a Task?
-
-A Task in CrewAI is essentially a job or an assignment that an AI agent needs to complete. It's defined by what needs to be done and can include additional information like which agent should do it and what tools they might need.
-
-# Task Properties
-
-- **Description**: A clear, concise statement of what the task entails.
-- **Agent**: Optionally, you can specify which agent is responsible for the task. If not, the crew's process will determine who takes it on.
-- **Tools**: These are the functions or capabilities the agent can utilize to perform the task. They can be anything from simple actions like 'search' to more complex interactions with other agents or APIs.
-
-# Integrating Tools with Tasks
-
-In CrewAI, tools are functions from the `langchain` toolkit that agents can use to interact with the world. These can be generic utilities or specialized functions designed for specific actions. When you assign tools to a task, they empower the agent to perform its duties more effectively.
-
-## Example of Creating a Task with Tools
-
-```python
-from crewai import Task
-from langchain.agents import Tool
-from langchain.utilities import GoogleSerperAPIWrapper
-
-# Initialize SerpAPI tool with your API key
-os.environ["OPENAI_API_KEY"] = "Your Key"
-os.environ["SERPER_API_KEY"] = "Your Key"
-
-search = GoogleSerperAPIWrapper()
-
-# Create tool to be used by agent
-serper_tool = Tool(
-  name="Intermediate Answer",
-  func=search.run,
-  description="useful for when you need to ask with search",
-)
-
-# Create a task with a description and the search tool
-task = Task(
-  description='Find and summarize the latest and most relevant news on AI',
-  tools=[serper_tool]
-)
-```
-
-When the task is executed by an agent, the tools specified in the task will override the agent's default tools. This means that for the duration of this task, the agent will use the search tool provided, even if it has other tools assigned to it.
-
-# Tool Override Mechanism
-
-The ability to override an agent's tools with those specified in a task allows for greater flexibility. An agent might generally use a set of standard tools, but for certain tasks, you may want it to use a particular tool that is more suited to the task at hand.
-
-# Conclusion
-
-Creating tasks with the right tools is crucial in CrewAI. It ensures that your agents are not only aware of what they need to do but are also equipped with the right functions to do it effectively. This feature underlines the flexibility and power of the CrewAI system, where tasks can be tailored with specific tools to achieve the best outcome.

docs/core-concepts/Crews.md

@@ -0,0 +1,75 @@
+---
+title: crewAI Crews
+description: Understanding and utilizing crews in the crewAI framework.
+---
+
+## What is a Crew?
+!!! note "Definition of 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
+
+| Attribute            | Description                                                  |
+| :------------------- | :----------------------------------------------------------- |
+| **Tasks**            | A list of tasks assigned to the crew.                        |
+| **Agents**           | A list of agents that are part of the crew.                  |
+| **Process**          | The process flow (e.g., sequential, hierarchical) the crew follows. |
+| **Verbose**          | The verbosity level for logging during execution.            |
+| **Manager LLM**      | The language model used by the manager agent in a hierarchical process. |
+| **Config**           | Configuration settings for the crew.                         |
+| **Max RPM**          | Maximum requests per minute the crew adheres to during execution. |
+| **Language**         | Language setting for the crew's operation.                   |
+
+!!! note "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 a Crew
+
+!!! note "Crew Composition"
+    When assembling a crew, you combine agents with complementary roles and tools, assign tasks, and select a process that dictates their execution order and interaction.
+
+### Example: Assembling a Crew
+
+```python
+from crewai import Crew, Agent, Task, Process
+from langchain_community.tools import DuckDuckGoSearchRun
+
+# Define agents with specific roles and tools
+researcher = Agent(
+    role='Senior Research Analyst',
+    goal='Discover innovative AI technologies',
+    tools=[DuckDuckGoSearchRun()]
+)
+
+writer = Agent(
+    role='Content Writer',
+    goal='Write engaging articles on AI discoveries'
+)
+
+# Create tasks for the agents
+research_task = Task(description='Identify breakthrough AI technologies', agent=researcher)
+write_article_task = Task(description='Draft an article on the latest AI technologies', agent=writer)
+
+# Assemble the crew with a sequential process
+my_crew = Crew(
+    agents=[researcher, writer],
+    tasks=[research_task, write_article_task],
+    process=Process.sequential,
+    verbose=True
+)
+```
+
+## 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.
+
+### 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.
+
+```python
+# Start the crew's task execution
+result = my_crew.kickoff()
+print(result)
+```

docs/core-concepts/Defining-Tasks.md

@@ -1,42 +0,0 @@
-# Overview of a Task
-
-In the CrewAI framework, tasks are the individual assignments that agents are responsible for completing. They are the fundamental units of work that your AI crew will undertake. Understanding how to define and manage tasks is key to leveraging the full potential of CrewAI.
-
-A task in CrewAI encapsulates all the information needed for an agent to execute it, including a description, the agent assigned to it, and any specific tools required. Tasks are designed to be flexible, allowing for both simple and complex actions depending on your needs.
-
-# Properties of a Task
-
-Every task in CrewAI has several properties:
-
-- **Description**: A clear and concise statement of what needs to be done.
-- **Agent**: The agent assigned to the task (optional). If no agent is specified, the task can be picked up by any agent based on the process defined.
-- **Tools**: A list of tools (optional) that the agent can use to complete the task. These can override the agent's default tools if necessary.
-
-# Creating a Task
-
-Creating a task is straightforward. You define what needs to be done and, optionally, who should do it and what tools they should use. Here’s a conceptual guide:
-
-```python
-from crewai import Task
-
-# Define a task with a designated agent and specific tools
-task = Task(description='Generate monthly sales report', agent=sales_agent, tools=[reporting_tool])
-```
-
-# Task Assignment
-
-Tasks can be assigned to agents in several ways:
-
-- Directly, by specifying the agent when creating the task.
-- [WIP] Through the Crew's process, which can assign tasks based on agent roles, availability, or other criteria.
-
-# Task Execution
-
-Once a task has been defined and assigned, it's ready to be executed. Execution is typically handled by the Crew object, which manages the workflow and ensures that tasks are completed according to the defined process.
-
-# Task Collaboration
-
-Tasks in CrewAI can be designed to require collaboration between agents. For example, one agent might gather data while another analyzes it. This collaborative approach can be defined within the task properties and managed by the Crew's process.
-
-# Conclusion
-Tasks are the driving force behind the actions of agents in CrewAI. By properly defining tasks, you set the stage for your AI agents to work effectively, either independently or as a collaborative unit. In the following sections, we will explore how tasks fit into the larger picture of processes and crew management.

docs/core-concepts/Delegation-and-Collaboration.md

@@ -1,26 +0,0 @@
-# How Agents Collaborate:
-
-In CrewAI, collaboration is the cornerstone of agent interaction. Agents are designed to work together by sharing information, requesting assistance, and combining their skills to complete tasks more efficiently.
-
-- **Information Sharing**: Agents can share findings and data amongst themselves to ensure all members are informed and can contribute effectively.
-- **Task Assistance**: If an agent encounters a task that requires additional expertise, it can seek the help of another agent with the necessary skill set.
-- **Resource Allocation**: Agents can share or allocate resources such as tools or processing power to optimize task execution.
-
-Collaboration is embedded in the DNA of CrewAI, enabling a dynamic and adaptive approach to problem-solving.
-
-# Delegation: Dividing to Conquer
-
-Delegation is the process by which an agent assigns a task to another agent, or just ask another agent, it's an intelligent decision-making process that enhances the crew's functionality.
-By default all agents can delegate work and ask questions, so if you want an agent to work alone make sure to set that option when initializing an Agent, this is useful to prevent deviations if the task is supposed to be straightforward.
-
-## Implementing Collaboration and Delegation
-
-When setting up your crew, you'll define the roles and capabilities of each agent. CrewAI's infrastructure takes care of the rest, managing the complex interplay of agents as they work together.
-
-## Example Scenario:
-
-Imagine a scenario where you have a researcher agent that gathers data and a writer agent that compiles reports. The writer can autonomously ask question or delegate more in depth research work depending on its needs as it tries to complete its task.
-
-# Conclusion
-
-Collaboration and delegation are what transform a collection of AI agents into a unified, intelligent crew. With CrewAI, you have a framework that not only simplifies these interactions but also makes them more effective, paving the way for sophisticated AI systems that can tackle complex, multi-dimensional tasks.

docs/core-concepts/Managing-Processes.md

@@ -1,49 +0,0 @@
-# Managing Processes in CrewAI
-
-Processes are the heart of CrewAI's workflow management, akin to the way a human team organizes its work. In CrewAI, processes define the sequence and manner in which tasks are executed by agents, mirroring the coordination you'd expect in a well-functioning team of people.
-
-## Understanding Processes
-
-A process in CrewAI can be thought of as the game plan for how your AI agents will handle their workload. Just as a project manager assigns tasks to team members based on their skills and the project timeline, CrewAI processes assign tasks to agents to ensure efficient workflow.
-
-## Process Implementations
-
-- **Sequential (Supported)**: This is the only process currently implemented in CrewAI. It ensures tasks are handled one at a time, in a given order, much like a relay race where one runner passes the baton to the next.
-- **Consensual (WIP)**: Envisioned for a future update, the consensual process will enable agents to make joint decisions on task execution, similar to a team consensus in a meeting before proceeding.
-- **Hierarchical (WIP)**: Also in the pipeline, this process will introduce a chain of command to task execution, where some agents may have the authority to prioritize tasks or delegate them, akin to a traditional corporate hierarchy.
-These additional processes, once implemented, will offer more nuanced and sophisticated ways for agents to interact and complete tasks, much like teams in complex organizational structures.
-
-
-## Defining a Sequential Process
-
-Creating a sequential process in CrewAI is straightforward and reflects the simplicity of coordinating a team's efforts step by step. In this process the outcome of the previous task is sent into the next one as context that I should use to accomplish it's task
-
-```python
-from crewai import Process
-
-# Define a sequential process
-sequential_process = Process.sequential
-```
-
-# The Magic of Sequential Processes
-
-The sequential process is where much of CrewAI's magic happens. It ensures that tasks are approached with the same thoughtful progression that a human team would use, fostering a natural and logical flow of work while passing on task outcome into the next.
-
-## Assigning Processes to a Crew
-
-To assign a process to a crew, simply set it during the crew's creation. The process will dictate the crew's approach to task execution.
-
-```python
-from crewai import Crew
-
-# Create a crew with a sequential process
-crew = Crew(agents=my_agents, tasks=my_tasks, process=sequential_process)
-```
-
-## The Role of Processes in Teamwork
-
-The process you choose for your crew is critical. It's what transforms a group of individual agents into a cohesive unit that can tackle complex projects with the precision and harmony you'd find in a team of skilled humans.
-
-## Conclusion
-
-Processes bring structure and order to the CrewAI ecosystem, allowing agents to collaborate effectively and accomplish goals systematically. As CrewAI evolves, additional process types will be introduced to enhance the framework's versatility, much like a team that grows and adapts over time.

docs/core-concepts/Processes.md

@@ -0,0 +1,48 @@
+---
+title: Managing Processes in CrewAI
+description: An overview of workflow management through processes in CrewAI.
+---
+
+## Understanding Processes
+!!! note "Core Concept"
+    Processes in CrewAI orchestrate how tasks are executed by agents, akin to project management in human teams. They ensure tasks are distributed and completed efficiently, according to a predefined game plan.
+
+## Process Implementations
+
+- **Sequential**: Executes tasks one after another, ensuring a linear and orderly progression.
+- **Hierarchical**: Implements a chain of command, where tasks are delegated and executed based on a managerial structure.
+- **Consensual (WIP)**: Future process type aiming for collaborative decision-making among agents on task execution.
+
+## The Role of Processes in Teamwork
+Processes transform individual agents into a unified team, coordinating their efforts to achieve common goals with efficiency and harmony.
+
+## Assigning Processes to a Crew
+Specify the process during crew creation to determine the execution strategy:
+
+```python
+from crewai import Crew
+from crewai.process import 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
+crew = Crew(agents=my_agents, tasks=my_tasks, process=Process.hierarchical)
+```
+
+## Sequential Process
+Ensures a natural flow of work, mirroring human team dynamics by progressing through tasks thoughtfully and systematically.
+
+Tasks need to be pre-assigned to agents, and the order of execution is determined by the order of the tasks in the list.
+
+Tasks are executed one after another, ensuring a linear and orderly progression and the output of one task is automatically used as context into the next task.
+
+You can also define specific task's outputs that should be used as context for another task by using the `context` parameter in the `Task` class.
+
+## Hierarchical Process
+Mimics a corporate hierarchy, where a manager oversees task execution, planning, delegation, and validation, enhancing task coordination.
+
+In this process tasks don't need to be pre-assigned to agents, the manager will decide which agent will perform each task, review the output and decide if the task is completed or not.
+
+## Conclusion
+Processes are vital for structured collaboration within CrewAI, enabling agents to work together systematically. Future updates will introduce new processes, further mimicking the adaptability and complexity of human teamwork.

docs/core-concepts/Tasks.md

@@ -0,0 +1,212 @@
+---
+title: crewAI Tasks
+description: Overview and management of tasks within the crewAI framework.
+---
+
+## Overview of a Task
+!!! note "What is a Task?"
+    In the CrewAI framework, tasks are individual assignments that agents complete. They encapsulate necessary information for execution, including a description, assigned agent, and required tools, offering flexibility for various action complexities.
+
+Tasks in CrewAI can be designed to require collaboration between agents. For example, one agent might gather data while another analyzes it. This collaborative approach can be defined within the task properties and managed by the Crew's process.
+
+## Task Attributes
+
+| Attribute      | Description                          |
+| :---------- | :----------------------------------- |
+| **Description**       | A clear, concise statement of what the task entails.  |
+| **Agent**    | Optionally, you can specify which agent is responsible for the task. If not, the crew's process will determine who takes it on. |
+| **Expected Output** *(optional)*      | Clear and detailed definition of expected output for the task.  |
+| **Tools** *(optional)*   | These are the functions or capabilities the agent can utilize to perform the task. They can be anything from simple actions like 'search' to more complex interactions with other agents or APIs. |
+| **Async Execution** *(optional)*      | If the task should be executed asynchronously.  |
+| **Context**  *(optional)*     | Other tasks that will have their output used as context for this task, if one is an asynchronous task it will wait for that to finish |
+| **Callback**  *(optional)*  | A function to be executed after the task is completed. |
+
+## Creating a Task
+
+This is the simpliest example for creating a task, it involves defining its scope and agent, but there are optional attributes that can provide a lot of flexibility:
+
+```python
+from crewai import Task
+
+task = Task(
+	description='Find and summarize the latest and most relevant news on AI',
+	agent=sales_agent
+)
+```
+!!! note "Task Assignment"
+	Tasks can be assigned directly by specifying an `agent` to them, or they can be assigned in run time if you are using the `hierarchical` through CrewAI's process, considering roles, availability, or other criteria.
+
+## Integrating Tools with Tasks
+
+Tools from the [crewAI Toolkit](https://github.com/joaomdmoura/crewai-tools) and [LangChain Tools](https://python.langchain.com/docs/integrations/tools) enhance task performance, allowing agents to interact more effectively with their environment. Assigning specific tools to tasks can tailor agent capabilities to particular needs.
+
+## Creating a Task with Tools
+
+```python
+import os
+os.environ["OPENAI_API_KEY"] = "Your Key"
+
+from crewai import Agent, Task, Crew
+from langchain.agents import Tool
+from langchain_community.tools import DuckDuckGoSearchRun
+
+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
+)
+
+# Install duckduckgo-search for this example:
+# !pip install -U duckduckgo-search
+search_tool = DuckDuckGoSearchRun()
+
+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=2
+)
+
+result = crew.kickoff()
+print(result)
+```
+
+This demonstrates how tasks with specific tools can override an agent's default set for tailored task execution.
+
+## Refering other Tasks
+
+In crewAI the output of one task is automatically relayed into the next one, but you can specifically define what tasks output 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:
+
+```python
+# ...
+
+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]
+)
+
+write_blog_task = Task(
+  description="Write a full blog post about the importante of AI and it's latest news",
+	expected_output='Full blog post that is 4 paragraphs long',
+	agent=writer_agent,
+  context=[research_task]
+)
+
+#...
+```
+
+## 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.
+
+```python
+#...
+
+list_ideas = Task(
+	description="List of 5 interesting ideas to explore for na 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, it's 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
+
+You can define a callback function that will be executed after the task is completed. This is useful for tasks that need to trigger some side effect after they are completed, while the crew is still running.
+
+```python
+# ...
+
+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.result}
+	""")
+
+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
+
+Once a crew finishes running, you can access the output of a specific task by using the `output` attribute of the task object:
+
+```python
+# ...
+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=2
+)
+
+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.result}
+""")
+```
+
+
+
+
+## Tool Override Mechanism
+
+Specifying tools in a task allows for dynamic adaptation of agent capabilities, emphasizing CrewAI's flexibility.
+
+## 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 is crucial for maximizing CrewAI's potential, ensuring agents are effectively prepared for their assignments.

docs/core-concepts/Tools.md

@@ -0,0 +1,83 @@
+---
+title: crewAI Tools
+description: Understanding and leveraging tools within the crewAI framework.
+---
+
+## What is a Tool?
+!!! note "Definition"
+    A tool in CrewAI, is a skill, something Agents can use perform tasks, right now those can be tools from the [crewAI Toolkit](https://github.com/joaomdmoura/crewai-tools) and [LangChain Tools](https://python.langchain.com/docs/integrations/tools), those are basically functions that an agent can utilize for various actions, from simple searches to complex interactions with external systems.
+
+## Key Characteristics of Tools
+
+- **Utility**: Designed for specific tasks such as web searching, data analysis, or content generation.
+- **Integration**: Enhance agent capabilities by integrating tools directly into their workflow.
+- **Customizability**: Offers the flexibility to develop custom tools or use existing ones from LangChain's ecosystem.
+
+## Creating your own Tools
+!!! example "Custom Tool Creation"
+    Developers can craft custom tools tailored for their agent’s needs or utilize pre-built options. Here’s how to create one:
+
+```python
+import json
+import requests
+from crewai import Agent
+from langchain.tools import tool
+from unstructured.partition.html import partition_html
+
+class BrowserTools():
+
+	# Anotate the fuction with the tool decorator from LangChain
+	@tool("Scrape website content")
+	def scrape_website(website):
+		# Write logic for the tool.
+		# In this case a function to scrape website content
+		url = f"https://chrome.browserless.io/content?token={config('BROWSERLESS_API_KEY')}"
+		payload = json.dumps({"url": website})
+		headers = {'cache-control': 'no-cache', 'content-type': 'application/json'}
+		response = requests.request("POST", url, headers=headers, data=payload)
+		elements = partition_html(text=response.text)
+		content = "\n\n".join([str(el) for el in elements])
+		return content[:5000]
+
+# Assign the scraping tool 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=[BrowserTools().scrape_website]
+)
+```
+
+## Using LangChain Tools
+!!! info "LangChain Integration"
+    CrewAI seamlessly integrates with LangChain’s comprehensive toolkit. Assigning an existing tool to an agent is straightforward:
+
+```python
+from crewai import Agent
+from langchain.agents import Tool
+from langchain.utilities import GoogleSerperAPIWrapper
+import os
+
+# Setup API keys
+os.environ["OPENAI_API_KEY"] = "Your Key"
+os.environ["SERPER_API_KEY"] = "Your Key"
+
+search = GoogleSerperAPIWrapper()
+
+# Create and assign the search tool to an agent
+serper_tool = Tool(
+  name="Intermediate Answer",
+  func=search.run,
+  description="Useful for search-based queries",
+)
+
+agent = Agent(
+  role='Research Analyst',
+  goal='Provide up-to-date market analysis',
+  backstory='An expert analyst with a keen eye for market trends.',
+  tools=[serper_tool]
+)
+```
+
+## Conclusion
+Tools are crucial for extending the capabilities of CrewAI agents, allowing them to undertake a diverse array of tasks and collaborate efficiently. When building your AI solutions with CrewAI, consider both custom and existing tools to empower your agents and foster a dynamic AI ecosystem.

docs/core-concepts/Understanding-Agents.md

@@ -1,41 +0,0 @@
-# What is an Agent?
-
-In CrewAI, an agent is an autonomous unit programmed to perform tasks, make decisions, and communicate with other agents. Think of an agent as a member of a team, with specific skills and a particular job to do. Agents can have different roles like 'Researcher', 'Writer', or 'Customer Support', each contributing to the overall goal of the crew.
-
-# Key Properties of an Agent
-
-- **Role**: Defines the agent's function within the crew. It determines the kind of tasks the agent is best suited for.
-- **Goal**: The individual objective that the agent aims to achieve. It guides the agent's decision-making process.
-- **Backstory**: Provides context to the agent's role and goal, enriching the interaction and collaboration dynamics.
-- **Tools**: A set of capabilities or functions that the agent can use to perform tasks. Tools can be shared or exclusive to specific agents.
-- **Verbose**: This allow you to actually see what is going on during the Crew execution.
-- **Allow Delegation**: Agents can delegate tasks or questions to one another, ensuring that each task is handled by the most suitable agent.
-
-# Agent Lifecycle
-
-1. **Initialization**: An agent is created with a defined role, goal, backstory, and set of tools.
-2. **Task Assignment**: The agent is assigned tasks either directly or through the crew's process management.
-3. **Execution**: The agent performs the task using its available tools and in accordance with its role and goal.
-4. **Collaboration**: Throughout the execution, the agent can communicate with other agents to delegate, inquire, or assist.
-
-# Creating an Agent
-
-To create an agent, you would typically initialize an instance of the `Agent` class with the desired properties. Here's a conceptual example:
-
-```python
-from crewai import Agent
-
-# Create an agent with a role and a goal
-agent = Agent(
-  role='Data Analyst',
-  goal='Extract actionable insights',
-  verbose=True,
-  backstory="You'er a data analyst at a large company. I am responsible for analyzing data and providing insights to the business. I am currently working on a project to analyze the performance of our marketing campaigns. I have been asked to provide insights on how to improve the performance of our marketing campaigns."
-)
-```
-
-# Agent Interaction
-Agents can interact with each other using the CrewAI's built-in delegation and communication mechanisms. This allows for dynamic task management and problem-solving within the crew.
-
-# Conclusion
-Agents are the building blocks of the CrewAI framework. By understanding how to define and interact with agents, you can create sophisticated AI systems that leverage the power of collaborative intelligence.

docs/getting-started.md

@@ -1,95 +0,0 @@
-# Getting Started
-
-To get started with CrewAI, follow these simple steps:
-
-1. **Installation**:
-
-```shell
-pip install crewai
-```
-
-The example below also uses duckduckgo, so also install that
-```shell
-pip install duckduckgo-search
-```
-
-2. **Setting Up Your Crew**:
-
-```python
-import os
-from crewai import Agent, Task, Crew, Process
-
-os.environ["OPENAI_API_KEY"] = "YOUR KEY"
-
-# You can choose to use a local model through Ollama for example. See ./docs/llm-connections.md for more information.
-# from langchain.llms import Ollama
-# ollama_llm = Ollama(model="openhermes")
-
-# Install duckduckgo-search for this example:
-# !pip install -U duckduckgo-search
-
-from langchain.tools import DuckDuckGoSearchRun
-search_tool = DuckDuckGoSearchRun()
-
-# Define your agents with roles and goals
-researcher = Agent(
-  role='Senior Research Analyst',
-  goal='Uncover cutting-edge developments in AI and data science',
-  backstory="""You work at a leading tech think tank.
-  Your expertise lies in identifying emerging trends.
-  You have a knack for dissecting complex data and presenting
-  actionable insights.""",
-  verbose=True,
-  allow_delegation=False,
-  tools=[search_tool]
-  # You can pass an optional llm attribute specifying what mode you wanna use.
-  # It can be a local model through Ollama / LM Studio or a remote
-  # model like OpenAI, Mistral, Antrophic of others (https://python.langchain.com/docs/integrations/llms/)
-  #
-  # Examples:
-  # llm=ollama_llm # was defined above in the file
-  # llm=ChatOpenAI(model_name="gpt-3.5", temperature=0.7)
-)
-writer = Agent(
-  role='Tech Content Strategist',
-  goal='Craft compelling content on tech advancements',
-  backstory="""You are a renowned Content Strategist, known for
-  your insightful and engaging articles.
-  You transform complex concepts into compelling narratives.""",
-  verbose=True,
-  allow_delegation=True,
-  # (optional) llm=ollama_llm
-)
-
-# Create tasks for your agents
-task1 = Task(
-  description="""Conduct a comprehensive analysis of the latest advancements in AI in 2024.
-  Identify key trends, breakthrough technologies, and potential industry impacts.
-  Your final answer MUST be a full analysis report""",
-  agent=researcher
-)
-
-task2 = Task(
-  description="""Using the insights provided, develop an engaging blog
-  post that highlights the most significant AI advancements.
-  Your post should be informative yet accessible, catering to a tech-savvy audience.
-  Make it sound cool, avoid complex words so it doesn't sound like AI.
-  Your final answer MUST be the full blog post of at least 4 paragraphs.""",
-  agent=writer
-)
-
-# Instantiate your crew with a sequential process
-crew = Crew(
-  agents=[researcher, writer],
-  tasks=[task1, task2],
-  verbose=2, # You can set it to 1 or 2 to different logging levels
-)
-
-# Get your crew to work!
-result = crew.kickoff()
-
-print("######################")
-print(result)
-```
-
-Currently the only supported process is `Process.sequential`, where one task is executed after the other and the outcome of one is passed as extra content into this next.

docs/how-to/Creating-a-Crew-and-kick-it-off.md

@@ -1,75 +1,112 @@
-# Get a crew working
+---
+title: Assembling and Activating Your CrewAI Team
+description: A step-by-step guide to creating a cohesive CrewAI team for your projects.
+---
 
-Assembling a Crew in CrewAI is like casting characters for a play. Each agent you create is a cast member with a unique part to play. When your crew is assembled, you'll give the signal, and they'll spring into action, each performing their role in the grand scheme of your project.
+## Introduction
+Embarking on your CrewAI journey involves a few straightforward steps to set up your environment and initiate your AI crew. This guide ensures a seamless start.
 
-# Step 1: Assemble Your Agents
+## Step 0: Installation
+Begin by installing CrewAI and any additional packages required for your project. For instance, the `duckduckgo-search` package is used in this example for enhanced search capabilities.
 
-Start by creating your agents, each with its own role and backstory. These backstories add depth to the agents, influencing how they approach their tasks and interact with one another.
+```shell
+pip install crewai
+pip install duckduckgo-search
+```
+
+## Step 1: Assemble Your Agents
+Begin by defining your agents with distinct roles and backstories. These elements not only add depth but also guide their task execution and interaction within the crew.
 
 ```python
+import os
+os.environ["OPENAI_API_KEY"] = "Your Key"
+
 from crewai import Agent
 
-# Create a researcher agent
+# Topic that will be used in the crew run
+topic = 'AI in healthcare'
+
+# Creating a senior researcher agent
 researcher = Agent(
   role='Senior Researcher',
-  goal='Discover groundbreaking technologies',
+  goal=f'Uncover groundbreaking technologies around {topic}',
   verbose=True,
-  backstory='A curious mind fascinated by cutting-edge innovation and the potential to change the world, you know everything about tech.'
+  backstory="""Driven by curiosity, you're at the forefront of
+  innovation, eager to explore and share knowledge that could change
+  the world."""
 )
 
-# Create a writer agent
+# Creating a writer agent
 writer = Agent(
   role='Writer',
-  goal='Craft compelling stories about tech discoveries',
+  goal=f'Narrate compelling tech stories around {topic}',
   verbose=True,
-  backstory='A creative soul who translates complex tech jargon into engaging narratives for the masses, you write using simple words in a friendly and inviting tone that does not sounds like AI.'
+  backstory="""With a flair for simplifying complex topics, you craft
+  engaging narratives that captivate and educate, bringing new
+  discoveries to light in an accessible manner."""
 )
 ```
 
-# Step 2: Define the Tasks
-
-Outline the tasks that your agents need to tackle. These tasks are their missions, the specific objectives they need to achieve.
+## Step 2: Define the Tasks
+Detail the specific objectives for your agents. These tasks guide their focus and ensure a targeted approach to their roles.
 
 ```python
 from crewai import Task
 
-# Task for the researcher
+# Install duckduckgo-search for this example:
+# !pip install -U duckduckgo-search
+
+from langchain_community.tools import DuckDuckGoSearchRun
+search_tool = DuckDuckGoSearchRun()
+
+# Research task for identifying AI trends
 research_task = Task(
-  description='Identify the next big trend in AI',
-  agent=researcher  # Assigning the task to the researcher
+  description=f"""Identify the next big trend in {topic}.
+  Focus on identifying pros and cons and the overall narrative.
+
+  Your final report should clearly articulate the key points,
+  its market opportunities, and potential risks.
+  """,
+  expected_output='A comprehensive 3 paragraphs long report on the latest AI trends.',
+  max_inter=3,
+  tools=[search_tool],
+  agent=researcher
 )
 
-# Task for the writer
+# Writing task based on research findings
 write_task = Task(
-  description='Write an article on AI advancements leveraging the research made.',
-  agent=writer  # Assigning the task to the writer
+  description=f"""Compose an insightful article on {topic}.
+  Focus on the latest trends and how it's impacting the industry.
+  This article should be easy to understand, engaging and positive.
+  """,
+  expected_output=f'A 4 paragraph article on {topic} advancements.',
+  tools=[search_tool],
+  agent=writer
 )
 ```
 
-# Step 3: Form the Crew
-
-Bring your agents together into a crew. This is where you define the process they'll follow to complete their tasks.
+## Step 3: Form the Crew
+Combine your agents into a crew, setting the workflow process they'll follow to accomplish the tasks.
 
 ```python
 from crewai import Crew, Process
 
-# Instantiate your crew
-tech_crew = Crew(
+# Forming the tech-focused crew
+crew = Crew(
   agents=[researcher, writer],
   tasks=[research_task, write_task],
-  process=Process.sequential  # Tasks will be executed one after the other
+  process=Process.sequential  # Sequential task execution
 )
 ```
 
-# Step 4: Kick It Off
-
-With the crew formed and the stage set, it's time to start the show. Kick off the process and watch as your agents collaborate to achieve their goals.
+## Step 4: Kick It Off
+With your crew ready and the stage set, initiate the process. Watch as your agents collaborate, each contributing their expertise to achieve the collective goal.
 
 ```python
-# Begin the task execution
-tech_crew.kickoff()
+# Starting the task execution process
+result = crew.kickoff()
+print(result)
 ```
 
-# Conclusion
-
-Creating a crew and setting it into motion is a straightforward process in CrewAI. With each agent playing their part and a clear set of tasks, your AI ensemble is ready to take on any challenge. Remember, the richness of their backstories and the clarity of their goals will greatly enhance their performance and the outcomes of their collaboration.
+## Conclusion
+Building and activating a crew in CrewAI is a seamless process. By carefully assigning roles, tasks, and a clear process, your AI team is equipped to tackle challenges efficiently. The depth of agent backstories and the precision of their objectives enrich the collaboration, leading to successful project outcomes.

docs/how-to/Customizing-Agents.md

@@ -1,45 +1,45 @@
-# Customizable Attributes
+---
+title: Customizing Agents in CrewAI
+description: A guide to tailoring agents for specific roles and tasks within the CrewAI framework.
+---
 
-Customizing your AI agents is a cornerstone of creating an effective CrewAI team. Each agent can be tailored to fit the unique needs of your project, allowing for a dynamic and versatile AI workforce.
+## Customizable Attributes
+Tailoring your AI agents is pivotal in crafting an efficient CrewAI team. Customization allows agents to be dynamically adapted to the unique requirements of any project.
 
-When you initialize an Agent, you can set various attributes that define its behavior and role within the Crew:
+### Key Attributes for Customization
+- **Role**: Defines the agent's job within the crew, such as 'Analyst' or 'Customer Service Rep'.
+- **Goal**: The agent's objective, aligned with its role and the crew's overall goals.
+- **Backstory**: Adds depth to the agent's character, enhancing its role and motivations within the crew.
+- **Tools**: The capabilities or methods the agent employs to accomplish tasks, ranging from simple functions to complex integrations.
 
-- **Role**: The job title or function of the agent within your crew. This can be anything from 'Analyst' to 'Customer Service Rep'.
-- **Goal**: What the agent is aiming to achieve. Goals should be aligned with the agent's role and the overall objectives of the crew.
-- **Backstory**: A narrative that provides depth to the agent's character. This could include previous experience, motivations, or anything that adds context to their role.
-- **Tools**: The abilities or methods the agent uses to complete tasks. This could be as simple as a 'search' function or as complex as a custom-built analysis tool.
+## Understanding Tools in CrewAI
+Tools empower agents with functionalities to interact and manipulate their environment, from generic utilities to specialized functions. Integrating with LangChain offers access to a broad range of tools for diverse tasks.
 
-# Understanding Tools in CrewAI
-
-Tools in CrewAI are functions that empower agents to interact with the world around them. These can range from generic utilities like a search function to more complex ones like integrating with an external API. The integration with LangChain allows you to utilize a suite of ready-to-use tools such as [Google Serper](https://python.langchain.com/docs/integrations/tools/google_serper), which enables agents to perform web searches and gather data.
-
-# Customizing Agents and Tools
-
-You can customize an agent by passing parameters when creating an instance. Each parameter tweaks how the agent behaves and interacts within the crew.
-
-Customizing an agent's tools is particularly important. Tools define what an agent can do and how it interacts with tasks. For instance, if a task requires data analysis, assigning an agent with data-related tools would be optimal.
-
-When initializing your agents, you can equip them with a set of tools that enable them to perform their roles more effectively:
+## Customizing Agents and Tools
+Agents are customized by defining their attributes during initialization, with tools being a critical aspect of their functionality.
 
+### Example: Assigning Tools to an Agent
 ```python
 from crewai import Agent
 from langchain.agents import Tool
 from langchain.utilities import GoogleSerperAPIWrapper
+import os
 
-# Initialize SerpAPI tool with your API key
+# Set API keys for tool initialization
 os.environ["OPENAI_API_KEY"] = "Your Key"
 os.environ["SERPER_API_KEY"] = "Your Key"
 
-search = GoogleSerperAPIWrapper()
+# Initialize a search tool
+search_tool = GoogleSerperAPIWrapper()
 
-# Create tool to be used by agent
+# Define and assign the tool to an agent
 serper_tool = Tool(
   name="Intermediate Answer",
-  func=search.run,
-  description="useful for when you need to ask with search",
+  func=search_tool.run,
+  description="Useful for search-based queries"
 )
 
-# Create an agent and assign the search tool
+# Initialize the agent with the tool
 agent = Agent(
   role='Research Analyst',
   goal='Provide up-to-date market analysis',
@@ -49,18 +49,17 @@ agent = Agent(
 ```
 
 ## Delegation and Autonomy
+Agents in CrewAI can delegate tasks or ask questions, enhancing the crew's collaborative dynamics. This feature can be disabled to ensure straightforward task execution.
 
-One of the most powerful aspects of CrewAI agents is their ability to delegate tasks to one another. Each agent by default can delegate work or ask question to anyone in the crew, but you can disable that by setting `allow_delegation` to `false`, this is particularly useful for straightforward agents that should execute their tasks in isolation.
-
+### Example: Disabling Delegation for an Agent
 ```python
 agent = Agent(
   role='Content Writer',
-  goal='Write the most amazing content related to market trends an business.',
-  backstory='An expert writer with many years of experience in market trends, stocks and all business related things.',
+  goal='Write engaging content on market trends',
+  backstory='A seasoned writer with expertise in market analysis.',
   allow_delegation=False
 )
 ```
 
 ## Conclusion
-
-Customization is what makes CrewAI powerful. By adjusting the attributes of each agent, you can ensure that your AI team is well-equipped to handle the challenges you set for them. Remember, the more thought you put into your agents' roles, goals, backstories, and tools, the more nuanced and effective their interactions and task execution will be.
+Customizing agents is key to leveraging the full potential of CrewAI. By thoughtfully setting agents' roles, goals, backstories, and tools, you craft a nuanced and capable AI team ready to tackle complex challenges.

docs/how-to/Hierarchical.md

@@ -0,0 +1,60 @@
+---
+title: Implementing the Hierarchical Process in CrewAI
+description: Understanding and applying the hierarchical process within your CrewAI projects.
+---
+
+## Introduction
+The hierarchical process in CrewAI introduces a structured approach to task management, mimicking traditional organizational hierarchies for efficient task delegation and execution.
+
+!!! note "Complexity"
+	The current implementation of the hierarchical process relies on tools usage that usually require more complex models like GPT-4 and usually imply of a higher token usage.
+
+## Hierarchical Process Overview
+In this process, tasks are assigned and executed based on a defined hierarchy, where a 'manager' agent coordinates the workflow, delegating tasks to other agents and validating their outcomes before proceeding.
+
+### Key Features
+- **Task Delegation**: A manager agent oversees task distribution among crew members.
+- **Result Validation**: The manager reviews outcomes before passing tasks along, ensuring quality and relevance.
+- **Efficient Workflow**: Mimics corporate structures for a familiar and organized task management approach.
+
+## Implementing the Hierarchical Process
+To utilize the hierarchical process, you must define a crew with a designated manager and a clear chain of command for task execution.
+
+!!! note "Tools on the hierarchical process"
+	For tools when using the hierarchical process, you want to make sure to assign them to the agents instead of the tasks, as the manager will be the one delegating the tasks and the agents will be the ones executing them.
+
+!!! note "Manager LLM"
+	A manager will be automatically set for the crew, you don't need to define it. You do need to set the `manager_llm` parameter in the crew though.
+
+```python
+from langchain_openai import ChatOpenAI
+from crewai import Crew, Process, Agent
+
+# Define your agents, no need to define a manager
+researcher = Agent(
+	role='Researcher',
+	goal='Conduct in-depth analysis',
+	# tools = [...]
+)
+writer = Agent(
+	role='Writer',
+	goal='Create engaging content',
+	# tools = [...]
+)
+
+# Form the crew with a hierarchical process
+project_crew = Crew(
+	tasks=[...], # Tasks that that manager will figure out how to complete
+	agents=[researcher, writer],
+	manager_llm=ChatOpenAI(temperature=0, model="gpt-4"), # The manager's LLM that will be used internally
+	process=Process.hierarchical  # Designating the hierarchical approach
+)
+```
+
+### Workflow in Action
+1. **Task Assignment**: The manager assigns tasks based on agent roles and capabilities.
+2. **Execution and Review**: Agents perform their tasks, with the manager reviewing outcomes for approval.
+3. **Sequential Task Progression**: Tasks are completed in a sequence dictated by the manager, ensuring orderly progression.
+
+## Conclusion
+The hierarchical process in CrewAI offers a familiar, structured way to manage tasks within a project. By leveraging a chain of command, it enhances efficiency and quality control, making it ideal for complex projects requiring meticulous oversight.

docs/how-to/Human-Input-on-Execution.md

@@ -1,7 +1,7 @@
 # Human Input on Execution
 
 Human inputs is important in many agent execution use cases, humans are AGI so they can can be prompted to step in and provide extra details ins necessary.
-Using it with crewAI is pretty straightforward and you can do it through a LangChain Tool. 
+Using it with crewAI is pretty straightforward and you can do it through a LangChain Tool.
 Check [LangChain Integration](https://python.langchain.com/docs/integrations/tools/human_tools) for more details:
 
 Example:
@@ -9,7 +9,7 @@ Example:
 ```python
 import os
 from crewai import Agent, Task, Crew, Process
-from langchain.tools import DuckDuckGoSearchRun
+from langchain_community.tools import DuckDuckGoSearchRun
 from langchain.agents import load_tools
 
 search_tool = DuckDuckGoSearchRun()
@@ -45,7 +45,7 @@ writer = Agent(
 task1 = Task(
   description="""Conduct a comprehensive analysis of the latest advancements in AI in 2024.
   Identify key trends, breakthrough technologies, and potential industry impacts.
-  Compile your findings in a detailed report. 
+  Compile your findings in a detailed report.
   Make sure to check with the human if the draft is good before returning your Final Answer.
   Your final answer MUST be a full analysis report""",
   agent=researcher
@@ -56,7 +56,7 @@ task2 = Task(
   post that highlights the most significant AI advancements.
   Your post should be informative yet accessible, catering to a tech-savvy audience.
   Aim for a narrative that captures the essence of these breakthroughs and their
-  implications for the future. 
+  implications for the future.
   Your final answer MUST be the full blog post of at least 3 paragraphs.""",
   agent=writer
 )

docs/how-to/LLM-Connections.md

@@ -1,147 +1,69 @@
-# Connect CrewAI to LLMs
+---
+title: Connect CrewAI to LLMs
+description: Guide on integrating CrewAI with various Large Language Models (LLMs).
+---
 
-There are different types of connections.
-Ollama is the recommended way to connect to local LLMs.
-Azure uses a slightly different API and therefore has it's own connection object.
+## Connect CrewAI to LLMs
+!!! note "Default LLM"
+    By default, crewAI uses OpenAI's GPT-4 model for language processing. However, you can configure your agents to use a different model or API. This guide will show you how to connect your agents to different LLMs.
 
-crewAI is compatible with any of the LangChain LLM components. See this page for more information: https://python.langchain.com/docs/integrations/llms/
+CrewAI offers flexibility in connecting to various LLMs, including local models via [Ollama](https://ollama.ai) and different APIs like Azure. It's compatible with all [LangChain LLM](https://python.langchain.com/docs/integrations/llms/) components, enabling diverse integrations for tailored AI solutions.
 
-## Ollama
-
-crewAI supports integration with local models thorugh [Ollama](https://ollama.ai/) for enhanced flexibility and customization. This allows you to utilize your own models, which can be particularly useful for specialized tasks or data privacy concerns. We will conver other options for using local models in later sections. However, ollama is the recommended tool to use to host local models when possible.
+## Ollama Integration
+Ollama is preferred for local LLM integration, offering customization and privacy benefits. It requires installation and configuration, including model adjustments via a Modelfile to optimize performance.
 
 ### Setting Up Ollama
-
-- **Install Ollama**: Ensure that Ollama is properly installed in your environment. Follow the installation guide provided by Ollama for detailed instructions.
-- **Configure Ollama**: Set up Ollama to work with your local model. You will probably need to [tweak the model using a Modelfile](https://github.com/jmorganca/ollama/blob/main/docs/modelfile.md). I'd recommend adding `Observation` as a stop word and playing with `top_p` and `temperature`.
+- **Installation**: Follow Ollama's guide for setup.
+- **Configuration**: [Adjust your local model with a Modelfile](https://github.com/jmorganca/ollama/blob/main/docs/modelfile.md), considering adding `Observation` as a stop word and playing with parameters like `top_p` and `temperature`.
 
 ### Integrating Ollama with CrewAI
-- Instantiate Ollama Model: Create an instance of the Ollama model. You can specify the model and the base URL during instantiation. For example:
+Instantiate Ollama and pass it to your agents within CrewAI, enhancing them with the local model's capabilities.
 
 ```python
-from langchain.llms import Ollama
+from langchain_community.llms import Ollama
+
+# Assuming you have Ollama installed and downloaded the openhermes model
 ollama_openhermes = Ollama(model="openhermes")
-# Pass Ollama Model to Agents: When creating your agents within the CrewAI framework, you can pass the Ollama model as an argument to the Agent constructor. For instance:
 
 local_expert = Agent(
-  role='Local Expert at this city',
-  goal='Provide the BEST insights about the selected city',
-  backstory="""A knowledgeable local guide with extensive information
-  about the city, it's attractions and customs""",
-  tools=[
-    SearchTools.search_internet,
-    BrowserTools.scrape_and_summarize_website,
-  ],
-  llm=ollama_openhermes, # Ollama model passed here
+  role='Local Expert',
+  goal='Provide insights about the city',
+  backstory="A knowledgeable local guide.",
+  tools=[SearchTools.search_internet, BrowserTools.scrape_and_summarize_website],
+  llm=ollama_openhermes,
   verbose=True
 )
 ```
 
-## Open AI Compatible API Endpoints
+## OpenAI Compatible API Endpoints
+You can use environment variables for easy switch between APIs and models, supporting diverse platforms like FastChat, LM Studio, and Mistral AI.
 
-In the context of integrating various language models with CrewAI, the flexibility to switch between different API endpoints is a crucial feature. By utilizing environment variables for configuration details such as `OPENAI_API_BASE_URL`, `OPENAI_API_KEY`, and `MODEL_NAME`, you can easily transition between different APIs or models. For instance, if you want to switch from using the standard OpenAI GPT model to a custom or alternative version, simply update the values of these environment variables. 
-
-The `OPENAI_API_BASE_URL` variable allows you to define the base URL of the API to connect to, while `OPENAI_API_KEY` is used for authentication purposes. Lastly, the `MODEL_NAME` variable specifies the particular language model to be used, such as "gpt-3.5-turbo" or any other available model. 
-
-This method offers an easy way to adapt the system to different models or plataforms, be it for testing, scaling, or accessing different features available on various platforms. By centralizing the configuration in environment variables, the process becomes streamlined, reducing the need for extensive code modifications when switching between APIs or models.
-
-
-```python
-from dotenv import load_dotenv
-from langchain.chat_models.openai import ChatOpenAI
-
-load_dotenv()
-
-defalut_llm = ChatOpenAI(openai_api_base=os.environ.get("OPENAI_API_BASE_URL", "https://api.openai.com/v1"),
-                        openai_api_key=os.environ.get("OPENAI_API_KEY", "NA"),
-                        model_name=os.environ.get("MODEL_NAME", "gpt-3.5-turbo"))
-
-# Create an agent and assign the LLM
-example_agent = Agent(
-  role='Example Agent',
-  goal='Show how to assign a custom configured LLM',
-  backstory='You hang out in the docs section of GitHub repos.',
-  llm=default_llm
-)
-
-```
-
-The following sections show examples of the configuration settings for various OpenAI API compatible applications and services. We have included links to relavant documentation for the various application and services. 
-
-
-### Open AI
-
-OpenAI is the default LLM that will be used if you do not specify a value for the `llm` argument when creating an agent. It will also use default values for the `OPENAI_API_BASE_URL` and `MODEL_NAME`. So the only value you need to set when using the OpenAI endpoint is the API key that from your account.
-
-```sh
-# Required
-OPENAI_API_KEY="sk-..."
-
-# Optional
-OPENAI_API_BASE_URL=https://api.openai.com/v1
-MODEL_NAME="gpt-3.5-turbo"
-```
+### Configuration Examples
 
 ### FastChat
-
-FastChat is an open platform for training, serving, and evaluating large language model based chatbots.
-
-[GitHub](https://github.com/lm-sys/FastChat)
-
-[API Documentation](https://github.com/lm-sys/FastChat?tab=readme-ov-file#api)
-
-Configuration settings:
 ```sh
 # Required
-OPENAI_API_BASE_URL="http://localhost:8001/v1"
+OPENAI_API_BASE="http://localhost:8001/v1"
 OPENAI_API_KEY=NA
-MODEL_NAME='oh-2.5m7b-q51'
+MODEL_NAME='oh-2.5m7b-q51' # Depending on the model you have available
 ```
 
 ### LM Studio
-
-Discover, download, and run local LLMs
-
-[lmstudio.ai](https://lmstudio.ai/)
-
-
-
-Configuration settings:
 ```sh
 # Required
-OPENAI_API_BASE_URL="http://localhost:8000/v1"
-
+OPENAI_API_BASE="http://localhost:8000/v1"
 OPENAI_API_KEY=NA
 MODEL_NAME=NA
 ```
 
-
 ### Mistral API
-
-Mistral AI's API endpoints 
-
-[Mistral AI](https://mistral.ai/)
-
-[Documentation](https://docs.mistral.ai/)
-
 ```sh
 OPENAI_API_KEY=your-mistral-api-key
 OPENAI_API_BASE=https://api.mistral.ai/v1
 MODEL_NAME="mistral-small" # Check documentation for available models
 ```
 
-
-
 ### text-gen-web-ui
-
-A Gradio web UI for Large Language Models.
-
-[GitHub](https://github.com/oobabooga/text-generation-webui)
-
-[API Documentation](https://github.com/oobabooga/text-generation-webui/wiki/12-%E2%80%90-OpenAI-API)
-
-Configuration settings:
-
 ```sh
 # Required
 API_BASE_URL=http://localhost:5000
@@ -149,39 +71,8 @@ OPENAI_API_KEY=NA
 MODEL_NAME=NA
 ```
 
-## Other Inference API Endpoints
-
-Other platforms offer inference APIs such as Anthropic, Azure, and HuggingFace to name a few. Unfortunately, the APIs on the following platforms are not compatible with the OpenAI API specification. So, the following platforms will require a slightly different configuration than the examples in the previous section.
-
 ### Azure Open AI
-
-Azure hosted OpenAI API endpoints have their own LLM component that needs to be imported from `langchain_openai`.
-
-For more information, check out the langchain documenation for [Azure OpenAI](https://python.langchain.com/docs/integrations/llms/azure_openai).
-
-```python
-from dotenv import load_dotenv
-from langchain_openai import AzureChatOpenAI
-
-load_dotenv()
-
-default_llm = AzureChatOpenAI(
-    openai_api_version=os.environ.get("AZURE_OPENAI_VERSION", "2023-07-01-preview"),
-    azure_deployment=os.environ.get("AZURE_OPENAI_DEPLOYMENT", "gpt35"),
-    azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT", "https://<your-endpoint>.openai.azure.com/"),
-    api_key=os.environ.get("AZURE_OPENAI_KEY")
-)
-
-# Create an agent and assign the LLM
-example_agent = Agent(
-  role='Example Agent',
-  goal='Show how to assign a custom configured LLM',
-  backstory='You hang out in the docs section of GitHub repos.',
-  llm=default_llm
-)
-
-```
-
+Azure's OpenAI API needs a distinct setup, utilizing the `langchain_openai` component for Azure-specific configurations.
 
 Configuration settings:
 ```sh
@@ -190,3 +81,25 @@ AZURE_OPENAI_DEPLOYMENT=""
 AZURE_OPENAI_ENDPOINT=""
 AZURE_OPENAI_KEY=""
 ```
+
+```python
+from dotenv import load_dotenv
+from langchain_openai import AzureChatOpenAI
+
+load_dotenv()
+
+default_llm = AzureChatOpenAI(
+    azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
+    api_key=os.environ.get("AZURE_OPENAI_KEY")
+)
+
+example_agent = Agent(
+  role='Example Agent',
+  goal='Demonstrate custom LLM configuration',
+  backstory='A diligent explorer of GitHub docs.',
+  llm=default_llm
+)
+```
+
+## Conclusion
+Integrating CrewAI with different LLMs expands the framework's versatility, allowing for customized, efficient AI solutions across various domains and platforms.

docs/how-to/Sequential.md

@@ -0,0 +1,50 @@
+---
+title: Implementing the Sequential Process in CrewAI
+description: A guide to utilizing the sequential process for task execution in CrewAI projects.
+---
+
+## Introduction
+The sequential process in CrewAI ensures tasks are executed one after the other, following a linear progression. This approach is akin to a relay race, where each agent completes their task before passing the baton to the next.
+
+## Sequential Process Overview
+This process is straightforward and effective, particularly for projects where tasks must be completed in a specific order to achieve the desired outcome.
+
+### Key Features
+- **Linear Task Flow**: Tasks are handled in a predetermined sequence, ensuring orderly progression.
+- **Simplicity**: Ideal for projects with clearly defined, step-by-step tasks.
+- **Easy Monitoring**: Task completion can be easily tracked, offering clear insights into project progress.
+
+## Implementing the Sequential Process
+To apply the sequential process, assemble your crew and define the tasks in the order they need to be executed.
+
+!!! note "Task assignment"
+	In the sequential process you need to make sure all tasks are assigned to the agents, as the agents will be the ones executing them.
+
+```python
+from crewai import Crew, Process, Agent, Task
+
+# Define your agents
+researcher = Agent(role='Researcher', goal='Conduct foundational research')
+analyst = Agent(role='Data Analyst', goal='Analyze research findings')
+writer = Agent(role='Writer', goal='Draft the final report')
+
+# Define the tasks in sequence
+research_task = Task(description='Gather relevant data', agent=researcher)
+analysis_task = Task(description='Analyze the data', agent=analyst)
+writing_task = Task(description='Compose the report', agent=writer)
+
+# Form the crew with a sequential process
+report_crew = Crew(
+  agents=[researcher, analyst, writer],
+  tasks=[research_task, analysis_task, writing_task],
+  process=Process.sequential
+)
+```
+
+### Workflow in Action
+1. **Initial Task**: The first agent completes their task and signals completion.
+2. **Subsequent Tasks**: Following agents pick up their tasks in the order defined, using the outcomes of preceding tasks as inputs.
+3. **Completion**: The process concludes once the final task is executed, culminating in the project's completion.
+
+## Conclusion
+The sequential process in CrewAI provides a clear, straightforward path for task execution. It's particularly suited for projects requiring a logical progression of tasks, ensuring each step is completed before the next begins, thereby facilitating a cohesive final product.

docs/index.md

@@ -1,36 +1,113 @@
-<img src='./crewai_logo.png' width='250'/>
+<img src='./crew_only_logo.png' width='250' class='mb-10'/>
 
-# Welcome to crewAI Documentation
-🤖 Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.
+# crewAI Documentation
 
-<p align="center">
-    <img src='./crewAI-mindmap.png' />
-</p>
+Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.
 
-## Core Concepts
-- [Understanding Agents](./core-concepts/Understanding-Agents.md)
-- [Creating Tasks](./core-concepts/Creating-Tasks.md)
-- [Defining Tasks](./core-concepts/Defining-Tasks.md)
-- [Managing Processes](./core-concepts/Managing-Processes.md)
-- [Collaboration and Delegation](./core-concepts/Delegation-and-Collaboration.md)
-- [Agent Tools](./core-concepts/Agent-Tools.md)
-
-## How-To Guides
-- [Connecting to LLMs](./how-to/LLM-Connections.md)
-- [Customizing Agents](./how-to/Customizing-Agents.md)
-- [Creating a Crew and kick it off](./how-to/Creating-a-Crew-and-kick-it-off.md)
-- [Human Input on Execution](./how-to/Human-Input-on-Execution.md)
-
-## Examples and Tutorials
-You can test different real life examples of AI crews [in the examples repo](https://github.com/joaomdmoura/crewAI-examples)
-
-- [Trip Planner](https://github.com/joaomdmoura/crewAI-examples/tree/main/trip_planner)
-- [Stock Analysis](https://github.com/joaomdmoura/crewAI-examples/tree/main/stock_analysis)
-- [Landing Page Generator](https://github.com/joaomdmoura/crewAI-examples/tree/main/landing_page_generator)
-- [Having Human input on the execution](./how-to/Human-Input-on-Execution.md)
-
-## API Reference
-- [Agent API](#agent-api)[WIP]
-- [Task API](#task-api)[WIP]
-- [Crew API](#crew-api)[WIP]
-- [Process API](#process-api)[WIP]
+<div style="display:flex; margin:0 auto; justify-content: center;">
+    <div style="width:25%">
+        <h2>Core Concepts</h2>
+        <ul>
+            <li>
+                <a href="./core-concepts/Agents">
+                    Agents
+                </a>
+            </li>
+            <li>
+                <a href="./core-concepts/Tasks">
+                    Tasks
+                </a>
+            </li>
+            <li>
+                <a href="./core-concepts/Tools">
+                    Tools
+                </a>
+            </li>
+            <li>
+                <a href="./core-concepts/Processes">
+                    Processes
+                </a>
+            </li>
+            <li>
+                <a href="./core-concepts/Crews">
+                    Crews
+                </a>
+            </li>
+        </ul>
+    </div>
+    <div style="width:30%">
+        <h2>How-To Guides</h2>
+        <ul>
+            <li>
+                <a href="./how-to/Creating-a-Crew-and-kick-it-off">
+                    Getting Started
+                </a>
+            </li>
+            <li>
+                <a href="./how-to/how-to/Sequential">
+                    Using Sequential Process
+                </a>
+            </li>
+            <li>
+                <a href="./how-to/Hierarchical">
+                    Using Hierarchical Process
+                </a>
+            </li>
+            <li>
+                <a href="./how-to/LLM-Connections">
+                    Connecting to LLMs
+                </a>
+            </li>
+            <li>
+                <a href="./how-to/Customizing-Agents">
+                    Customizing Agents
+                </a>
+            </li>
+            <li>
+                <a href="./how-to/Human-Input-on-Execution">
+                    Human Input on Execution
+                </a>
+            </li>
+        </ul>
+    </div>
+    <div style="width:30%">
+        <h2>Examples</h2>
+        <ul>
+            <li>
+                <a target='_blank' href="https://github.com/joaomdmoura/crewAI-examples/tree/main/prep-for-a-meeting">
+                    Prepare for meetings
+                </a>
+            </li>
+            <li>
+                <a target='_blank' href="https://github.com/joaomdmoura/crewAI-examples/tree/main/trip_planner">
+                    Trip Planner Crew
+                </a>
+            </li>
+            <li>
+                <a target='_blank' href="https://github.com/joaomdmoura/crewAI-examples/tree/main/instagram_post">
+                    Create Instagram Post
+                </a>
+            </li>
+            <li>
+                <a target='_blank' href="https://github.com/joaomdmoura/crewAI-examples/tree/main/stock_analysis">
+                    Stock Analysis
+                </a>
+            </li>
+            <li>
+                <a target='_blank' href="https://github.com/joaomdmoura/crewAI-examples/tree/main/game-builder-crew">
+                    Game Generator
+                </a>
+            </li>
+            <li>
+                <a target='_blank' href="https://github.com/joaomdmoura/crewAI-examples/tree/main/CrewAI-LangGraph">
+                    Drafting emails with LangGraph
+                </a>
+            </li>
+            <li>
+                <a target='_blank' href="https://github.com/joaomdmoura/crewAI-examples/tree/main/landing_page_generator">
+                    Landing Page Generator
+                </a>
+            </li>
+        </ul>
+    </div>
+</div>

docs/postcss.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  plugins: [require('tailwindcss'), require('autoprefixer')]
+}

docs/stylesheets/extra.css

@@ -0,0 +1,3 @@
+.md-typeset .admonition-title {
+  margin-bottom: 10px;
+}

docs/stylesheets/output.css

@@ -0,0 +1,565 @@
+/*
+! tailwindcss v3.4.1 | MIT License | https://tailwindcss.com
+*/
+
+/*
+1. Prevent padding and border from affecting element width. (https://github.com/mozdevs/cssremedy/issues/4)
+2. Allow adding a border to an element by just adding a border-width. (https://github.com/tailwindcss/tailwindcss/pull/116)
+*/
+
+*,
+::before,
+::after {
+  box-sizing: border-box;
+  /* 1 */
+  border-width: 0;
+  /* 2 */
+  border-style: solid;
+  /* 2 */
+  border-color: #e5e7eb;
+  /* 2 */
+}
+
+::before,
+::after {
+  --tw-content: '';
+}
+
+/*
+1. Use a consistent sensible line-height in all browsers.
+2. Prevent adjustments of font size after orientation changes in iOS.
+3. Use a more readable tab size.
+4. Use the user's configured `sans` font-family by default.
+5. Use the user's configured `sans` font-feature-settings by default.
+6. Use the user's configured `sans` font-variation-settings by default.
+7. Disable tap highlights on iOS
+*/
+
+html,
+:host {
+  line-height: 1.5;
+  /* 1 */
+  -webkit-text-size-adjust: 100%;
+  /* 2 */
+  -moz-tab-size: 4;
+  /* 3 */
+  -o-tab-size: 4;
+     tab-size: 4;
+  /* 3 */
+  font-family: ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+  /* 4 */
+  font-feature-settings: normal;
+  /* 5 */
+  font-variation-settings: normal;
+  /* 6 */
+  -webkit-tap-highlight-color: transparent;
+  /* 7 */
+}
+
+/*
+1. Remove the margin in all browsers.
+2. Inherit line-height from `html` so users can set them as a class directly on the `html` element.
+*/
+
+body {
+  margin: 0;
+  /* 1 */
+  line-height: inherit;
+  /* 2 */
+}
+
+/*
+1. Add the correct height in Firefox.
+2. Correct the inheritance of border color in Firefox. (https://bugzilla.mozilla.org/show_bug.cgi?id=190655)
+3. Ensure horizontal rules are visible by default.
+*/
+
+hr {
+  height: 0;
+  /* 1 */
+  color: inherit;
+  /* 2 */
+  border-top-width: 1px;
+  /* 3 */
+}
+
+/*
+Add the correct text decoration in Chrome, Edge, and Safari.
+*/
+
+abbr:where([title]) {
+  -webkit-text-decoration: underline dotted;
+          text-decoration: underline dotted;
+}
+
+/*
+Remove the default font size and weight for headings.
+*/
+
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  font-size: inherit;
+  font-weight: inherit;
+}
+
+/*
+Reset links to optimize for opt-in styling instead of opt-out.
+*/
+
+a {
+  color: inherit;
+  text-decoration: inherit;
+}
+
+/*
+Add the correct font weight in Edge and Safari.
+*/
+
+b,
+strong {
+  font-weight: bolder;
+}
+
+/*
+1. Use the user's configured `mono` font-family by default.
+2. Use the user's configured `mono` font-feature-settings by default.
+3. Use the user's configured `mono` font-variation-settings by default.
+4. Correct the odd `em` font sizing in all browsers.
+*/
+
+code,
+kbd,
+samp,
+pre {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+  /* 1 */
+  font-feature-settings: normal;
+  /* 2 */
+  font-variation-settings: normal;
+  /* 3 */
+  font-size: 1em;
+  /* 4 */
+}
+
+/*
+Add the correct font size in all browsers.
+*/
+
+small {
+  font-size: 80%;
+}
+
+/*
+Prevent `sub` and `sup` elements from affecting the line height in all browsers.
+*/
+
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+/*
+1. Remove text indentation from table contents in Chrome and Safari. (https://bugs.chromium.org/p/chromium/issues/detail?id=999088, https://bugs.webkit.org/show_bug.cgi?id=201297)
+2. Correct table border color inheritance in all Chrome and Safari. (https://bugs.chromium.org/p/chromium/issues/detail?id=935729, https://bugs.webkit.org/show_bug.cgi?id=195016)
+3. Remove gaps between table borders by default.
+*/
+
+table {
+  text-indent: 0;
+  /* 1 */
+  border-color: inherit;
+  /* 2 */
+  border-collapse: collapse;
+  /* 3 */
+}
+
+/*
+1. Change the font styles in all browsers.
+2. Remove the margin in Firefox and Safari.
+3. Remove default padding in all browsers.
+*/
+
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit;
+  /* 1 */
+  font-feature-settings: inherit;
+  /* 1 */
+  font-variation-settings: inherit;
+  /* 1 */
+  font-size: 100%;
+  /* 1 */
+  font-weight: inherit;
+  /* 1 */
+  line-height: inherit;
+  /* 1 */
+  color: inherit;
+  /* 1 */
+  margin: 0;
+  /* 2 */
+  padding: 0;
+  /* 3 */
+}
+
+/*
+Remove the inheritance of text transform in Edge and Firefox.
+*/
+
+button,
+select {
+  text-transform: none;
+}
+
+/*
+1. Correct the inability to style clickable types in iOS and Safari.
+2. Remove default button styles.
+*/
+
+button,
+[type='button'],
+[type='reset'],
+[type='submit'] {
+  -webkit-appearance: button;
+  /* 1 */
+  background-color: transparent;
+  /* 2 */
+  background-image: none;
+  /* 2 */
+}
+
+/*
+Use the modern Firefox focus style for all focusable elements.
+*/
+
+:-moz-focusring {
+  outline: auto;
+}
+
+/*
+Remove the additional `:invalid` styles in Firefox. (https://github.com/mozilla/gecko-dev/blob/2f9eacd9d3d995c937b4251a5557d95d494c9be1/layout/style/res/forms.css#L728-L737)
+*/
+
+:-moz-ui-invalid {
+  box-shadow: none;
+}
+
+/*
+Add the correct vertical alignment in Chrome and Firefox.
+*/
+
+progress {
+  vertical-align: baseline;
+}
+
+/*
+Correct the cursor style of increment and decrement buttons in Safari.
+*/
+
+::-webkit-inner-spin-button,
+::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/*
+1. Correct the odd appearance in Chrome and Safari.
+2. Correct the outline style in Safari.
+*/
+
+[type='search'] {
+  -webkit-appearance: textfield;
+  /* 1 */
+  outline-offset: -2px;
+  /* 2 */
+}
+
+/*
+Remove the inner padding in Chrome and Safari on macOS.
+*/
+
+::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/*
+1. Correct the inability to style clickable types in iOS and Safari.
+2. Change font properties to `inherit` in Safari.
+*/
+
+::-webkit-file-upload-button {
+  -webkit-appearance: button;
+  /* 1 */
+  font: inherit;
+  /* 2 */
+}
+
+/*
+Add the correct display in Chrome and Safari.
+*/
+
+summary {
+  display: list-item;
+}
+
+/*
+Removes the default spacing and border for appropriate elements.
+*/
+
+blockquote,
+dl,
+dd,
+h1,
+h2,
+h3,
+h4,
+h5,
+h6,
+hr,
+figure,
+p,
+pre {
+  margin: 0;
+}
+
+fieldset {
+  margin: 0;
+  padding: 0;
+}
+
+legend {
+  padding: 0;
+}
+
+ol,
+ul,
+menu {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+
+/*
+Reset default styling for dialogs.
+*/
+
+dialog {
+  padding: 0;
+}
+
+/*
+Prevent resizing textareas horizontally by default.
+*/
+
+textarea {
+  resize: vertical;
+}
+
+/*
+1. Reset the default placeholder opacity in Firefox. (https://github.com/tailwindlabs/tailwindcss/issues/3300)
+2. Set the default placeholder color to the user's configured gray 400 color.
+*/
+
+input::-moz-placeholder, textarea::-moz-placeholder {
+  opacity: 1;
+  /* 1 */
+  color: #9ca3af;
+  /* 2 */
+}
+
+input::placeholder,
+textarea::placeholder {
+  opacity: 1;
+  /* 1 */
+  color: #9ca3af;
+  /* 2 */
+}
+
+/*
+Set the default cursor for buttons.
+*/
+
+button,
+[role="button"] {
+  cursor: pointer;
+}
+
+/*
+Make sure disabled buttons don't get the pointer cursor.
+*/
+
+:disabled {
+  cursor: default;
+}
+
+/*
+1. Make replaced elements `display: block` by default. (https://github.com/mozdevs/cssremedy/issues/14)
+2. Add `vertical-align: middle` to align replaced elements more sensibly by default. (https://github.com/jensimmons/cssremedy/issues/14#issuecomment-634934210)
+   This can trigger a poorly considered lint error in some tools but is included by design.
+*/
+
+img,
+svg,
+video,
+canvas,
+audio,
+iframe,
+embed,
+object {
+  display: block;
+  /* 1 */
+  vertical-align: middle;
+  /* 2 */
+}
+
+/*
+Constrain images and videos to the parent width and preserve their intrinsic aspect ratio. (https://github.com/mozdevs/cssremedy/issues/14)
+*/
+
+img,
+video {
+  max-width: 100%;
+  height: auto;
+}
+
+/* Make elements with the HTML hidden attribute stay hidden by default */
+
+[hidden] {
+  display: none;
+}
+
+*, ::before, ::after {
+  --tw-border-spacing-x: 0;
+  --tw-border-spacing-y: 0;
+  --tw-translate-x: 0;
+  --tw-translate-y: 0;
+  --tw-rotate: 0;
+  --tw-skew-x: 0;
+  --tw-skew-y: 0;
+  --tw-scale-x: 1;
+  --tw-scale-y: 1;
+  --tw-pan-x:  ;
+  --tw-pan-y:  ;
+  --tw-pinch-zoom:  ;
+  --tw-scroll-snap-strictness: proximity;
+  --tw-gradient-from-position:  ;
+  --tw-gradient-via-position:  ;
+  --tw-gradient-to-position:  ;
+  --tw-ordinal:  ;
+  --tw-slashed-zero:  ;
+  --tw-numeric-figure:  ;
+  --tw-numeric-spacing:  ;
+  --tw-numeric-fraction:  ;
+  --tw-ring-inset:  ;
+  --tw-ring-offset-width: 0px;
+  --tw-ring-offset-color: #fff;
+  --tw-ring-color: rgb(59 130 246 / 0.5);
+  --tw-ring-offset-shadow: 0 0 #0000;
+  --tw-ring-shadow: 0 0 #0000;
+  --tw-shadow: 0 0 #0000;
+  --tw-shadow-colored: 0 0 #0000;
+  --tw-blur:  ;
+  --tw-brightness:  ;
+  --tw-contrast:  ;
+  --tw-grayscale:  ;
+  --tw-hue-rotate:  ;
+  --tw-invert:  ;
+  --tw-saturate:  ;
+  --tw-sepia:  ;
+  --tw-drop-shadow:  ;
+  --tw-backdrop-blur:  ;
+  --tw-backdrop-brightness:  ;
+  --tw-backdrop-contrast:  ;
+  --tw-backdrop-grayscale:  ;
+  --tw-backdrop-hue-rotate:  ;
+  --tw-backdrop-invert:  ;
+  --tw-backdrop-opacity:  ;
+  --tw-backdrop-saturate:  ;
+  --tw-backdrop-sepia:  ;
+}
+
+::backdrop {
+  --tw-border-spacing-x: 0;
+  --tw-border-spacing-y: 0;
+  --tw-translate-x: 0;
+  --tw-translate-y: 0;
+  --tw-rotate: 0;
+  --tw-skew-x: 0;
+  --tw-skew-y: 0;
+  --tw-scale-x: 1;
+  --tw-scale-y: 1;
+  --tw-pan-x:  ;
+  --tw-pan-y:  ;
+  --tw-pinch-zoom:  ;
+  --tw-scroll-snap-strictness: proximity;
+  --tw-gradient-from-position:  ;
+  --tw-gradient-via-position:  ;
+  --tw-gradient-to-position:  ;
+  --tw-ordinal:  ;
+  --tw-slashed-zero:  ;
+  --tw-numeric-figure:  ;
+  --tw-numeric-spacing:  ;
+  --tw-numeric-fraction:  ;
+  --tw-ring-inset:  ;
+  --tw-ring-offset-width: 0px;
+  --tw-ring-offset-color: #fff;
+  --tw-ring-color: rgb(59 130 246 / 0.5);
+  --tw-ring-offset-shadow: 0 0 #0000;
+  --tw-ring-shadow: 0 0 #0000;
+  --tw-shadow: 0 0 #0000;
+  --tw-shadow-colored: 0 0 #0000;
+  --tw-blur:  ;
+  --tw-brightness:  ;
+  --tw-contrast:  ;
+  --tw-grayscale:  ;
+  --tw-hue-rotate:  ;
+  --tw-invert:  ;
+  --tw-saturate:  ;
+  --tw-sepia:  ;
+  --tw-drop-shadow:  ;
+  --tw-backdrop-blur:  ;
+  --tw-backdrop-brightness:  ;
+  --tw-backdrop-contrast:  ;
+  --tw-backdrop-grayscale:  ;
+  --tw-backdrop-hue-rotate:  ;
+  --tw-backdrop-invert:  ;
+  --tw-backdrop-opacity:  ;
+  --tw-backdrop-saturate:  ;
+  --tw-backdrop-sepia:  ;
+}
+
+.mb-10 {
+  margin-bottom: 2.5rem;
+}
+
+.transform {
+  transform: translate(var(--tw-translate-x), var(--tw-translate-y)) rotate(var(--tw-rotate)) skewX(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y));
+}
+
+.leading-3 {
+  line-height: .75rem;
+}
+
+.transition {
+  transition-property: color, background-color, border-color, text-decoration-color, fill, stroke, opacity, box-shadow, transform, filter, -webkit-backdrop-filter;
+  transition-property: color, background-color, border-color, text-decoration-color, fill, stroke, opacity, box-shadow, transform, filter, backdrop-filter;
+  transition-property: color, background-color, border-color, text-decoration-color, fill, stroke, opacity, box-shadow, transform, filter, backdrop-filter, -webkit-backdrop-filter;
+  transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+  transition-duration: 150ms;
+}

docs/stylesheets/tailwind.css

@@ -0,0 +1,3 @@
+@import 'tailwindcss/base';
+@import 'tailwindcss/components';
+@import 'tailwindcss/utilities';

docs/tailwind.config.js

@@ -0,0 +1,9 @@
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: ["./**/*.md"],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}
+

docs/telemetry/Telemetry.md

@@ -0,0 +1,17 @@
+## Telemetry
+
+CrewAI uses anonymous telemetry to collect usage data with the main purpose of helping us improve the library by focusing our efforts on the most used features, integrations and tools.
+
+There is NO data being collected on the prompts, tasks descriptions agents backstories or goals nor tools usage, no API calls, nor responses nor any data that is being processed by the agents, nor any secrets and env vars.
+
+Data collected includes:
+- Version of crewAI
+- Version of Python
+- General OS (e.g. number of CPUs, macOS/Windows/Linux)
+- Number of agents and tasks in a crew
+- Crew Process being used
+- If Agents are using memory or allowing delegation
+- If Tasks are being executed in parallel or sequentially
+- Language model being used
+- Roles of agents in a crew
+- Tools names available

mkdocs.yml

@@ -1,9 +1,161 @@
-site_name: crewAI Documentation
+site_name: crewAI
+site_author: crewAI, Inc
+site_description: Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.
+repo_name: crewAI
+repo_url: https://github.com/joaomdmoura/crewai/
+site_url: https://crewai.com
+edit_uri: edit/main/docs/
+copyright: Copyright © 2024 crewAI, Inc
+
+markdown_extensions:
+  - abbr
+  - admonition
+  - pymdownx.details
+  - attr_list
+  - def_list
+  - footnotes
+  - md_in_html
+  - toc:
+      permalink: true
+  - pymdownx.arithmatex:
+      generic: true
+  - pymdownx.betterem:
+      smart_enable: all
+  - pymdownx.caret
+  - pymdownx.emoji:
+      emoji_generator: !!python/name:material.extensions.emoji.to_svg
+      emoji_index: !!python/name:material.extensions.emoji.twemoji
+  - pymdownx.highlight:
+      anchor_linenums: true
+      line_spans: __span
+      pygments_lang_class: true
+  - pymdownx.inlinehilite
+  - pymdownx.keys
+  - pymdownx.magiclink:
+      normalize_issue_symbols: true
+      repo_url_shorthand: true
+      user: joaomdmoura
+      repo: crewAI
+  - pymdownx.mark
+  - pymdownx.smartsymbols
+  - pymdownx.snippets:
+      auto_append:
+        - includes/mkdocs.md
+  - pymdownx.superfences:
+      custom_fences:
+        - name: mermaid
+          class: mermaid
+          format: !!python/name:pymdownx.superfences.fence_code_format
+  - pymdownx.tabbed:
+      alternate_style: true
+      combine_header_slug: true
+      slugify: !!python/object/apply:pymdownx.slugs.slugify
+        kwds:
+          case: lower
+  - pymdownx.tasklist:
+      custom_checkbox: true
+  - pymdownx.tilde
 theme:
   name: material
+  language: en
+  icon:
+    repo: fontawesome/brands/github
+    edit: material/pencil
+    view: material/eye
+    admonition:
+      note: octicons/light-bulb-16
+      abstract: octicons/checklist-16
+      info: octicons/info-16
+      tip: octicons/squirrel-16
+      success: octicons/check-16
+      question: octicons/question-16
+      warning: octicons/alert-16
+      failure: octicons/x-circle-16
+      danger: octicons/zap-16
+      bug: octicons/bug-16
+      example: octicons/beaker-16
+      quote: octicons/quote-16
+
   palette:
-    scheme: default
-    primary: red
-    accent: red
+    - scheme: default
+      primary: red
+      accent: red
+      toggle:
+        icon: material/brightness-7
+        name: Switch to dark mode
+    - scheme: slate
+      primary: red
+      accent: red
+      toggle:
+        icon: material/brightness-4
+        name: Switch to light mode
   features:
-    - navigation.tabs
+    - announce.dismiss
+    - content.action.edit
+    - content.action.view
+    - content.code.annotate
+    - content.code.copy
+    - content.code.select
+    - content.tabs.link
+    - content.tooltips
+    - header.autohide
+    - navigation.footer
+    - navigation.indexes
+    # - navigation.prune
+    # - navigation.sections
+    # - navigation.tabs
+    - search.suggest
+    - navigation.instant
+    - navigation.instant.progress
+    - navigation.instant.prefetch
+    - navigation.tracking
+    # - navigation.expand
+    - navigation.path
+    - navigation.top
+    - toc.follow
+    - toc.integrate
+    - search.highlight
+    - search.share
+
+nav:
+  - Home: '/'
+  - Core Concepts:
+    - Agents: 'core-concepts/Agents.md'
+    - Tasks: 'core-concepts/Tasks.md'
+    - Tools: 'core-concepts/Tools.md'
+    - Processes: 'core-concepts/Processes.md'
+    - Crews: 'core-concepts/Crews.md'
+    - Collaboration: 'core-concepts/Collaboration.md'
+  - How to Guides:
+    - Getting Started: 'how-to/Creating-a-Crew-and-kick-it-off.md'
+    - Using Sequential Process: 'how-to/Sequential.md'
+    - Using Hierarchical Process: 'how-to/Hierarchical.md'
+    - Connecting to any LLM: 'how-to/LLM-Connections.md'
+    - Customizing Agents: 'how-to/Customizing-Agents.md'
+    - Human Input on Execution: 'how-to/Human-Input-on-Execution.md'
+  - Examples:
+    - Trip Planner Crew: https://github.com/joaomdmoura/crewAI-examples/tree/main/trip_planner"
+    - Create Instagram Post: https://github.com/joaomdmoura/crewAI-examples/tree/main/instagram_post"
+    - Stock Analysis: https://github.com/joaomdmoura/crewAI-examples/tree/main/stock_analysis"
+    - Game Generator: https://github.com/joaomdmoura/crewAI-examples/tree/main/game-builder-crew"
+    - Drafting emails with LangGraph: https://github.com/joaomdmoura/crewAI-examples/tree/main/CrewAI-LangGraph"
+    - Landing Page Generator: https://github.com/joaomdmoura/crewAI-examples/tree/main/landing_page_generator"
+    - Prepare for meetings: https://github.com/joaomdmoura/crewAI-examples/tree/main/prep-for-a-meeting"
+  - Telemetry: 'telemetry/Telemetry.md'
+
+extra_css:
+  - stylesheets/output.css
+  - stylesheets/extra.css
+
+plugins:
+  - social
+
+extra:
+  analytics:
+    provider: google
+    property: G-N3Q505TMQ6
+  social:
+    - icon: fontawesome/brands/twitter
+      link: https://twitter.com/joaomdmoura
+    - icon: fontawesome/brands/github
+      link: https://github.com/joaomdmoura/crewAI

pyproject.toml

@@ -1,9 +1,9 @@
 
 [tool.poetry]
 name = "crewai"
-version = "0.1.32"
+version = "0.5.5"
 description = "Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks."
-authors = ["Joao Moura <joaomdmoura@gmail.com>"]
+authors = ["Joao Moura <joao@crewai.com>"]
 readme = "README.md"
 packages = [
     { include = "crewai", from = "src" },
@@ -16,18 +16,28 @@ Documentation = "https://github.com/joaomdmoura/CrewAI/wiki/Index"
 Repository = "https://github.com/joaomdmoura/crewai"
 
 [tool.poetry.dependencies]
-python = ">=3.9,<4.0"
+python = ">=3.10,<4.0"
 pydantic = "^2.4.2"
-langchain = "^0.1.0"
+langchain = "0.1.0"
 openai = "^1.7.1"
 langchain-openai = "^0.0.2"
+opentelemetry-api = "^1.22.0"
+opentelemetry-sdk = "^1.22.0"
+opentelemetry-exporter-otlp-proto-http = "^1.22.0"
 
 [tool.poetry.group.dev.dependencies]
 isort = "^5.13.2"
-black = "^23.12.1"
+pyright = "1.1.333"
+black = {git = "https://github.com/psf/black.git", rev = "stable"}
 autoflake = "^2.2.1"
 pre-commit = "^3.6.0"
-mkdocs-material = "^9.5.3"
+mkdocs = "^1.4.3"
+mkdocstrings = "^0.22.0"
+mkdocstrings-python = "^1.1.2"
+mkdocs-material = {extras = ["imaging"], version = "^9.5.7"}
+mkdocs-material-extensions = "^1.3.1"
+pillow = "^10.2.0"
+cairosvg = "^2.7.1"
 
 [tool.isort]
 profile = "black"

src/crewai/agent.py

@@ -1,6 +1,7 @@
 import uuid
 from typing import Any, List, Optional
 
+from langchain.agents.agent import RunnableAgent
 from langchain.agents.format_scratchpad import format_log_to_str
 from langchain.memory import ConversationSummaryMemory
 from langchain.tools.render import render_text_description
@@ -47,7 +48,7 @@ class Agent(BaseModel):
             tools: Tools at agents disposal
     """
 
-    __hash__ = object.__hash__
+    __hash__ = object.__hash__  # type: ignore
     _logger: Logger = PrivateAttr()
     _rpm_controller: RPMController = PrivateAttr(default=None)
     _request_within_rpm_limit: Any = PrivateAttr(default=None)
@@ -80,21 +81,19 @@ class Agent(BaseModel):
     max_iter: Optional[int] = Field(
         default=15, description="Maximum iterations for an agent to execute a task"
     )
-    agent_executor: Optional[InstanceOf[CrewAgentExecutor]] = Field(
+    agent_executor: InstanceOf[CrewAgentExecutor] = Field(
         default=None, description="An instance of the CrewAgentExecutor class."
     )
-    tools_handler: Optional[InstanceOf[ToolsHandler]] = Field(
+    tools_handler: InstanceOf[ToolsHandler] = Field(
         default=None, description="An instance of the ToolsHandler class."
     )
-    cache_handler: Optional[InstanceOf[CacheHandler]] = Field(
+    cache_handler: InstanceOf[CacheHandler] = Field(
         default=CacheHandler(), description="An instance of the CacheHandler class."
     )
-    i18n: Optional[I18N] = Field(
-        default=I18N(), description="Internationalization settings."
-    )
-    llm: Optional[Any] = Field(
+    i18n: I18N = Field(default=I18N(), description="Internationalization settings.")
+    llm: Any = Field(
         default_factory=lambda: ChatOpenAI(
-            model_name="gpt-4",
+            model="gpt-4",
         ),
         description="Language model that will run the agent.",
     )
@@ -140,6 +139,7 @@ class Agent(BaseModel):
         Returns:
             Output of the agent
         """
+
         if context:
             task = self.i18n.slice("task_with_context").format(
                 task=task, context=context
@@ -170,7 +170,7 @@ class Agent(BaseModel):
         """
         self.cache_handler = cache_handler
         self.tools_handler = ToolsHandler(cache=self.cache_handler)
-        self.__create_agent_executor()
+        self._create_agent_executor()
 
     def set_rpm_controller(self, rpm_controller: RPMController) -> None:
         """Set the rpm controller for the agent.
@@ -180,9 +180,9 @@ class Agent(BaseModel):
         """
         if not self._rpm_controller:
             self._rpm_controller = rpm_controller
-            self.__create_agent_executor()
+            self._create_agent_executor()
 
-    def __create_agent_executor(self) -> None:
+    def _create_agent_executor(self) -> None:
         """Create an agent executor for the agent.
 
         Returns:
@@ -203,9 +203,9 @@ class Agent(BaseModel):
         }
 
         if self._rpm_controller:
-            executor_args[
-                "request_within_rpm_limit"
-            ] = self._rpm_controller.check_or_wait
+            executor_args["request_within_rpm_limit"] = (
+                self._rpm_controller.check_or_wait
+            )
 
         if self.memory:
             summary_memory = ConversationSummaryMemory(
@@ -234,7 +234,9 @@ class Agent(BaseModel):
                 i18n=self.i18n,
             )
         )
-        self.agent_executor = CrewAgentExecutor(agent=inner_agent, **executor_args)
+        self.agent_executor = CrewAgentExecutor(
+            agent=RunnableAgent(runnable=inner_agent), **executor_args
+        )
 
     @staticmethod
     def __tools_names(tools) -> str:

src/crewai/agents/cache/cache_handler.py

@@ -1,12 +1,10 @@
 from typing import Optional
 
-from pydantic import PrivateAttr
-
 
 class CacheHandler:
     """Callback handler for tool usage."""
 
-    _cache: PrivateAttr = {}
+    _cache: dict = {}
 
     def __init__(self):
         self._cache = {}

src/crewai/agents/executor.py

@@ -33,7 +33,7 @@ class CrewAgentExecutor(AgentExecutor):
 
     def _force_answer(self, output: AgentAction):
         return AgentStep(
-            action=output, observation=self.i18n.errors("used_too_many_tools")
+            action=output, observation=self.i18n.errors("force_final_answer")
         )
 
     def _call(
@@ -106,10 +106,14 @@ class CrewAgentExecutor(AgentExecutor):
                 **inputs,
             )
             if self._should_force_answer():
-                if isinstance(output, AgentAction):
+                if isinstance(output, AgentAction) or isinstance(output, AgentFinish):
                     output = output
-                else:
+                elif isinstance(output, CacheHit):
                     output = output.action
+                else:
+                    raise ValueError(
+                        f"Unexpected output type from agent: {type(output)}"
+                    )
                 yield self._force_answer(output)
                 return