updating docs

.github/workflows/mkdocs.yml

@@ -1,7 +1,7 @@
 name: Deploy MkDocs
 
 on:
-  workflow_dispatch:    
+  workflow_dispatch:
   push:
     branches:
       - main
@@ -22,6 +22,18 @@ 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 &&

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,51 @@
+---
+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. |
+| **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
+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'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."""
+)
+```
+
+## 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/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,44 +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 process 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.
-- **Hierarchical**: This process introduces a chain of command to task execution. You define the crew and the system assigns a manager to properly coordinate the planning and execution of tasks through delegation and validation of results, akin to a traditional corporate hierarchy.
-- **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.
-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.
-
-## 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.
-
-## 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. Different from the sequential process, you don't need to assign an agent to a task.
-
-```python
-from crewai import Crew
-from crewai.process import Process
-
-# Create a crew with a sequential process
-crew = Crew(agents=my_agents, tasks=my_tasks, process=Process.sequential)
-# OR create a crew with a hierarchical process
-crew = Crew(agents=my_agents, tasks=my_tasks, process=Process.hierarchical)
-```
-
-## Sequential Process
-
-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.
-
-## Hierarchical Process
-
-The hierarchical process is tiny bit more magic, as the chain of command and task assignment is hidden from the user. The system will automatically assign a manager the execute the tasks, but the agent will never execute the job by itself. Instead, the manager will plan the steps to execute the task and delegate the work to the agents. The agents will then execute the task and report back to the manager, who will validate the results and pass the task outcome to the next task.
-
-## 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,145 @@
+---
+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. |
+| **Context**  *(optional)*     | Other tasks that will have their output used as context for this task. |
+| **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]
+)
+
+#...
+```
+
+## 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
+)
+
+#...
+```
+
+## 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/how-to/LLM-Connections.md

@@ -39,9 +39,9 @@ local_expert = Agent(
 
 ## Open AI Compatible API Endpoints
 
-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. 
+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`, `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. 
+The `OPENAI_API_BASE` 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.
 
@@ -52,7 +52,7 @@ 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"),
+defalut_llm = ChatOpenAI(openai_api_base=os.environ.get("OPENAI_API_BASE", "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"))
 
@@ -66,19 +66,19 @@ example_agent = Agent(
 
 ```
 
-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. 
+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.
+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` 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
+OPENAI_API_BASE=https://api.openai.com/v1
 MODEL_NAME="gpt-3.5-turbo"
 ```
 
@@ -93,7 +93,7 @@ FastChat is an open platform for training, serving, and evaluating large languag
 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'
 ```
@@ -109,7 +109,7 @@ Discover, download, and run local LLMs
 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
@@ -118,7 +118,7 @@ MODEL_NAME=NA
 
 ### Mistral API
 
-Mistral AI's API endpoints 
+Mistral AI's API endpoints
 
 [Mistral AI](https://mistral.ai/)
 

docs/index.md

@@ -1,36 +1,93 @@
-<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/Managing-Processes">
+                    Managing Processes
+                </a>
+            </li>
+            <li>
+                <a href="./core-concepts/Delegation-and-Collaboration">
+                    Collaboration and Delegation
+                </a>
+            </li>
+            <li>
+                <a href="./core-concepts/Agent-Tools">
+                    Agent Tools
+                </a>
+            </li> -->
+        </ul>
+    </div>
+    <div style="width:30%">
+        <h2>How-To Guides</h2>
+        <ul>
+            <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/Creating-a-Crew-and-kick-it-off">
+                    Creating a Crew and kick it off
+                </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 href="https://github.com/joaomdmoura/crewAI-examples/tree/main/trip_planner">
+                    Trip Planner Crew
+                </a>
+            </li>
+            <li>
+                <a href="https://github.com/joaomdmoura/crewAI-examples/tree/main/stock_analysis">
+                    Stock Analysis
+                </a>
+            </li>
+            <li>
+                <a 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,718 @@
+/*
+! 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:  ;
+}
+
+.m-3 {
+  margin: 0.75rem;
+}
+
+.m-0 {
+  margin: 0px;
+}
+
+.m-auto {
+  margin: auto;
+}
+
+.my-3 {
+  margin-top: 0.75rem;
+  margin-bottom: 0.75rem;
+}
+
+.mb-3 {
+  margin-bottom: 0.75rem;
+}
+
+.mt-5 {
+  margin-top: 1.25rem;
+}
+
+.mb-5 {
+  margin-bottom: 1.25rem;
+}
+
+.mr-10 {
+  margin-right: 2.5rem;
+}
+
+.ml-10 {
+  margin-left: 2.5rem;
+}
+
+.mb-10 {
+  margin-bottom: 2.5rem;
+}
+
+.hidden {
+  display: none;
+}
+
+.w-1\/2 {
+  width: 50%;
+}
+
+.w-1\/5 {
+  width: 20%;
+}
+
+.w-2\/3 {
+  width: 66.666667%;
+}
+
+.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));
+}
+
+.rounded {
+  border-radius: 0.25rem;
+}
+
+.border-2 {
+  border-width: 2px;
+}
+
+.border-solid {
+  border-style: solid;
+}
+
+.border-red-500 {
+  --tw-border-opacity: 1;
+  border-color: rgb(239 68 68 / var(--tw-border-opacity));
+}
+
+.border-red-800 {
+  --tw-border-opacity: 1;
+  border-color: rgb(153 27 27 / var(--tw-border-opacity));
+}
+
+.bg-red-500 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(239 68 68 / var(--tw-bg-opacity));
+}
+
+.bg-red-300 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(252 165 165 / var(--tw-bg-opacity));
+}
+
+.bg-red-400 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(248 113 113 / var(--tw-bg-opacity));
+}
+
+.p-5 {
+  padding: 1.25rem;
+}
+
+.p-2 {
+  padding: 0.5rem;
+}
+
+.p-0 {
+  padding: 0px;
+}
+
+.px-2 {
+  padding-left: 0.5rem;
+  padding-right: 0.5rem;
+}
+
+.py-1 {
+  padding-top: 0.25rem;
+  padding-bottom: 0.25rem;
+}
+
+.font-bold {
+  font-weight: 700;
+}
+
+.leading-10 {
+  line-height: 2.5rem;
+}
+
+.leading-3 {
+  line-height: .75rem;
+}
+
+.text-white {
+  --tw-text-opacity: 1;
+  color: rgb(255 255 255 / var(--tw-text-opacity));
+}
+
+.text-red-900 {
+  --tw-text-opacity: 1;
+  color: rgb(127 29 29 / var(--tw-text-opacity));
+}
+
+.text-red-800 {
+  --tw-text-opacity: 1;
+  color: rgb(153 27 27 / var(--tw-text-opacity));
+}
+
+.shadow-sm {
+  --tw-shadow: 0 1px 2px 0 rgb(0 0 0 / 0.05);
+  --tw-shadow-colored: 0 1px 2px 0 var(--tw-shadow-color);
+  box-shadow: var(--tw-ring-offset-shadow, 0 0 #0000), var(--tw-ring-shadow, 0 0 #0000), var(--tw-shadow);
+}
+
+.shadow-md {
+  --tw-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1);
+  --tw-shadow-colored: 0 4px 6px -1px var(--tw-shadow-color), 0 2px 4px -2px var(--tw-shadow-color);
+  box-shadow: var(--tw-ring-offset-shadow, 0 0 #0000), var(--tw-ring-shadow, 0 0 #0000), var(--tw-shadow);
+}
+
+.shadow-lg {
+  --tw-shadow: 0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1);
+  --tw-shadow-colored: 0 10px 15px -3px var(--tw-shadow-color), 0 4px 6px -4px var(--tw-shadow-color);
+  box-shadow: var(--tw-ring-offset-shadow, 0 0 #0000), var(--tw-ring-shadow, 0 0 #0000), var(--tw-shadow);
+}
+
+.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: [],
+}
+

mkdocs.yml

@@ -1,9 +1,154 @@
-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'
+    - Collaboration: 'core-concepts/Collaboration.md'
+  - How to Guides:
+    - 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:
+    - Example 1: 'examples/Example-1.md'
+    - Example 2: 'examples/Example-2.md'
+    - Example 3: 'examples/Example-3.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

@@ -23,19 +23,24 @@ openai = "^1.7.1"
 langchain-openai = "^0.0.2"
 pyright = "1.1.333"
 black = {git = "https://github.com/psf/black.git", rev = "stable"}
+mkdocs-material = {extras = ["imaging"], version = "^9.5.7"}
 
 [tool.poetry.group.dev.dependencies]
 isort = "^5.13.2"
 black = "^24.1"
 autoflake = "^2.2.1"
 pre-commit = "^3.6.0"
+mkdocs = "^1.4.3"
 mkdocs-material = "^9.5.3"
+mkdocstrings = "^0.22.0"
+mkdocstrings-python = "^1.1.2"
 
 [tool.isort]
 profile = "black"
 known_first_party = ["crewai"]
 
 
+
 [tool.poetry.group.test.dependencies]
 pytest = "^7.4"
 pytest-vcr = "^1.0.2"