Add back in Gui's tool_usage fix

* Provide inputs on crew creation

* Better naming

* Add crew id and task index to tasks

* Fix type again

.editorconfig

@@ -0,0 +1,14 @@
+# .editorconfig
+root = true
+
+# All files
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+# Python files
+[*.py]
+indent_style = space
+indent_size = 2

.github/workflows/black.yml

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

.github/workflows/linter.yml

@@ -0,0 +1,16 @@
+name: Lint
+
+on: [pull_request]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install Requirements
+        run: |
+          pip install ruff
+
+      - name: Run Ruff Linter
+        run: ruff check --exclude "templates","__init__.py"

.github/workflows/tests.yml

@@ -14,18 +14,17 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Setup Python
         uses: actions/setup-python@v4
         with:
-          python-version: '3.10'
+          python-version: "3.11.9"
 
       - name: Install Requirements
         run: |
-          sudo apt-get update &&
-          pip install poetry &&
-          poetry lock &&
+          set -e
+          pip install poetry
           poetry install
 
       - name: Run tests

.github/workflows/type-checker.yml

@@ -1,4 +1,3 @@
-
 name: Run Type Checks
 
 on: [pull_request]
@@ -12,19 +11,16 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Setup Python
         uses: actions/setup-python@v4
         with:
-          python-version: '3.10'
+          python-version: "3.10"
 
       - name: Install Requirements
         run: |
-          sudo apt-get update &&
-          pip install poetry &&
-          poetry lock &&
-          poetry install
+          pip install mypy
 
       - name: Run type checks
-        run: poetry run pyright
+        run: mypy src

.gitignore

@@ -5,4 +5,13 @@ dist/
 .env
 assets/*
 .idea
-test/
+test/
+docs_crew/
+chroma.sqlite3
+old_en.json
+db/
+test.py
+rc-tests/*
+*.pkl
+temp/*
+.vscode/*

.pre-commit-config.yaml

@@ -1,21 +1,9 @@
 repos:
-
-  - repo: https://github.com/psf/black-pre-commit-mirror
-    rev: 23.12.1
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.4.4
     hooks:
-      - id: black
-        language_version: python3.11
-        files: \.(py)$
-
-  - repo: https://github.com/pycqa/isort
-    rev: 5.13.2
-    hooks:
-      - id: isort
-        name: isort (python)
-        args: ["--profile", "black", "--filter-files"]
-
-  - repo: https://github.com/PyCQA/autoflake
-    rev: v2.2.1
-    hooks:
-      - id: autoflake
-        args: ['--in-place', '--remove-all-unused-imports', '--remove-unused-variables', '--ignore-init-module-imports']
+      - id: ruff
+        args: ["--fix"]
+        exclude: "templates"
+      - id: ruff-format
+        exclude: "templates"

README.md

@@ -24,12 +24,12 @@
 - [Key Features](#key-features)
 - [Examples](#examples)
   - [Quick Tutorial](#quick-tutorial)
+  - [Write Job Descriptions](#write-job-descriptions)
   - [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)
 
@@ -48,10 +48,10 @@ To get started with CrewAI, follow these simple steps:
 pip install crewai
 ```
 
-The example below also uses DuckDuckGo's Search. You can install it with `pip` too:
+If you want to install the 'crewai' package along with its optional features that include additional tools for agents, you can do so by using the following command: pip install 'crewai[tools]'. This command installs the basic package and also adds extra components which require more dependencies to function."
 
 ```shell
-pip install duckduckgo-search
+pip install 'crewai[tools]'
 ```
 
 ### 2. Setting Up Your Crew
@@ -59,18 +59,29 @@ pip install duckduckgo-search
 ```python
 import os
 from crewai import Agent, Task, Crew, Process
+from crewai_tools import SerperDevTool
 
 os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"
+os.environ["SERPER_API_KEY"] = "Your Key" # serper.dev API key
 
-# 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")
+# You can choose to use a local model through Ollama for example. See https://docs.crewai.com/how-to/LLM-Connections/ for more information.
 
-# Install duckduckgo-search for this example:
-# !pip install -U duckduckgo-search
+# os.environ["OPENAI_API_BASE"] = 'http://localhost:11434/v1'
+# os.environ["OPENAI_MODEL_NAME"] ='openhermes'  # Adjust based on available model
+# os.environ["OPENAI_API_KEY"] ='sk-111111111111111111111111111111111111111111111111'
 
-from langchain_community.tools import DuckDuckGoSearchRun
-search_tool = DuckDuckGoSearchRun()
+# You can pass an optional llm attribute specifying what model you wanna use.
+# It can be a local model through Ollama / LM Studio or a remote
+# model like OpenAI, Mistral, Antrophic or others (https://docs.crewai.com/how-to/LLM-Connections/)
+#
+# import os
+# os.environ['OPENAI_MODEL_NAME'] = 'gpt-3.5-turbo'
+#
+# OR
+#
+# from langchain_openai import ChatOpenAI
+
+search_tool = SerperDevTool()
 
 # Define your agents with roles and goals
 researcher = Agent(
@@ -81,18 +92,9 @@ researcher = Agent(
   You have a knack for dissecting complex data and presenting actionable insights.""",
   verbose=True,
   allow_delegation=False,
+  # You can pass an optional llm attribute specifying what model you wanna use.
+  # llm=ChatOpenAI(model_name="gpt-3.5", temperature=0.7),
   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 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
-  #
-  # from langchain_openai import ChatOpenAI
-  # llm=ChatOpenAI(model_name="gpt-3.5", temperature=0.7)
 )
 writer = Agent(
   role='Tech Content Strategist',
@@ -100,15 +102,14 @@ writer = Agent(
   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
+  allow_delegation=True
 )
 
 # 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""",
+  Identify key trends, breakthrough technologies, and potential industry impacts.""",
+  expected_output="Full analysis report in bullet points",
   agent=researcher
 )
 
@@ -116,8 +117,8 @@ 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.""",
+  Make it sound cool, avoid complex words so it doesn't sound like AI.""",
+  expected_output="Full blog post of at least 4 paragraphs",
   agent=writer
 )
 
@@ -126,6 +127,7 @@ crew = Crew(
   agents=[researcher, writer],
   tasks=[task1, task2],
   verbose=2, # You can set it to 1 or 2 to different logging levels
+  process = Process.sequential
 )
 
 # Get your crew to work!
@@ -143,7 +145,9 @@ In addition to the sequential process, you can use the hierarchical process, whi
 - **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 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!
+- **Save output as file**: Save the output of individual tasks as a file, so you can use it later.
+- **Parse output as Pydantic or Json**: Parse the output of individual tasks as a Pydantic model or as a Json if you want to.
+- **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 your agents' connections to models, even ones running locally!
 
 ![CrewAI Mind Map](./docs/crewAI-mindmap.png "CrewAI Mind Map")
 
@@ -160,6 +164,12 @@ You can test different real life examples of AI crews in the [crewAI-examples re
 
 [![CrewAI Tutorial](https://img.youtube.com/vi/tnejrr-0a94/maxresdefault.jpg)](https://www.youtube.com/watch?v=tnejrr-0a94 "CrewAI Tutorial")
 
+### Write Job Descriptions
+
+[Check out code for this example](https://github.com/joaomdmoura/crewAI-examples/tree/main/job-posting) or watch a video below:
+
+[![Jobs postings](https://img.youtube.com/vi/u98wEMz-9to/maxresdefault.jpg)](https://www.youtube.com/watch?v=u98wEMz-9to "Jobs postings")
+
 ### Trip Planner
 
 [Check out code for this example](https://github.com/joaomdmoura/crewAI-examples/tree/main/trip_planner) or watch a video below:
@@ -180,12 +190,13 @@ Please refer to the [Connect crewAI to LLMs](https://docs.crewai.com/how-to/LLM-
 
 ## How CrewAI Compares
 
-- **Autogen**: While Autogen excels in creating conversational agents capable of working together, it lacks an inherent concept of process. In Autogen, orchestrating agents' interactions requires additional programming, which can become complex and cumbersome as the scale of tasks grows.
+- **Autogen**: While Autogen does good in creating conversational agents capable of working together, it lacks an inherent concept of process. In Autogen, orchestrating agents' interactions requires additional programming, which can become complex and cumbersome as the scale of tasks grows.
 
 - **ChatDev**: ChatDev introduced the idea of processes into the realm of AI agents, but its implementation is quite rigid. Customizations in ChatDev are limited and not geared towards production environments, which can hinder scalability and flexibility in real-world applications.
 
 **CrewAI's Advantage**: CrewAI is built with production in mind. It offers the flexibility of Autogen's conversational agents and the structured process approach of ChatDev, but without the rigidity. CrewAI's processes are designed to be dynamic and adaptable, fitting seamlessly into both development and production workflows.
 
+
 ## Contribution
 
 CrewAI is open-source and we welcome contributions. If you're looking to contribute, please:
@@ -224,7 +235,7 @@ poetry run pytest
 ### Running static type checks
 
 ```bash
-poetry run pyright
+poetry run mypy
 ```
 
 ### Packaging
@@ -239,11 +250,6 @@ poetry build
 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 [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.
@@ -251,6 +257,7 @@ CrewAI uses anonymous telemetry to collect usage data with the main purpose of h
 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
   - So we can understand how many users are using the latest version
 - Version of Python

crewAI.excalidraw

@@ -1463,11 +1463,11 @@
       "locked": false,
       "fontSize": 20,
       "fontFamily": 3,
-      "text": "Agents have the inert ability of\nreach out to another to delegate\nwork or ask questions.",
+      "text": "Agents have the innate ability of\nreach out to another to delegate\nwork or ask questions.",
       "textAlign": "right",
       "verticalAlign": "top",
       "containerId": null,
-      "originalText": "Agents have the inert ability of\nreach out to another to delegate\nwork or ask questions.",
+      "originalText": "Agents have the innate ability of\nreach out to another to delegate\nwork or ask questions.",
       "lineHeight": 1.2,
       "baseline": 68
     },
@@ -1734,4 +1734,4 @@
     "viewBackgroundColor": "#ffffff"
   },
   "files": {}
-}
+}

docs/CNAME

@@ -0,0 +1 @@
+docs.crewai.com

docs/core-concepts/Agents.md

@@ -10,31 +10,37 @@ description: What are crewAI Agents and how to use them.
       <li class='leading-3'>Perform tasks</li>
       <li class='leading-3'>Make decisions</li>
       <li class='leading-3'>Communicate with other agents</li>
+    </ul>
       <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. |
-| **LLM**       | The language model used by the agent to process and generate text. |
-| **Tools**    | Set of capabilities or functions that the agent can use to perform tasks. Tools can be shared or exclusive to specific agents. |
-| **Function Calling LLM** | The language model used by this agent to call functions, if none is passed the same main llm for each agent will be used.      |
-| **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. |
-| **Step Callback**    | A function that is called after each step of the agent. This can be used to log the agent's actions or to perform other operations. It will overwrite the crew `step_callback` |
+| Attribute                  | Parameter  | Description                                                                                                                                                                                                                                    |
+| :------------------------- | :---- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Role**                   | `role`  | Defines the agent's function within the crew. It determines the kind of tasks the agent is best suited for.                                                                                                                                    |
+| **Goal**                   | `goal`  | The individual objective that the agent aims to achieve. It guides the agent's decision-making process.                                                                                                                                        |
+| **Backstory**              | `backstory`  | Provides context to the agent's role and goal, enriching the interaction and collaboration dynamics.                                                                                                                                           |
+| **LLM** *(optional)*       | `llm`  | Represents the language model that will run the agent. It dynamically fetches the model name from the `OPENAI_MODEL_NAME` environment variable, defaulting to "gpt-4" if not specified.                                                         |
+| **Tools** *(optional)*     | `tools`  | Set of capabilities or functions that the agent can use to perform tasks. Expected to be instances of custom classes compatible with the agent's execution environment. Tools are initialized with a default value of an empty list.             |
+| **Function Calling LLM** *(optional)* | `function_calling_llm`  | Specifies the language model that will handle the tool calling for this agent, overriding the crew function calling LLM if passed. Default is `None`.                                                                                          |
+| **Max Iter** *(optional)*  | `max_iter` | Max Iter is the maximum number of iterations the agent can perform before being forced to give its best answer. Default is `25`.                                                                                                                           |
+| **Max RPM** *(optional)*   | `max_rpm`  | Max RPM is the maximum number of requests per minute the agent can perform to avoid rate limits. It's optional and can be left unspecified, with a default value of `None`.                                                                               |
+| **Max Execution Time** *(optional)*   | `max_execution_time`  | Max Execution Time is the Maximum execution time for an agent to execute a task. It's optional and can be left unspecified, with a default value of `None`, meaning no max execution time.                                                                     |
+| **Verbose** *(optional)*   | `verbose`  | Setting this to `True` configures the internal logger to provide detailed execution logs, aiding in debugging and monitoring. Default is `False`.                                                                                              |
+| **Allow Delegation** *(optional)* | `allow_delegation`  | Agents can delegate tasks or questions to one another, ensuring that each task is handled by the most suitable agent. Default is `True`.                                                                                                       |
+| **Step Callback** *(optional)* | `step_callback`  | A function that is called after each step of the agent. This can be used to log the agent's actions or to perform other operations. It will overwrite the crew `step_callback`.                                                               |
+| **Cache** *(optional)*     | `cache`  | Indicates if the agent should use a cache for tool usage. Default is `True`.                                                                                                                                                                  |
+| **System Template** *(optional)*     | `system_template`  | Specifies the system format for the agent. Default is `None`.                                                                                                                                                                  |
+| **Prompt Template** *(optional)*     | `prompt_template`  | Specifies the prompt format for the agent. Default is `None`.                                                                                                                                                                  |
+| **Response Template** *(optional)*     | `response_template`  | Specifies the response format for the agent. Default is `None`.                                                                                                                                                                  |
 
 ## 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.
+    Agents can interact with each other using crewAI's built-in delegation and communication mechanisms. 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:
+To create an agent, you would typically initialize an instance of the `Agent` class with the desired properties. Here's a conceptual example including all attributes:
 
 ```python
 # Example: Creating an agent with all attributes
@@ -48,16 +54,96 @@ agent = Agent(
   to the business.
   You're currently working on a project to analyze the
   performance of our marketing campaigns.""",
-  tools=[my_tool1, my_tool2],
-  llm=my_llm,
-  function_calling_llm=my_llm,
-  max_iter=10,
-  max_rpm=10,
-  verbose=True,
-  allow_delegation=True,
-  step_callback=my_intermediate_step_callback
+  tools=[my_tool1, my_tool2],  # Optional, defaults to an empty list
+  llm=my_llm,  # Optional
+  function_calling_llm=my_llm,  # Optional
+  max_iter=15,  # Optional
+  max_rpm=None, # Optional
+  max_execution_time=None, # Optional
+  verbose=True,  # Optional
+  allow_delegation=True,  # Optional
+  step_callback=my_intermediate_step_callback,  # Optional
+  cache=True,  # Optional
+  system_template=my_system_template,  # Optional
+  prompt_template=my_prompt_template,  # Optional
+  response_template=my_response_template,  # Optional
+  config=my_config,  # Optional
+  crew=my_crew,  # Optional
+  tools_handler=my_tools_handler,  # Optional
+  cache_handler=my_cache_handler,  # Optional
+  callbacks=[callback1, callback2],  # Optional
+  agent_executor=my_agent_executor  # Optional
 )
 ```
 
+## Setting prompt templates
+
+Prompt templates are used to format the prompt for the agent. You can use to update the system, regular and response templates for the agent. Here's an example of how to set prompt templates:
+
+```python
+agent = Agent(
+        role="{topic} specialist",
+        goal="Figure {goal} out",
+        backstory="I am the master of {role}",
+        system_template="""<|start_header_id|>system<|end_header_id|>
+
+{{ .System }}<|eot_id|>""",
+        prompt_template="""<|start_header_id|>user<|end_header_id|>
+
+{{ .Prompt }}<|eot_id|>""",
+        response_template="""<|start_header_id|>assistant<|end_header_id|>
+
+{{ .Response }}<|eot_id|>""",
+    )
+```
+
+## Bring your Third Party Agents
+!!! note "Extend your Third Party Agents like LlamaIndex, Langchain, Autogen or fully custom agents using the the crewai's BaseAgent class."
+
+    BaseAgent includes attributes and methods required to integrate with your crews to run and delegate tasks to other agents within your own crew.
+
+    CrewAI is a universal multi agent framework that allows for all agents to work together to automate tasks and solve problems.
+
+
+```py
+from crewai import Agent, Task, Crew
+from custom_agent import CustomAgent # You need to build and extend your own agent logic with the CrewAI BaseAgent class then import it here.
+
+from langchain.agents import load_tools
+
+langchain_tools = load_tools(["google-serper"], llm=llm)
+
+agent1 = CustomAgent(
+    role="backstory agent",
+    goal="who is {input}?",
+    backstory="agent backstory",
+    verbose=True,
+)
+
+task1 = Task(
+    expected_output="a short biography of {input}",
+    description="a short biography of {input}",
+    agent=agent1,
+)
+
+agent2 = Agent(
+    role="bio agent",
+    goal="summarize the short bio for {input} and if needed do more research",
+    backstory="agent backstory",
+    verbose=True,
+)
+
+task2 = Task(
+    description="a tldr summary of the short biography",
+    expected_output="5 bullet point summary of the biography",
+    agent=agent2,
+    context=[task1],
+)
+
+my_crew = Crew(agents=[agent1, agent2], tasks=[task1, task2])
+crew = my_crew.kickoff(inputs={"input": "Mark Twain"})
+```
+
+
 ## 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.
+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

@@ -1,6 +1,6 @@
 ---
 title: How Agents Collaborate in CrewAI
-description: Exploring the dynamics of agent collaboration within the CrewAI framework.
+description: Exploring the dynamics of agent collaboration within the CrewAI framework, focusing on the newly integrated features for enhanced functionality.
 ---
 
 ## Collaboration Fundamentals
@@ -11,14 +11,32 @@ description: Exploring the dynamics of agent collaboration within the CrewAI fra
 - **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.
 
+## Enhanced Attributes for Improved Collaboration
+The `Crew` class has been enriched with several attributes to support advanced functionalities:
+
+- **Language Model Management (`manager_llm`, `function_calling_llm`)**: Manages language models for executing tasks and tools, facilitating sophisticated agent-tool interactions. Note that while `manager_llm` is mandatory for hierarchical processes to ensure proper execution flow, `function_calling_llm` is optional, with a default value provided for streamlined tool interaction.
+- **Custom Manager Agent (`manager_agent`)**: Allows specifying a custom agent as the manager instead of using the default manager provided by CrewAI.
+- **Process Flow (`process`)**: Defines the execution logic (e.g., sequential, hierarchical) to streamline task distribution and execution.
+- **Verbose Logging (`verbose`)**: Offers detailed logging capabilities for monitoring and debugging purposes. It supports both integer and boolean types to indicate the verbosity level. For example, setting `verbose` to 1 might enable basic logging, whereas setting it to True enables more detailed logs.
+- **Rate Limiting (`max_rpm`)**: Ensures efficient utilization of resources by limiting requests per minute. Guidelines for setting `max_rpm` should consider the complexity of tasks and the expected load on resources.
+- **Internationalization / Customization Support (`language`, `prompt_file`)**: Facilitates full customization of the inner prompts, enhancing global usability. Supported languages and the process for utilizing the `prompt_file` attribute for customization should be clearly documented. [Example of file](https://github.com/joaomdmoura/crewAI/blob/main/src/crewai/translations/en.json)
+- **Execution and Output Handling (`full_output`)**: Distinguishes between full and final outputs for nuanced control over task results. Examples showcasing the difference in outputs can aid in understanding the practical implications of this attribute.
+- **Callback and Telemetry (`step_callback`, `task_callback`)**: Integrates callbacks for step-wise and task-level execution monitoring, alongside telemetry for performance analytics. The purpose and usage of `task_callback` alongside `step_callback` for granular monitoring should be clearly explained.
+- **Crew Sharing (`share_crew`)**: Enables sharing of crew information with CrewAI for continuous improvement and training models. The privacy implications and benefits of this feature, including how it contributes to model improvement, should be outlined.
+- **Usage Metrics (`usage_metrics`)**: Stores all metrics for the language model (LLM) usage during all tasks' execution, providing insights into operational efficiency and areas for improvement. Detailed information on accessing and interpreting these metrics for performance analysis should be provided.
+- **Memory Usage (`memory`)**: Indicates whether the crew should use memory to store memories of its execution, enhancing task execution and agent learning.
+- **Embedder Configuration (`embedder`)**: Specifies the configuration for the embedder to be used by the crew for understanding and generating language. This attribute supports customization of the language model provider.
+- **Cache Management (`cache`)**: Determines whether the crew should use a cache to store the results of tool executions, optimizing performance.
+- **Output Logging (`output_log_file`)**: Specifies the file path for logging the output of the crew execution.
+
 ## 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.
+Setting up a crew involves defining the roles and capabilities of each agent. CrewAI seamlessly manages their interactions, ensuring efficient collaboration and delegation, with enhanced customization and monitoring features to adapt to various operational needs.
 
 ## 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.
+Consider a crew with a researcher agent tasked with data gathering and a writer agent responsible for compiling reports. The integration of advanced language model management and process flow attributes allows for more sophisticated interactions, such as the writer delegating complex research tasks to the researcher or querying specific information, thereby 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.
+The integration of advanced attributes and functionalities into the CrewAI framework significantly enriches the agent collaboration ecosystem. These enhancements not only simplify interactions but also offer unprecedented flexibility and control, paving the way for sophisticated AI-driven solutions capable of tackling complex tasks through intelligent collaboration and delegation.

docs/core-concepts/Crews.md

@@ -1,37 +1,43 @@
 ---
 title: crewAI Crews
-description: Understanding and utilizing crews in the crewAI framework.
+description: Understanding and utilizing crews in the crewAI framework with comprehensive attributes and functionalities.
 ---
 
 ## 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.
+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. |
-| **Function Calling LLM** | The language model used by all agensts in the crew to call functions, if none is passed the same main llm for each agent will be used.      |
-| **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.                   |
-| **Full Output**    | Whether the crew should return the full output with all tasks outputs or just the final output. |
-| **Step Callback**    | A function that is called after each step of every agent. This can be used to log the agent's actions or to perform other operations, it won't override the agent specific `step_callback` |
-| **Share Crew**       | Whether you want to share the complete crew infromation and execution with the crewAI team to make the library better, and allow us to train models. |
-
+| Attribute                   | Parameters          | Description                                                                                              |
+| :-------------------------- | :------------------ | :------------------------------------------------------------------------------------------------------- |
+| **Tasks**                   | `tasks`               | A list of tasks assigned to the crew.                                                                    |
+| **Agents**                  | `agents`              | A list of agents that are part of the crew.                                                              |
+| **Process** *(optional)*    | `process`             | The process flow (e.g., sequential, hierarchical) the crew follows.                                      |
+| **Verbose** *(optional)*    | `verbose`             | The verbosity level for logging during execution.                                                        |
+| **Manager LLM** *(optional)*| `manager_llm`         | The language model used by the manager agent in a hierarchical process. **Required when using a hierarchical process.** |
+| **Function Calling LLM** *(optional)* | `function_calling_llm` | If passed, the crew will use this LLM to do function calling for tools for all agents in the crew. Each agent can have its own LLM, which overrides the crew's LLM for function calling. |
+| **Config** *(optional)*     | `config`              | Optional configuration settings for the crew, in `Json` or `Dict[str, Any]` format.                       |
+| **Max RPM** *(optional)*    | `max_rpm`             | Maximum requests per minute the crew adheres to during execution.                                         |
+| **Language**  *(optional)*  | `language`            | Language used for the crew, defaults to English.                                                          |
+| **Language File** *(optional)* | `language_file`       | Path to the language file to be used for the crew.                                                        |
+| **Memory** *(optional)*     | `memory`              | Utilized for storing execution memories (short-term, long-term, entity memory).                           |
+| **Cache** *(optional)*      | `cache`               | Specifies whether to use a cache for storing the results of tools' execution.                             |
+| **Embedder** *(optional)*   | `embedder`            | Configuration for the embedder to be used by the crew. Mostly used by memory for now.                     |
+| **Full Output** *(optional)*| `full_output`         | Whether the crew should return the full output with all tasks outputs or just the final output.           |
+| **Step Callback** *(optional)* | `step_callback`       | A function that is called after each step of every agent. This can be used to log the agent's actions or to perform other operations; it won't override the agent-specific `step_callback`. |
+| **Task Callback** *(optional)* | `task_callback`       | A function that is called after the completion of each task. Useful for monitoring or additional operations post-task execution. |
+| **Share Crew** *(optional)* | `share_crew`          | Whether you want to share the complete crew information and execution with the crewAI team to make the library better, and allow us to train models. |
+| **Output Log File** *(optional)* | `output_log_file`    | Whether you want to have a file with the complete crew output and execution. You can set it using True and it will default to the folder you are currently in and it will be called logs.txt or passing a string with the full path and name of the file. |
+| **Manager Agent** *(optional)* | `manager_agent`      | `manager` sets a custom agent that will be used as a manager.                                             |
+| **Manager Callbacks** *(optional)* | `manager_callbacks` | `manager_callbacks` takes a list of callback handlers to be executed by the manager agent when a hierarchical process is used. |
+| **Prompt File** *(optional)* | `prompt_file`         | Path to the prompt JSON file to be used for the crew.                                                     |
 
 !!! 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.
+    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.
+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
 
@@ -43,17 +49,35 @@ from langchain_community.tools import DuckDuckGoSearchRun
 researcher = Agent(
     role='Senior Research Analyst',
     goal='Discover innovative AI technologies',
+    backstory="""You're a senior research 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
+        trends and innovations in the space of artificial intelligence.""",
     tools=[DuckDuckGoSearchRun()]
 )
 
 writer = Agent(
     role='Content Writer',
-    goal='Write engaging articles on AI discoveries'
+    goal='Write engaging articles on AI discoveries',
+    backstory="""You're a senior writer at a large company.
+        You're responsible for creating content to the business.
+        You're currently working on a project to write about trends
+        and innovations in the space of AI for your next meeting.""",
+    verbose=True
 )
 
 # 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)
+research_task = Task(
+    description='Identify breakthrough AI technologies',
+    agent=researcher,
+    expected_output='A bullet list summary of the top 5 most important AI news'
+)
+write_article_task = Task(
+    description='Draft an article on the latest AI technologies',
+    agent=writer,
+    expected_output='3 paragraph blog post on the latest AI technologies'
+)
 
 # Assemble the crew with a sequential process
 my_crew = Crew(
@@ -61,14 +85,33 @@ my_crew = Crew(
     tasks=[research_task, write_article_task],
     process=Process.sequential,
     full_output=True,
-    verbose=True
+    verbose=True,
 )
 ```
 
+## Memory Utilization
+
+Crews can utilize memory (short-term, long-term, and entity memory) to enhance their execution and learning over time. This feature allows crews to store and recall execution memories, aiding in decision-making and task execution strategies.
+
+## Cache Utilization
+
+Caches can be employed to store the results of tools' execution, making the process more efficient by reducing the need to re-execute identical tasks.
+
+## Crew Usage Metrics
+
+After the crew execution, you can access the `usage_metrics` attribute to view the language model (LLM) usage metrics for all tasks executed by the crew. This provides insights into operational efficiency and areas for improvement.
+
+```python
+# Access the crew's usage metrics
+crew = Crew(agents=[agent1, agent2], tasks=[task1, task2])
+crew.kickoff()
+print(crew.usage_metrics)
+```
+
 ## 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.
+- **Hierarchical Process**: A manager agent coordinates the crew, delegating tasks and validating outcomes before proceeding. **Note**: A `manager_llm` or `manager_agent` is required for this process and it's essential for validating the process flow.
 
 ### Kicking Off a Crew
 
@@ -78,4 +121,38 @@ Once your crew is assembled, initiate the workflow with the `kickoff()` method.
 # Start the crew's task execution
 result = my_crew.kickoff()
 print(result)
-```
+```
+
+### Different ways to Kicking Off a Crew
+
+Once your crew is assembled, initiate the workflow with the appropriate kickoff method. CrewAI provides several methods for better control over the kickoff process: `kickoff()`, `kickoff_for_each()`, `kickoff_async()`, and `kickoff_for_each_async()`.
+
+`kickoff()`: Starts the execution process according to the defined process flow.
+`kickoff_for_each()`: Executes tasks for each agent individually.
+`kickoff_async()`: Initiates the workflow asynchronously.
+`kickoff_for_each_async()`: Executes tasks for each agent individually in an asynchronous manner.
+
+```python
+# Start the crew's task execution
+result = my_crew.kickoff()
+print(result)
+
+# Example of using kickoff_for_each
+inputs_array = [{'topic': 'AI in healthcare'}, {'topic': 'AI in finance'}]
+results = my_crew.kickoff_for_each(inputs=inputs_array)
+for result in results:
+    print(result)
+
+# Example of using kickoff_async
+inputs = {'topic': 'AI in healthcare'}
+async_result = my_crew.kickoff_async(inputs=inputs)
+print(async_result)
+
+# Example of using kickoff_for_each_async
+inputs_array = [{'topic': 'AI in healthcare'}, {'topic': 'AI in finance'}]
+async_results = my_crew.kickoff_for_each_async(inputs=inputs_array)
+for async_result in async_results:
+    print(async_result)
+```
+
+These methods provide flexibility in how you manage and execute tasks within your crew, allowing for both synchronous and asynchronous workflows tailored to your needs

docs/core-concepts/Memory.md

@@ -0,0 +1,170 @@
+---
+title: crewAI Memory Systems
+description: Leveraging memory systems in the crewAI framework to enhance agent capabilities.
+---
+
+## Introduction to Memory Systems in crewAI
+!!! note "Enhancing Agent Intelligence"
+    The crewAI framework introduces a sophisticated memory system designed to significantly enhance the capabilities of AI agents. This system comprises short-term memory, long-term memory, entity memory, and contextual memory, each serving a unique purpose in aiding agents to remember, reason, and learn from past interactions.
+
+## Memory System Components
+
+| Component            | Description                                                  |
+| :------------------- | :----------------------------------------------------------- |
+| **Short-Term Memory**| Temporarily stores recent interactions and outcomes, enabling agents to recall and utilize information relevant to their current context during the current executions. |
+| **Long-Term Memory** | Preserves valuable insights and learnings from past executions, allowing agents to build and refine their knowledge over time. So Agents can remember what they did right and wrong across multiple executions |
+| **Entity Memory**    | Captures and organizes information about entities (people, places, concepts) encountered during tasks, facilitating deeper understanding and relationship mapping. |
+| **Contextual Memory**| Maintains the context of interactions by combining `ShortTermMemory`, `LongTermMemory`, and `EntityMemory`, aiding in the coherence and relevance of agent responses over a sequence of tasks or a conversation. |
+
+## How Memory Systems Empower Agents
+
+1. **Contextual Awareness**: With short-term and contextual memory, agents gain the ability to maintain context over a conversation or task sequence, leading to more coherent and relevant responses.
+
+2. **Experience Accumulation**: Long-term memory allows agents to accumulate experiences, learning from past actions to improve future decision-making and problem-solving.
+
+3. **Entity Understanding**: By maintaining entity memory, agents can recognize and remember key entities, enhancing their ability to process and interact with complex information.
+
+## Implementing Memory in Your Crew
+
+When configuring a crew, you can enable and customize each memory component to suit the crew's objectives and the nature of tasks it will perform.
+By default, the memory system is disabled, and you can ensure it is active by setting `memory=True` in the crew configuration. The memory will use OpenAI Embeddings by default, but you can change it by setting `embedder` to a different model.
+
+### Example: Configuring Memory for a Crew
+
+```python
+from crewai import Crew, Agent, Task, Process
+
+# Assemble your crew with memory capabilities
+my_crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process=Process.sequential,
+    memory=True,
+    verbose=True
+)
+```
+
+## Additional Embedding Providers
+
+### Using OpenAI embeddings (already default)
+```python
+from crewai import Crew, Agent, Task, Process
+
+my_crew = Crew(
+		agents=[...],
+		tasks=[...],
+		process=Process.sequential,
+		memory=True,
+		verbose=True,
+		embedder={
+				"provider": "openai",
+				"config":{
+						"model": 'text-embedding-3-small'
+				}
+		}
+)
+```
+
+### Using Google AI embeddings
+```python
+from crewai import Crew, Agent, Task, Process
+
+my_crew = Crew(
+		agents=[...],
+		tasks=[...],
+		process=Process.sequential,
+		memory=True,
+		verbose=True,
+		embedder={
+			"provider": "google",
+			"config":{
+				"model": 'models/embedding-001',
+				"task_type": "retrieval_document",
+				"title": "Embeddings for Embedchain"
+			}
+		}
+)
+```
+
+### Using Azure OpenAI embeddings
+```python
+from crewai import Crew, Agent, Task, Process
+
+my_crew = Crew(
+		agents=[...],
+		tasks=[...],
+		process=Process.sequential,
+		memory=True,
+		verbose=True,
+		embedder={
+			"provider": "azure_openai",
+			"config":{
+				"model": 'text-embedding-ada-002',
+				"deployment_name": "you_embedding_model_deployment_name"
+			}
+		}
+)
+```
+
+### Using GPT4ALL embeddings
+```python
+from crewai import Crew, Agent, Task, Process
+
+my_crew = Crew(
+		agents=[...],
+		tasks=[...],
+		process=Process.sequential,
+		memory=True,
+		verbose=True,
+		embedder={
+			"provider": "gpt4all"
+		}
+)
+```
+
+### Using Vertex AI embeddings
+```python
+from crewai import Crew, Agent, Task, Process
+
+my_crew = Crew(
+		agents=[...],
+		tasks=[...],
+		process=Process.sequential,
+		memory=True,
+		verbose=True,
+		embedder={
+			"provider": "vertexai",
+			"config":{
+				"model": 'textembedding-gecko'
+			}
+		}
+)
+```
+
+### Using Cohere embeddings
+```python
+from crewai import Crew, Agent, Task, Process
+
+my_crew = Crew(
+		agents=[...],
+		tasks=[...],
+		process=Process.sequential,
+		memory=True,
+		verbose=True,
+		embedder={
+			"provider": "cohere",
+			"config":{
+				"model": "embed-english-v3.0"
+    		"vector_dimension": 1024
+			}
+		}
+)
+```
+
+## Benefits of Using crewAI's Memory System
+- **Adaptive Learning:** Crews become more efficient over time, adapting to new information and refining their approach to tasks.
+- **Enhanced Personalization:** Memory enables agents to remember user preferences and historical interactions, leading to personalized experiences.
+- **Improved Problem Solving:** Access to a rich memory store aids agents in making more informed decisions, drawing on past learnings and contextual insights.
+
+## Getting Started
+Integrating crewAI's memory system into your projects is straightforward. By leveraging the provided memory components and configurations, you can quickly empower your agents with the ability to remember, reason, and learn from their interactions, unlocking new levels of intelligence and capability.

docs/core-concepts/Processes.md

@@ -1,48 +1,64 @@
 ---
 title: Managing Processes in CrewAI
-description: An overview of workflow management through processes in CrewAI.
+description: Detailed guide on workflow management through processes in CrewAI, with updated implementation details.
 ---
 
 ## 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.
+    In CrewAI, processes orchestrate the execution of tasks by agents, akin to project management in human teams. These processes ensure tasks are distributed and executed efficiently, in alignment with a predefined strategy.
 
 ## 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.
+- **Sequential**: Executes tasks sequentially, ensuring tasks are completed in an orderly progression.
+- **Hierarchical**: Organizes tasks in a managerial hierarchy, where tasks are delegated and executed based on a structured chain of command. A manager language model (`manager_llm`) or a custom manager agent (`manager_agent`) must be specified in the crew to enable the hierarchical process, facilitating the creation and management of tasks by the manager.
+- **Consensual Process (Planned)**: Aiming for collaborative decision-making among agents on task execution, this process type introduces a democratic approach to task management within CrewAI. It is planned for future development and is not currently implemented in the codebase.
 
 ## 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.
+Processes enable individual agents to operate as a cohesive unit, streamlining their efforts to achieve common objectives with efficiency and coherence.
 
 ## Assigning Processes to a Crew
-Specify the process during crew creation to determine the execution strategy:
+To assign a process to a crew, specify the process type upon crew creation to set the execution strategy. For a hierarchical process, ensure to define `manager_llm` or `manager_agent` for the manager agent.
 
 ```python
 from crewai import Crew
 from crewai.process import Process
+from langchain_openai import ChatOpenAI
 
 # Example: Creating a crew with a sequential process
-crew = Crew(agents=my_agents, tasks=my_tasks, process=Process.sequential)
+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)
+# Ensure to provide a manager_llm or manager_agent
+crew = Crew(
+    agents=my_agents,
+    tasks=my_tasks,
+    process=Process.hierarchical,
+    manager_llm=ChatOpenAI(model="gpt-4")
+    # or
+    # manager_agent=my_manager_agent
+)
 ```
+**Note:** Ensure `my_agents` and `my_tasks` are defined prior to creating a `Crew` object, and for the hierarchical process, either `manager_llm` or `manager_agent` is also required.
 
 ## Sequential Process
-Ensures a natural flow of work, mirroring human team dynamics by progressing through tasks thoughtfully and systematically.
+This method mirrors dynamic team workflows, progressing through tasks in a thoughtful and systematic manner. Task execution follows the predefined order in the task list, with the output of one task serving as context for the next.
 
-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.
+To customize task context, utilize the `context` parameter in the `Task` class to specify outputs that should be used as context for subsequent tasks.
 
 ## Hierarchical Process
-Mimics a corporate hierarchy, where a manager oversees task execution, planning, delegation, and validation, enhancing task coordination.
+Emulates a corporate hierarchy, CrewAI allows specifying a custom manager agent or automatically creates one, requiring the specification of a manager language model (`manager_llm`). This agent oversees task execution, including planning, delegation, and validation. Tasks are not pre-assigned; the manager allocates tasks to agents based on their capabilities, reviews outputs, and assesses task completion.
 
-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.
+## Process Class: Detailed Overview
+The `Process` class is implemented as an enumeration (`Enum`), ensuring type safety and restricting process values to the defined types (`sequential`, `hierarchical`). The consensual process is planned for future inclusion, emphasizing our commitment to continuous development and innovation.
+
+## Additional Task Features
+- **Asynchronous Execution**: Tasks can now be executed asynchronously, allowing for parallel processing and efficiency improvements. This feature is designed to enable tasks to be carried out concurrently, enhancing the overall productivity of the crew.
+- **Human Input Review**: An optional feature that enables the review of task outputs by humans to ensure quality and accuracy before finalization. This additional step introduces a layer of oversight, providing an opportunity for human intervention and validation.
+- **Output Customization**: Tasks support various output formats, including JSON (`output_json`), Pydantic models (`output_pydantic`), and file outputs (`output_file`), providing flexibility in how task results are captured and utilized. This allows for a wide range of output possibilities, catering to different needs and requirements.
 
 ## 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.
+The structured collaboration facilitated by processes within CrewAI is crucial for enabling systematic teamwork among agents. This documentation has been updated to reflect the latest features, enhancements, and the planned integration of the Consensual Process, ensuring users have access to the most current and comprehensive information.

docs/core-concepts/Tasks.md

@@ -1,82 +1,83 @@
 ---
 title: crewAI Tasks
-description: Overview and management of tasks within the crewAI framework.
+description: Detailed guide on managing and creating tasks within the crewAI framework, reflecting the latest codebase updates.
 ---
 
 ## 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.
+    In the crewAI framework, tasks are specific assignments completed by agents. They provide all necessary details for execution, such as a description, the agent responsible, required tools, and more, facilitating a wide range of 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.
+Tasks within crewAI can be collaborative, requiring multiple agents to work together. This is managed through the task properties and orchestrated by the Crew's process, enhancing teamwork and efficiency.
 
 ## 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 |
-| **Output JSON**  *(optional)*     | Takes a pydantic model and returns the output as a JSON object. **Agent LLM needs to be using OpenAI client, could be Ollama for example but using the OpenAI wrapper** |
-| **Output Pydantic**  *(optional)*     | Takes a pydantic model and returns the output as a pydantic object. **Agent LLM needs to be using OpenAI client, could be Ollama for example but using the OpenAI wrapper** |
-| **Output File**  *(optional)*     | Takes a file path and saves the output of the task on it. |
-| **Callback**  *(optional)*  | A function to be executed after the task is completed. |
+| Attribute              | Parameters           | Description                                                                                   |
+| :----------------------| :------------------- | :-------------------------------------------------------------------------------------------- |
+| **Description**        | `description`          | A clear, concise statement of what the task entails.                                          |
+| **Agent**              | `agent`                | The agent responsible for the task, assigned either directly or by the crew's process.        |
+| **Expected Output**    | `expected_output`      | A detailed description of what the task's completion looks like.                              |
+| **Tools** *(optional)* | `tools`                | The functions or capabilities the agent can utilize to perform the task.                      |
+| **Async Execution** *(optional)* | `async_execution`      | If set, the task executes asynchronously, allowing progression without waiting for completion.|
+| **Context**  *(optional)* | `context`              | Specifies tasks whose outputs are used as context for this task.                              |
+| **Config** *(optional)* | `config`               | Additional configuration details for the agent executing the task, allowing further customization. |
+| **Output JSON**  *(optional)* | `output_json`          | Outputs a JSON object, requiring an OpenAI client. Only one output format can be set.         |
+| **Output Pydantic**  *(optional)* | `output_pydantic`      | Outputs a Pydantic model object, requiring an OpenAI client. Only one output format can be set. |
+| **Output File**  *(optional)* | `output_file`          | Saves the task output to a file. If used with `Output JSON` or `Output Pydantic`, specifies how the output is saved. |
+| **Callback**  *(optional)* | `callback`             | A Python callable that is executed with the task's output upon completion.                    |
+| **Human Input** *(optional)* | `human_input`         | Indicates if the task requires human feedback at the end, useful for tasks needing human oversight. |
 
 ## 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:
+Creating a task involves defining its scope, responsible agent, and any additional attributes for flexibility:
 
 ```python
 from crewai import Task
 
 task = Task(
-	description='Find and summarize the latest and most relevant news on AI',
-	agent=sales_agent
+    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.
+    Directly specify an `agent` for assignment or let the `hierarchical` CrewAI's process decide based on roles, availability, etc.
 
 ## 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.
+Leverage tools from the [crewAI Toolkit](https://github.com/joaomdmoura/crewai-tools) and [LangChain Tools](https://python.langchain.com/docs/integrations/tools) for enhanced task performance and agent interaction.
 
 ## Creating a Task with Tools
 
 ```python
 import os
 os.environ["OPENAI_API_KEY"] = "Your Key"
+os.environ["SERPER_API_KEY"] = "Your Key" # serper.dev API key
 
 from crewai import Agent, Task, Crew
-from langchain.agents import Tool
-from langchain_community.tools import DuckDuckGoSearchRun
+from crewai_tools import SerperDevTool
 
 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
+  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()
+search_tool = SerperDevTool()
 
 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,
+  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
+    agents=[research_agent],
+    tasks=[task],
+    verbose=2
 )
 
 result = crew.kickoff()
@@ -85,27 +86,36 @@ print(result)
 
 This demonstrates how tasks with specific tools can override an agent's default set for tailored task execution.
 
-## Refering other Tasks
+## Referring to 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.
+In crewAI, the output of one task is automatically relayed into the next one, but you can specifically define what tasks' output, including multiple, 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]
+research_ai_task = Task(
+    description='Find and summarize the latest AI news',
+    expected_output='A bullet list summary of the top 5 most important AI news',
+    async_execution=True,
+    agent=research_agent,
+    tools=[search_tool]
+)
+
+research_ops_task = Task(
+    description='Find and summarize the latest AI Ops news',
+    expected_output='A bullet list summary of the top 5 most important AI Ops news',
+    async_execution=True,
+    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]
+    description="Write a full blog post about the importance of AI and its latest news",
+    expected_output='Full blog post that is 4 paragraphs long',
+    agent=writer_agent,
+    context=[research_ai_task, research_ops_task]
 )
 
 #...
@@ -113,7 +123,7 @@ write_blog_task = 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 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.
 
@@ -121,24 +131,24 @@ You can then use the `context` attribute to define in a future task that it shou
 #...
 
 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
+    description="List of 5 interesting ideas to explore for an 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
+    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
+    description="Write an article about AI, its 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
 )
 
 #...
@@ -146,70 +156,94 @@ write_article = 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.
+The callback function is executed after the task is completed, allowing for actions or notifications to be triggered based on the task's outcome.
 
 ```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}
-	""")
+    # Do something after the task is completed
+    # Example: Send an email to the manager
+    print(f"""
+        Task completed!
+        Task: {output.description}
+        Output: {output.raw_output}
+    """)
 
 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
+    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
+## 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]
+    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
+    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}
+    Task completed!
+    Task: {task1.output.description}
+    Output: {task1.output.raw_output}
 """)
 ```
 
-
-
-
 ## Tool Override Mechanism
 
 Specifying tools in a task allows for dynamic adaptation of agent capabilities, emphasizing CrewAI's flexibility.
 
+## Error Handling and Validation Mechanisms
+
+While creating and executing tasks, certain validation mechanisms are in place to ensure the robustness and reliability of task attributes. These include but are not limited to:
+
+- Ensuring only one output type is set per task to maintain clear output expectations.
+- Preventing the manual assignment of the `id` attribute to uphold the integrity of the unique identifier system.
+
+These validations help in maintaining the consistency and reliability of task executions within the crewAI framework.
+
+## Creating Directories when Saving Files
+
+You can now specify if a task should create directories when saving its output to a file. This is particularly useful for organizing outputs and ensuring that file paths are correctly structured.
+
+```python
+# ...
+
+save_output_task = Task(
+    description='Save the summarized AI news to a file',
+    expected_output='File saved successfully',
+    agent=research_agent,
+    tools=[file_save_tool],
+    output_file='outputs/ai_news_summary.txt',
+    create_directory=True
+)
+
+#...
+```
+
 ## 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.
+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, understanding the execution process, and following robust validation practices are crucial for maximizing CrewAI's potential, ensuring agents are effectively prepared for their assignments and that tasks are executed as intended.

docs/core-concepts/Tools.md

@@ -1,83 +1,194 @@
 ---
 title: crewAI Tools
-description: Understanding and leveraging tools within the crewAI framework.
+description: Understanding and leveraging tools within the crewAI framework for agent collaboration and task execution.
 ---
 
+## Introduction
+CrewAI tools empower agents with capabilities ranging from web searching and data analysis to collaboration and delegating tasks among coworkers. This documentation outlines how to create, integrate, and leverage these tools within the CrewAI framework, including a new focus on collaboration tools.
+
 ## 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.
+    A tool in CrewAI is a skill or function that agents can utilize to perform various actions. This includes tools from the [crewAI Toolkit](https://github.com/joaomdmoura/crewai-tools) and [LangChain Tools](https://python.langchain.com/docs/integrations/tools), enabling everything from simple searches to complex interactions and effective teamwork among agents.
 
 ## 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.
+- **Utility**: Crafted for tasks such as web searching, data analysis, content generation, and agent collaboration.
+- **Integration**: Boosts agent capabilities by seamlessly integrating tools into their workflow.
+- **Customizability**: Provides the flexibility to develop custom tools or utilize existing ones, catering to the specific needs of agents.
+- **Error Handling**: Incorporates robust error handling mechanisms to ensure smooth operation.
+- **Caching Mechanism**: Features intelligent caching to optimize performance and reduce redundant operations.
+
+## Using crewAI Tools
+
+To enhance your agents' capabilities with crewAI tools, begin by installing our extra tools package:
+
+```bash
+pip install 'crewai[tools]'
+```
+
+Here's an example demonstrating their use:
+
+```python
+import os
+from crewai import Agent, Task, Crew
+# Importing crewAI tools
+from crewai_tools import (
+    DirectoryReadTool,
+    FileReadTool,
+    SerperDevTool,
+    WebsiteSearchTool
+)
+
+# Set up API keys
+os.environ["SERPER_API_KEY"] = "Your Key" # serper.dev API key
+os.environ["OPENAI_API_KEY"] = "Your Key"
+
+# Instantiate tools
+docs_tool = DirectoryReadTool(directory='./blog-posts')
+file_tool = FileReadTool()
+search_tool = SerperDevTool()
+web_rag_tool = WebsiteSearchTool()
+
+# Create agents
+researcher = Agent(
+    role='Market Research Analyst',
+    goal='Provide up-to-date market analysis of the AI industry',
+    backstory='An expert analyst with a keen eye for market trends.',
+    tools=[search_tool, web_rag_tool],
+    verbose=True
+)
+
+writer = Agent(
+    role='Content Writer',
+    goal='Craft engaging blog posts about the AI industry',
+    backstory='A skilled writer with a passion for technology.',
+    tools=[docs_tool, file_tool],
+    verbose=True
+)
+
+# Define tasks
+research = Task(
+    description='Research the latest trends in the AI industry and provide a summary.',
+    expected_output='A summary of the top 3 trending developments in the AI industry with a unique perspective on their significance.',
+    agent=researcher
+)
+
+write = Task(
+    description='Write an engaging blog post about the AI industry, based on the research analyst’s summary. Draw inspiration from the latest blog posts in the directory.',
+    expected_output='A 4-paragraph blog post formatted in markdown with engaging, informative, and accessible content, avoiding complex jargon.',
+    agent=writer,
+    output_file='blog-posts/new_post.md'  # The final blog post will be saved here
+)
+
+# Assemble a crew
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[research, write],
+    verbose=2
+)
+
+# Execute tasks
+crew.kickoff()
+```
+
+## Available crewAI Tools
+
+- **Error Handling**: All tools are built with error handling capabilities, allowing agents to gracefully manage exceptions and continue their tasks.
+- **Caching Mechanism**: All tools support caching, enabling agents to efficiently reuse previously obtained results, reducing the load on external resources and speeding up the execution time. You can also define finer control over the caching mechanism using the `cache_function` attribute on the tool.
+
+Here is a list of the available tools and their descriptions:
+
+| Tool                        | Description                                                                                   |
+| :-------------------------- | :-------------------------------------------------------------------------------------------- |
+| **CodeDocsSearchTool**      | A RAG tool optimized for searching through code documentation and related technical documents. |
+| **CSVSearchTool**           | A RAG tool designed for searching within CSV files, tailored to handle structured data.       |
+| **DirectorySearchTool**     | A RAG tool for searching within directories, useful for navigating through file systems.      |
+| **DOCXSearchTool**          | A RAG tool aimed at searching within DOCX documents, ideal for processing Word files.         |
+| **DirectoryReadTool**       | Facilitates reading and processing of directory structures and their contents.                |
+| **FileReadTool**            | Enables reading and extracting data from files, supporting various file formats.              |
+| **GithubSearchTool**        | A RAG tool for searching within GitHub repositories, useful for code and documentation search.|
+| **SerperDevTool**           | A specialized tool for development purposes, with specific functionalities under development. |
+| **TXTSearchTool**           | A RAG tool focused on searching within text (.txt) files, suitable for unstructured data.     |
+| **JSONSearchTool**          | A RAG tool designed for searching within JSON files, catering to structured data handling.     |
+| **MDXSearchTool**           | A RAG tool tailored for searching within Markdown (MDX) files, useful for documentation.      |
+| **PDFSearchTool**           | A RAG tool aimed at searching within PDF documents, ideal for processing scanned documents.    |
+| **PGSearchTool**            | A RAG tool optimized for searching within PostgreSQL databases, suitable for database queries. |
+| **RagTool**                 | A general-purpose RAG tool capable of handling various data sources and types.                 |
+| **ScrapeElementFromWebsiteTool** | Enables scraping specific elements from websites, useful for targeted data extraction.     |
+| **ScrapeWebsiteTool**       | Facilitates scraping entire websites, ideal for comprehensive data collection.                 |
+| **WebsiteSearchTool**       | A RAG tool for searching website content, optimized for web data extraction.                   |
+| **XMLSearchTool**           | A RAG tool designed for searching within XML files, suitable for structured data formats.      |
+| **YoutubeChannelSearchTool**| A RAG tool for searching within YouTube channels, useful for video content analysis.           |
+| **YoutubeVideoSearchTool**  | A RAG tool aimed at searching within YouTube videos, ideal for video data extraction.          |
+| **BrowserbaseTool**         | A tool for interacting with and extracting data from web browsers.                            |
+| **ExaSearchTool**           | A tool designed for performing exhaustive searches across various data sources.               |
 
 ## 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:
+    Developers can craft custom tools tailored for their agent’s needs or utilize pre-built options:
 
-```python
-import json
-import requests
-from crewai import Agent
-from langchain.tools import tool
-from unstructured.partition.html import partition_html
+To create your own crewAI tools you will need to install our extra tools package:
 
-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]
-)
+```bash
+pip install 'crewai[tools]'
 ```
 
-## Using LangChain Tools
-!!! info "LangChain Integration"
-    CrewAI seamlessly integrates with LangChain’s comprehensive toolkit. Assigning an existing tool to an agent is straightforward:
+Once you do that there are two main ways for one to create a crewAI tool:
+### Subclassing `BaseTool`
 
 ```python
-from crewai import Agent
-from langchain.agents import Tool
-from langchain.utilities import GoogleSerperAPIWrapper
-import os
+from crewai_tools import BaseTool
 
-# Setup API keys
-os.environ["OPENAI_API_KEY"] = "Your Key"
-os.environ["SERPER_API_KEY"] = "Your Key"
+class MyCustomTool(BaseTool):
+    name: str = "Name of my tool"
+    description: str = "Clear description for what this tool is useful for, your agent will need this information to use it."
 
-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]
-)
+    def _run(self, argument: str) -> str:
+        # Implementation goes here
+        return "Result from custom tool"
 ```
 
+### Utilizing the `tool` Decorator
+
+```python
+from crewai_tools import tool
+@tool("Name of my tool")
+def my_tool(question: str) -> str:
+    """Clear description for what this tool is useful for, your agent will need this information to use it."""
+    # Function logic here
+    return "Result from your custom tool"
+```
+
+### Custom Caching Mechanism
+!!! note "Caching"
+    Tools can optionally implement a `cache_function` to fine-tune caching behavior. This function determines when to cache results based on specific conditions, offering granular control over caching logic.
+
+```python
+from crewai_tools import tool
+
+@tool
+def multiplication_tool(first_number: int, second_number: int) -> str:
+    """Useful for when you need to multiply two numbers together."""
+    return first_number * second_number
+
+def cache_func(args, result):
+    # In this case, we only cache the result if it's a multiple of 2
+    cache = result % 2 == 0
+    return cache
+
+multiplication_tool.cache_function = cache_func
+
+writer1 = Agent(
+        role="Writer",
+        goal="You write lessons of math for kids.",
+        backstory="You're an expert in writing and you love to teach kids but you know nothing of math.",
+        tools=[multiplication_tool],
+        allow_delegation=False,
+    )
+    #...
+```
+
+
 ## 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.
+Tools are pivotal in extending the capabilities of CrewAI agents, enabling them to undertake a broad spectrum of tasks and collaborate effectively. When building solutions with CrewAI, leverage both custom and existing tools to empower your agents and enhance the AI ecosystem. Consider utilizing error handling, caching mechanisms, and the flexibility of tool arguments to optimize your agents' performance and capabilities.

docs/core-concepts/Training-Crew.md

@@ -0,0 +1,53 @@
+---
+title: crewAI Train
+description: Learn how to train your crewAI agents by giving them feedback early on and get consistent results.
+---
+
+## Introduction
+The training feature in CrewAI allows you to train your AI agents using the command-line interface (CLI). By running the command `crewai train -n <n_iterations>`, you can specify the number of iterations for the training process.
+
+During training, CrewAI utilizes techniques to optimize the performance of your agents along with human feedback. This helps the agents improve their understanding, decision-making, and problem-solving abilities.
+
+### Training Your Crew Using the CLI
+To use the training feature, follow these steps:
+
+1. Open your terminal or command prompt.
+2. Navigate to the directory where your CrewAI project is located.
+3. Run the following command:
+
+```shell
+crewai train -n <n_iterations>
+```
+
+### Training Your Crew Programmatically
+To train your crew programmatically, use the following steps:
+
+1. Define the number of iterations for training.
+2. Specify the input parameters for the training process.
+3. Execute the training command within a try-except block to handle potential errors.
+
+```python
+    n_iterations = 2
+    inputs = {"topic": "CrewAI Training"}
+
+    try:
+        YourCrewName_Crew().crew().train(n_iterations= n_iterations, inputs=inputs)
+
+    except Exception as e:
+        raise Exception(f"An error occurred while training the crew: {e}")
+```
+
+!!! note "Replace `<n_iterations>` with the desired number of training iterations. This determines how many times the agents will go through the training process."
+
+
+### Key Points to Note:
+- **Positive Integer Requirement:** Ensure that the number of iterations (`n_iterations`) is a positive integer. The code will raise a `ValueError` if this condition is not met.
+- **Error Handling:** The code handles subprocess errors and unexpected exceptions, providing error messages to the user.
+
+It is important to note that the training process may take some time, depending on the complexity of your agents and will also require your feedback on each iteration.
+
+Once the training is complete, your agents will be equipped with enhanced capabilities and knowledge, ready to tackle complex tasks and provide more consistent and valuable insights.
+
+Remember to regularly update and retrain your agents to ensure they stay up-to-date with the latest information and advancements in the field.
+
+Happy training with CrewAI!

docs/core-concepts/Using-LangChain-Tools.md

@@ -0,0 +1,38 @@
+---
+title: Using LangChain Tools
+description: Learn how to integrate LangChain tools with CrewAI agents to enhance search-based queries and more.
+---
+
+## Using LangChain Tools
+!!! info "LangChain Integration"
+    CrewAI seamlessly integrates with LangChain’s comprehensive toolkit for search-based queries and more, here are the available built-in tools that are offered by Langchain [LangChain Toolkit](https://python.langchain.com/docs/integrations/tools/)
+
+```python
+from crewai import Agent
+from langchain.agents import Tool
+from langchain.utilities import GoogleSerperAPIWrapper
+
+# Setup API keys
+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]
+)
+
+# rest of the code ...
+```
+
+## Conclusion
+Tools are pivotal in extending the capabilities of CrewAI agents, enabling them to undertake a broad spectrum of tasks and collaborate effectively. When building solutions with CrewAI, leverage both custom and existing tools to empower your agents and enhance the AI ecosystem. Consider utilizing error handling, caching mechanisms, and the flexibility of tool arguments to optimize your agents' performance and capabilities.

docs/core-concepts/Using-LlamaIndex-Tools.md

@@ -0,0 +1,57 @@
+---
+title: Using LlamaIndex Tools
+description: Learn how to integrate LlamaIndex tools with CrewAI agents to enhance search-based queries and more.
+---
+
+## Using LlamaIndex Tools
+
+!!! info "LlamaIndex Integration"
+    CrewAI seamlessly integrates with LlamaIndex’s comprehensive toolkit for RAG (Retrieval-Augmented Generation) and agentic pipelines, enabling advanced search-based queries and more. Here are the available built-in tools offered by LlamaIndex.
+
+```python
+from crewai import Agent
+from crewai_tools import LlamaIndexTool
+
+# Example 1: Initialize from FunctionTool
+from llama_index.core.tools import FunctionTool
+
+your_python_function = lambda ...: ...
+og_tool = FunctionTool.from_defaults(your_python_function, name="<name>", description='<description>')
+tool = LlamaIndexTool.from_tool(og_tool)
+
+# Example 2: Initialize from LlamaHub Tools
+from llama_index.tools.wolfram_alpha import WolframAlphaToolSpec
+wolfram_spec = WolframAlphaToolSpec(app_id="<app_id>")
+wolfram_tools = wolfram_spec.to_tool_list()
+tools = [LlamaIndexTool.from_tool(t) for t in wolfram_tools]
+
+# Example 3: Initialize Tool from a LlamaIndex Query Engine
+query_engine = index.as_query_engine()
+query_tool = LlamaIndexTool.from_query_engine(
+    query_engine,
+    name="Uber 2019 10K Query Tool",
+    description="Use this tool to lookup the 2019 Uber 10K Annual Report"
+)
+
+# Create and assign the tools 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=[tool, *tools, query_tool]
+)
+
+# rest of the code ...
+```
+
+## Steps to Get Started
+
+To effectively use the LlamaIndexTool, follow these steps:
+
+1. **Package Installation**: Confirm that the `crewai[tools]` package is installed in your Python environment.
+
+    ```shell
+    pip install 'crewai[tools]'
+    ```
+
+2. **Install and Use LlamaIndex**: Follow LlamaIndex documentation [LlamaIndex Documentation](https://docs.llamaindex.ai/) to set up a RAG/agent pipeline.

docs/how-to/AgentOps-Observability.md

@@ -0,0 +1,86 @@
+---
+title: Agent Monitoring with AgentOps
+description: Understanding and logging your agent performance with AgentOps.
+---
+
+# Intro
+Observability is a key aspect of developing and deploying conversational AI agents. It allows developers to understand how their agents are performing, how their agents are interacting with users, and how their agents use external tools and APIs. AgentOps is a product independent of CrewAI that provides a comprehensive observability solution for agents.
+
+## AgentOps
+
+[AgentOps](https://agentops.ai/?=crew) provides session replays, metrics, and monitoring for agents.
+
+At a high level, AgentOps gives you the ability to monitor cost, token usage, latency, agent failures, session-wide statistics, and more. For more info, check out the [AgentOps Repo](https://github.com/AgentOps-AI/agentops).
+
+### Overview
+AgentOps provides monitoring for agents in development and production. It provides a dashboard for tracking agent performance, session replays, and custom reporting.
+
+Additionally, AgentOps provides session drilldowns for viewing Crew agent interactions, LLM calls, and tool usage in real-time. This feature is useful for debugging and understanding how agents interact with users as well as other agents.
+
+![Overview of a select series of agent session runs](..%2Fassets%2Fagentops-overview.png)
+![Overview of session drilldowns for examining agent runs](..%2Fassets%2Fagentops-session.png)
+![Viewing a step-by-step agent replay execution graph](..%2Fassets%2Fagentops-replay.png)
+
+### Features
+- **LLM Cost Management and Tracking**: Track spend with foundation model providers.
+- **Replay Analytics**: Watch step-by-step agent execution graphs.
+- **Recursive Thought Detection**: Identify when agents fall into infinite loops.
+- **Custom Reporting**: Create custom analytics on agent performance.
+- **Analytics Dashboard**: Monitor high-level statistics about agents in development and production.
+- **Public Model Testing**: Test your agents against benchmarks and leaderboards.
+- **Custom Tests**: Run your agents against domain-specific tests.
+- **Time Travel Debugging**: Restart your sessions from checkpoints.
+- **Compliance and Security**: Create audit logs and detect potential threats such as profanity and PII leaks.
+- **Prompt Injection Detection**: Identify potential code injection and secret leaks.
+
+### Using AgentOps
+
+1. **Create an API Key:**
+   Create a user API key here: [Create API Key](app.agentops.ai/account)
+
+2. **Configure Your Environment:**
+   Add your API key to your environment variables
+
+   ```bash
+   AGENTOPS_API_KEY=<YOUR_AGENTOPS_API_KEY>
+   ```
+
+3. **Install AgentOps:**
+   Install AgentOps with:
+   ```bash
+   pip install crewai[agentops]
+   ```
+   or
+   ```bash
+   pip install agentops
+   ```
+
+   Before using `Crew` in your script, include these lines:
+
+   ```python
+   import agentops
+   agentops.init()
+   ```
+
+   This will initiate an AgentOps session as well as automatically track Crew agents. For further info on how to outfit more complex agentic systems, check out the [AgentOps documentation](https://docs.agentops.ai) or join the [Discord](https://discord.gg/j4f3KbeH).
+
+### Crew + AgentOps Examples
+- [Job Posting](https://github.com/joaomdmoura/crewAI-examples/tree/main/job-posting)
+- [Markdown Validator](https://github.com/joaomdmoura/crewAI-examples/tree/main/markdown_validator)
+- [Instagram Post](https://github.com/joaomdmoura/crewAI-examples/tree/main/instagram_post)
+
+### Further Information
+
+To get started, create an [AgentOps account](https://agentops.ai/?=crew).
+
+For feature requests or bug reports, please reach out to the AgentOps team on the [AgentOps Repo](https://github.com/AgentOps-AI/agentops).
+
+#### Extra links
+
+<a href="https://twitter.com/agentopsai/">🐦 Twitter</a>
+<span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+<a href="https://discord.gg/JHPt4C7r">📢 Discord</a>
+<span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+<a href="https://app.agentops.ai/?=crew">🖇️ AgentOps Dashboard</a>
+<span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+<a href="https://docs.agentops.ai/introduction">📙 Documentation</a>

docs/how-to/Coding-Agents.md

@@ -0,0 +1,76 @@
+---
+title: Coding Agents
+description: Learn how to enable your crewAI Agents to write and execute code, and explore advanced features for enhanced functionality.
+---
+
+## Introduction
+
+crewAI Agents now have the powerful ability to write and execute code, significantly enhancing their problem-solving capabilities. This feature is particularly useful for tasks that require computational or programmatic solutions.
+
+## Enabling Code Execution
+
+To enable code execution for an agent, set the `allow_code_execution` parameter to `True` when creating the agent. Here's an example:
+
+```python
+from crewai import Agent
+
+coding_agent = Agent(
+    role="Senior Python Developer",
+    goal="Craft well-designed and thought-out code",
+    backstory="You are a senior Python developer with extensive experience in software architecture and best practices.",
+    allow_code_execution=True
+)
+```
+
+## Important Considerations
+
+1. **Model Selection**: It is strongly recommended to use more capable models like Claude 3.5 Sonnet and GPT-4 when enabling code execution. These models have a better understanding of programming concepts and are more likely to generate correct and efficient code.
+
+2. **Error Handling**: The code execution feature includes error handling. If executed code raises an exception, the agent will receive the error message and can attempt to correct the code or provide alternative solutions.
+
+3. **Dependencies**: To use the code execution feature, you need to install the `crewai_tools` package. If not installed, the agent will log an info message: "Coding tools not available. Install crewai_tools."
+
+## Code Execution Process
+
+When an agent with code execution enabled encounters a task requiring programming:
+
+1. The agent analyzes the task and determines that code execution is necessary.
+2. It formulates the Python code needed to solve the problem.
+3. The code is sent to the internal code execution tool (`CodeInterpreterTool`).
+4. The tool executes the code in a controlled environment and returns the result.
+5. The agent interprets the result and incorporates it into its response or uses it for further problem-solving.
+
+## Example Usage
+
+Here's a detailed example of creating an agent with code execution capabilities and using it in a task:
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create an agent with code execution enabled
+coding_agent = Agent(
+    role="Python Data Analyst",
+    goal="Analyze data and provide insights using Python",
+    backstory="You are an experienced data analyst with strong Python skills.",
+    allow_code_execution=True
+)
+
+# Create a task that requires code execution
+data_analysis_task = Task(
+    description="Analyze the given dataset and calculate the average age of participants.",
+    agent=coding_agent
+)
+
+# Create a crew and add the task
+analysis_crew = Crew(
+    agents=[coding_agent],
+    tasks=[data_analysis_task]
+)
+
+# Execute the crew
+result = analysis_crew.kickoff()
+
+print(result)
+```
+
+In this example, the `coding_agent` can write and execute Python code to perform data analysis tasks.

docs/how-to/Create-Custom-Tools.md

@@ -0,0 +1,63 @@
+---
+title: Creating and Utilizing Tools in crewAI
+description: Comprehensive guide on crafting, using, and managing custom tools within the crewAI framework, including new functionalities and error handling.
+---
+
+## Creating and Utilizing Tools in crewAI
+This guide provides detailed instructions on creating custom tools for the crewAI framework and how to efficiently manage and utilize these tools, incorporating the latest functionalities such as tool delegation, error handling, and dynamic tool calling. It also highlights the importance of collaboration tools, enabling agents to perform a wide range of actions.
+
+### Prerequisites
+Before creating your own tools, ensure you have the crewAI extra tools package installed:
+
+```bash
+pip install 'crewai[tools]'
+```
+
+### Subclassing `BaseTool`
+
+To create a personalized tool, inherit from `BaseTool` and define the necessary attributes and the `_run` method.
+
+```python
+from crewai_tools import BaseTool
+
+class MyCustomTool(BaseTool):
+    name: str = "Name of my tool"
+    description: str = "What this tool does. It's vital for effective utilization."
+
+    def _run(self, argument: str) -> str:
+        # Your tool's logic here
+        return "Tool's result"
+```
+
+### Using the `tool` Decorator
+
+Alternatively, use the `tool` decorator for a direct approach to create tools. This requires specifying attributes and the tool's logic within a function.
+
+```python
+from crewai_tools import tool
+
+@tool("Tool Name")
+def my_simple_tool(question: str) -> str:
+    """Tool description for clarity."""
+    # Tool logic here
+    return "Tool output"
+```
+
+### Defining a Cache Function for the Tool
+
+To optimize tool performance with caching, define custom caching strategies using the `cache_function` attribute.
+
+```python
+@tool("Tool with Caching")
+def cached_tool(argument: str) -> str:
+    """Tool functionality description."""
+    return "Cacheable result"
+
+def my_cache_strategy(arguments: dict, result: str) -> bool:
+    # Define custom caching logic
+    return True if some_condition else False
+
+cached_tool.cache_function = my_cache_strategy
+```
+
+By adhering to these guidelines and incorporating new functionalities and collaboration tools into your tool creation and management processes, you can leverage the full capabilities of the crewAI framework, enhancing both the development experience and the efficiency of your AI agents.

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

@@ -1,112 +1,82 @@
 ---
 title: Assembling and Activating Your CrewAI Team
-description: A step-by-step guide to creating a cohesive CrewAI team for your projects.
+description: A comprehensive guide to creating a dynamic CrewAI team for your projects, with updated functionalities including verbose mode, memory capabilities, asynchronous execution, output customization, language model configuration, code execution, integration with third-party agents, and improved task management.
 ---
 
 ## 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.
+Embark on your CrewAI journey by setting up your environment and initiating your AI crew with the latest features. This guide ensures a smooth start, incorporating all recent updates for an enhanced experience, including code execution capabilities, integration with third-party agents, and advanced task management.
 
 ## 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.
+Install CrewAI and any necessary packages for your project. CrewAI is compatible with Python >=3.10,<=3.13.
 
 ```shell
 pip install crewai
-pip install duckduckgo-search
+pip install 'crewai[tools]'
 ```
 
 ## 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.
+Define your agents with distinct roles, backstories, and enhanced capabilities. The Agent class now supports a wide range of attributes for fine-tuned control over agent behavior and interactions, including code execution and integration with third-party agents.
 
 ```python
 import os
-os.environ["OPENAI_API_KEY"] = "Your Key"
-
+from langchain.llms import OpenAI
 from crewai import Agent
+from crewai_tools import SerperDevTool, BrowserbaseTool, ExaSearchTool
 
-# Topic that will be used in the crew run
-topic = 'AI in healthcare'
+os.environ["OPENAI_API_KEY"] = "Your OpenAI Key"
+os.environ["SERPER_API_KEY"] = "Your Serper Key"
 
-# Creating a senior researcher agent
+search_tool = SerperDevTool()
+browser_tool = BrowserbaseTool()
+exa_search_tool = ExaSearchTool()
+
+# Creating a senior researcher agent with advanced configurations
 researcher = Agent(
-  role='Senior Researcher',
-  goal=f'Uncover groundbreaking technologies around {topic}',
-  verbose=True,
-  backstory="""Driven by curiosity, you're at the forefront of
-  innovation, eager to explore and share knowledge that could change
-  the world."""
+    role='Senior Researcher',
+    goal='Uncover groundbreaking technologies in {topic}',
+    backstory=("Driven by curiosity, you're at the forefront of innovation, "
+               "eager to explore and share knowledge that could change the world."),
+    memory=True,
+    verbose=True,
+    allow_delegation=False,
+    tools=[search_tool, browser_tool],
+    allow_code_execution=False,  # New attribute for enabling code execution
+    max_iter=15,  # Maximum number of iterations for task execution
+    max_rpm=100,  # Maximum requests per minute
+    max_execution_time=3600,  # Maximum execution time in seconds
+    system_template="Your custom system template here",  # Custom system template
+    prompt_template="Your custom prompt template here",  # Custom prompt template
+    response_template="Your custom response template here",  # Custom response template
 )
 
-# Creating a writer agent
+# Creating a writer agent with custom tools and specific configurations
 writer = Agent(
-  role='Writer',
-  goal=f'Narrate compelling tech stories around {topic}',
+    role='Writer',
+    goal='Narrate compelling tech stories about {topic}',
+    backstory=("With a flair for simplifying complex topics, you craft engaging "
+               "narratives that captivate and educate, bringing new discoveries to light."),
+    verbose=True,
+    allow_delegation=False,
+    memory=True,
+    tools=[exa_search_tool],
+    function_calling_llm=OpenAI(model_name="gpt-3.5-turbo"),  # Separate LLM for function calling
+)
+
+# Setting a specific manager agent
+manager = Agent(
+  role='Manager',
+  goal='Ensure the smooth operation and coordination of the team',
   verbose=True,
-  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."""
+  backstory=(
+    "As a seasoned project manager, you excel in organizing "
+    "tasks, managing timelines, and ensuring the team stays on track."
+  ),
+  allow_code_execution=True,  # Enable code execution for the manager
 )
 ```
 
-## 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.
+### New Agent Attributes and Features
 
-```python
-from crewai import Task
-
-# 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=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
-)
-
-# Writing task based on research findings
-write_task = Task(
-  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
-Combine your agents into a crew, setting the workflow process they'll follow to accomplish the tasks.
-
-```python
-from crewai import Crew, Process
-
-# Forming the tech-focused crew
-crew = Crew(
-  agents=[researcher, writer],
-  tasks=[research_task, write_task],
-  process=Process.sequential  # Sequential task execution
-)
-```
-
-## 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
-# Starting the task execution process
-result = crew.kickoff()
-print(result)
-```
-
-## 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.
+1. `allow_code_execution`: Enable or disable code execution capabilities for the agent (default is False).
+2. `max_execution_time`: Set a maximum execution time (in seconds) for the agent to complete a task.
+3. `function_calling_llm`: Specify a separate language model for function calling.

docs/how-to/Customize-Prompts.md

@@ -0,0 +1,94 @@
+---
+title: Initial Support to Bring Your Own Prompts in CrewAI
+description: Enhancing customization and internationalization by allowing users to bring their own prompts in CrewAI.
+
+---
+
+# Initial Support to Bring Your Own Prompts in CrewAI
+
+CrewAI now supports the ability to bring your own prompts, enabling extensive customization and internationalization. This feature allows users to tailor the inner workings of their agents to better suit specific needs, including support for multiple languages.
+
+## Internationalization and Customization Support
+
+### Custom Prompts with `prompt_file`
+
+The `prompt_file` attribute facilitates full customization of the agent prompts, enhancing the global usability of CrewAI. Users can specify their prompt templates, ensuring that the agents communicate in a manner that aligns with specific project requirements or language preferences.
+
+#### Example of a Custom Prompt File
+
+The custom prompts can be defined in a JSON file, similar to the example provided [here](https://github.com/joaomdmoura/crewAI/blob/main/src/crewai/translations/en.json).
+
+### Supported Languages
+
+CrewAI's custom prompt support includes internationalization, allowing prompts to be written in different languages. This is particularly useful for global teams or projects that require multilingual support.
+
+## How to Use the `prompt_file` Attribute
+
+To utilize the `prompt_file` attribute, include it in your crew definition. Below is an example demonstrating how to set up agents and tasks with custom prompts.
+
+### Example
+
+```python
+import os
+from crewai import Agent, Task, Crew
+
+# Define your agents
+researcher = Agent(
+    role="Researcher",
+    goal="Make the best research and analysis on content about AI and AI agents",
+    backstory="You're an expert researcher, specialized in technology, software engineering, AI and startups. You work as a freelancer and is now working on doing research and analysis for a new customer.",
+    allow_delegation=False,
+)
+
+writer = Agent(
+    role="Senior Writer",
+    goal="Write the best content about AI and AI agents.",
+    backstory="You're a senior writer, specialized in technology, software engineering, AI and startups. You work as a freelancer and are now working on writing content for a new customer.",
+    allow_delegation=False,
+)
+
+# Define your tasks
+tasks = [
+    Task(
+        description="Say Hi",
+        expected_output="The word: Hi",
+        agent=researcher,
+    )
+]
+
+# Instantiate your crew with custom prompts
+crew = Crew(
+    agents=[researcher],
+    tasks=tasks,
+    prompt_file="prompt.json",  # Path to your custom prompt file
+)
+
+# Get your crew to work!
+crew.kickoff()
+```
+
+## Advanced Customization Features
+
+### `language` Attribute
+
+In addition to `prompt_file`, the `language` attribute can be used to specify the language for the agent's prompts. This ensures that the prompts are generated in the desired language, further enhancing the internationalization capabilities of CrewAI.
+
+### Creating Custom Prompt Files
+
+Custom prompt files should be structured in JSON format and include all necessary prompt templates. Below is a simplified example of a prompt JSON file:
+
+```json
+{
+    "system": "You are a system template.",
+    "prompt": "Here is your prompt template.",
+    "response": "Here is your response template."
+}
+```
+
+### Benefits of Custom Prompts
+
+- **Enhanced Flexibility**: Tailor agent communication to specific project needs.
+- **Improved Usability**: Supports multiple languages, making it suitable for global projects.
+- **Consistency**: Ensures uniform prompt structures across different agents and tasks.
+
+By incorporating these updates, CrewAI provides users with the ability to fully customize and internationalize their agent prompts, making the platform more versatile and user-friendly.

docs/how-to/Customizing-Agents.md

@@ -1,55 +1,78 @@
 ---
 title: Customizing Agents in CrewAI
-description: A guide to tailoring agents for specific roles and tasks within the CrewAI framework.
+description: A comprehensive guide to tailoring agents for specific roles, tasks, and advanced customizations within the CrewAI framework.
 ---
 
 ## 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.
+Crafting an efficient CrewAI team hinges on the ability to dynamically tailor your AI agents to meet the unique requirements of any project. This section covers the foundational attributes you can customize.
 
 ### 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**: Specifies the agent's job within the crew, such as 'Analyst' or 'Customer Service Rep'.
+- **Goal**: Defines what the agent aims to achieve, in alignment with its role and the overarching objectives of the crew.
+- **Backstory**: Provides depth to the agent's persona, enriching its motivations and engagements within the crew.
+- **Tools** *(Optional)*: Represents the capabilities or methods the agent uses to perform tasks, from simple functions to intricate integrations.
+- **Cache** *(Optional)*: Determines whether the agent should use a cache for tool usage.
+- **Max RPM**: Sets the maximum number of requests per minute (`max_rpm`). This attribute is optional and can be set to `None` for no limit, allowing for unlimited queries to external services if needed.
+- **Verbose** *(Optional)*: Enables detailed logging of an agent's actions, useful for debugging and optimization. Specifically, it provides insights into agent execution processes, aiding in the optimization of performance.
+- **Allow Delegation** *(Optional)*: `allow_delegation` controls whether the agent is allowed to delegate tasks to other agents.
+- **Max Iter** *(Optional)*: The `max_iter` attribute allows users to define the maximum number of iterations an agent can perform for a single task, preventing infinite loops or excessively long executions. The default value is set to 25, providing a balance between thoroughness and efficiency. Once the agent approaches this number, it will try its best to give a good answer.
+- **Max Execution Time** *(Optional)*: `max_execution_time` Sets the maximum execution time for an agent to complete a task.
+- **System Template** *(Optional)*: `system_template` defines the system format for the agent.
+- **Prompt Template** *(Optional)*: `prompt_template` defines the prompt format for the agent.
+- **Response Template** *(Optional)*: `response_template` defines the response format for the agent.
 
-## 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.
+## Advanced Customization Options
+Beyond the basic attributes, CrewAI allows for deeper customization to enhance an agent's behavior and capabilities significantly.
+
+### Language Model Customization
+Agents can be customized with specific language models (`llm`) and function-calling language models (`function_calling_llm`), offering advanced control over their processing and decision-making abilities. It's important to note that setting the `function_calling_llm` allows for overriding the default crew function-calling language model, providing a greater degree of customization.
+
+## Performance and Debugging Settings
+Adjusting an agent's performance and monitoring its operations are crucial for efficient task execution.
+
+### Verbose Mode and RPM Limit
+- **Verbose Mode**: Enables detailed logging of an agent's actions, useful for debugging and optimization. Specifically, it provides insights into agent execution processes, aiding in the optimization of performance.
+- **RPM Limit**: Sets the maximum number of requests per minute (`max_rpm`). This attribute is optional and can be set to `None` for no limit, allowing for unlimited queries to external services if needed.
+
+### Maximum Iterations for Task Execution
+The `max_iter` attribute allows users to define the maximum number of iterations an agent can perform for a single task, preventing infinite loops or excessively long executions. The default value is set to 25, providing a balance between thoroughness and efficiency. Once the agent approaches this number, it will try its best to give a good answer.
 
 ## Customizing Agents and Tools
-Agents are customized by defining their attributes during initialization, with tools being a critical aspect of their functionality.
+Agents are customized by defining their attributes and tools during initialization. Tools are critical for an agent's functionality, enabling them to perform specialized tasks. The `tools` attribute should be an array of tools the agent can utilize, and it's initialized as an empty list by default. Tools can be added or modified post-agent initialization to adapt to new requirements.
+
+```shell
+pip install 'crewai[tools]'
+```
 
 ### Example: Assigning Tools to an Agent
 ```python
-from crewai import Agent
-from langchain.agents import Tool
-from langchain.utilities import GoogleSerperAPIWrapper
 import os
+from crewai import Agent
+from crewai_tools import SerperDevTool
 
 # Set API keys for tool initialization
 os.environ["OPENAI_API_KEY"] = "Your Key"
 os.environ["SERPER_API_KEY"] = "Your Key"
 
 # Initialize a search tool
-search_tool = GoogleSerperAPIWrapper()
+search_tool = SerperDevTool()
 
-# Define and assign the tool to an agent
-serper_tool = Tool(
-  name="Intermediate Answer",
-  func=search_tool.run,
-  description="Useful for search-based queries"
-)
-
-# Initialize the agent with the tool
+# Initialize the agent with advanced options
 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]
+  tools=[search_tool],
+  memory=True, # Enable memory
+  verbose=True,
+  max_rpm=None, # No limit on requests per minute
+  max_iter=25, # Default value for maximum iterations
+  allow_delegation=False
 )
 ```
 
 ## 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.
+Controlling an agent's ability to delegate tasks or ask questions is vital for tailoring its autonomy and collaborative dynamics within the CrewAI framework. By default, the `allow_delegation` attribute is set to `True`, enabling agents to seek assistance or delegate tasks as needed. This default behavior promotes collaborative problem-solving and efficiency within the CrewAI ecosystem. If needed, delegation can be disabled to suit specific operational requirements.
 
 ### Example: Disabling Delegation for an Agent
 ```python
@@ -57,9 +80,9 @@ agent = Agent(
   role='Content Writer',
   goal='Write engaging content on market trends',
   backstory='A seasoned writer with expertise in market analysis.',
-  allow_delegation=False
+  allow_delegation=False # Disabling delegation
 )
 ```
 
 ## Conclusion
-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.
+Customizing agents in CrewAI by setting their roles, goals, backstories, and tools, alongside advanced options like language model customization, memory, performance settings, and delegation preferences, equips a nuanced and capable AI team ready for complex challenges.

docs/how-to/Force-Tool-Ouput-as-Result.md

@@ -0,0 +1,31 @@
+---
+title: Forcing Tool Output as Result
+description: Learn how to force tool output as the result in of an Agent's task in crewAI.
+---
+
+## Introduction
+In CrewAI, you can force the output of a tool as the result of an agent's task. This feature is useful when you want to ensure that the tool output is captured and returned as the task result, and avoid the agent modifying the output during the task execution.
+
+## Forcing Tool Output as Result
+To force the tool output as the result of an agent's task, you can set the `force_tool_output` parameter to `True` when creating the task. This parameter ensures that the tool output is captured and returned as the task result, without any modifications by the agent.
+
+Here's an example of how to force the tool output as the result of an agent's task:
+
+```python
+# ...
+# Define a custom tool that returns the result as the answer
+coding_agent =Agent(
+        role="Data Scientist",
+        goal="Product amazing resports on AI",
+        backstory="You work with data and AI",
+        tools=[MyCustomTool(result_as_answer=True)],
+    )
+# ...
+```
+
+### Workflow in Action
+
+1. **Task Execution**: The agent executes the task using the tool provided.
+2. **Tool Output**: The tool generates the output, which is captured as the task result.
+3. **Agent Interaction**: The agent my reflect and take learnings from the tool but the output is not modified.
+4. **Result Return**: The tool output is returned as the task result without any modifications.

docs/how-to/Hierarchical.md

@@ -1,60 +1,68 @@
 ---
 title: Implementing the Hierarchical Process in CrewAI
-description: Understanding and applying the hierarchical process within your CrewAI projects.
+description: A comprehensive guide to understanding and applying the hierarchical process within your CrewAI projects, updated to reflect the latest coding practices and functionalities.
 ---
 
 ## Introduction
-The hierarchical process in CrewAI introduces a structured approach to task management, mimicking traditional organizational hierarchies for efficient task delegation and execution.
+The hierarchical process in CrewAI introduces a structured approach to task management, simulating traditional organizational hierarchies for efficient task delegation and execution. This systematic workflow enhances project outcomes by ensuring tasks are handled with optimal efficiency and accuracy.
 
-!!! 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.
+!!! note "Complexity and Efficiency"
+    The hierarchical process is designed to leverage advanced models like GPT-4, optimizing token usage while handling complex tasks with greater efficiency.
 
 ## 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.
+By default, tasks in CrewAI are managed through a sequential process. However, adopting a hierarchical approach allows for a clear hierarchy in task management, where a 'manager' agent coordinates the workflow, delegates tasks, and validates outcomes for streamlined and effective execution. This manager agent can now be either automatically created by CrewAI or explicitly set by the user.
 
 ### 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.
+- **Task Delegation**: A manager agent allocates tasks among crew members based on their roles and capabilities.
+- **Result Validation**: The manager evaluates outcomes to ensure they meet the required standards.
+- **Efficient Workflow**: Emulates corporate structures, providing an organized approach to task management.
 
 ## 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.
+To utilize the hierarchical process, it's essential to explicitly set the process attribute to `Process.hierarchical`, as the default behavior is `Process.sequential`. Define a crew with a designated manager and establish a clear chain of command.
 
-!!! 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 "Tools and Agent Assignment"
+    Assign tools at the agent level to facilitate task delegation and execution by the designated agents under the manager's guidance. Tools can also be specified at the task level for precise control over tool availability during task execution.
 
-!!! 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.
+!!! note "Manager LLM Requirement"
+    Configuring the `manager_llm` parameter is crucial for the hierarchical process. The system requires a manager LLM to be set up for proper function, ensuring tailored decision-making.
 
 ```python
 from langchain_openai import ChatOpenAI
 from crewai import Crew, Process, Agent
 
-# Define your agents, no need to define a manager
+# Agents are defined with attributes for backstory, cache, and verbose mode
 researcher = Agent(
-	role='Researcher',
-	goal='Conduct in-depth analysis',
-	# tools = [...]
+    role='Researcher',
+    goal='Conduct in-depth analysis',
+    backstory='Experienced data analyst with a knack for uncovering hidden trends.',
+    cache=True,
+    verbose=False,
+    # tools=[]  # This can be optionally specified; defaults to an empty list
 )
 writer = Agent(
-	role='Writer',
-	goal='Create engaging content',
-	# tools = [...]
+    role='Writer',
+    goal='Create engaging content',
+    backstory='Creative writer passionate about storytelling in technical domains.',
+    cache=True,
+    verbose=False,
+    # tools=[]  # Optionally specify tools; defaults to an empty list
 )
 
-# Form the crew with a hierarchical process
+# Establishing the crew with a hierarchical process and additional configurations
 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
+    tasks=[...],  # Tasks to be delegated and executed under the manager's supervision
+    agents=[researcher, writer],
+    manager_llm=ChatOpenAI(temperature=0, model="gpt-4"),  # Mandatory if manager_agent is not set
+    process=Process.hierarchical,  # Specifies the hierarchical management approach
+    memory=True,  # Enable memory usage for enhanced task execution
+    manager_agent=None,  # Optional: explicitly set a specific agent as manager instead of the manager_llm
 )
 ```
 
 ### 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.
+1. **Task Assignment**: The manager assigns tasks strategically, considering each agent's capabilities and available tools.
+2. **Execution and Review**: Agents complete their tasks with the option for asynchronous execution and callback functions for streamlined workflows.
+3. **Sequential Task Progression**: Despite being a hierarchical process, tasks follow a logical order for smooth progression, facilitated by the manager's oversight.
 
 ## 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.
+Adopting the hierarchical process in CrewAI, with the correct configurations and understanding of the system's capabilities, facilitates an organized and efficient approach to project management. Utilize the advanced features and customizations to tailor the workflow to your specific needs, ensuring optimal task execution and project success.

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

@@ -1,71 +1,88 @@
-# Human Input on Execution
+---
+title: Human Input on Execution
+description: Integrating CrewAI with human input during execution in complex decision-making processes and leveraging the full capabilities of the agent's attributes and tools.
+---
 
-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.
-Check [LangChain Integration](https://python.langchain.com/docs/integrations/tools/human_tools) for more details:
+# Human Input in Agent Execution
 
-Example:
+Human input is critical in several agent execution scenarios, allowing agents to request additional information or clarification when necessary. This feature is especially useful in complex decision-making processes or when agents require more details to complete a task effectively.
+
+## Using Human Input with CrewAI
+
+To integrate human input into agent execution, set the `human_input` flag in the task definition. When enabled, the agent prompts the user for input before delivering its final answer. This input can provide extra context, clarify ambiguities, or validate the agent's output.
+
+### Example:
+
+```shell
+pip install crewai
+```
 
 ```python
 import os
-from crewai import Agent, Task, Crew, Process
-from langchain_community.tools import DuckDuckGoSearchRun
-from langchain.agents import load_tools
+from crewai import Agent, Task, Crew
+from crewai_tools import SerperDevTool
 
-search_tool = DuckDuckGoSearchRun()
+os.environ["SERPER_API_KEY"] = "Your Key"  # serper.dev API key
+os.environ["OPENAI_API_KEY"] = "Your Key"
 
-# Loading Human Tools
-human_tools = load_tools(["human"])
+# Loading Tools
+search_tool = SerperDevTool()
 
-# Define your agents with roles and goals
+# Define your agents with roles, goals, tools, and additional attributes
 researcher = Agent(
-  role='Senior Research Analyst',
-  goal='Uncover cutting-edge developments in AI and data science in',
-  backstory="""You are a Senior Research Analyst at a leading tech think tank.
-  Your expertise lies in identifying emerging trends and technologies in AI and
-  data science. You have a knack for dissecting complex data and presenting
-  actionable insights.""",
-  verbose=True,
-  allow_delegation=False,
-  # Passing human tools to the agent
-  tools=[search_tool]+human_tools
+    role='Senior Research Analyst',
+    goal='Uncover cutting-edge developments in AI and data science',
+    backstory=(
+        "You are a Senior Research Analyst at a leading tech think tank. "
+        "Your expertise lies in identifying emerging trends and technologies in AI and data science. "
+        "You have a knack for dissecting complex data and presenting actionable insights."
+    ),
+    verbose=True,
+    allow_delegation=False,
+    tools=[search_tool]
 )
 writer = Agent(
-  role='Tech Content Strategist',
-  goal='Craft compelling content on tech advancements',
-  backstory="""You are a renowned Tech Content Strategist, known for your insightful
-  and engaging articles on technology and innovation. With a deep understanding of
-  the tech industry, you transform complex concepts into compelling narratives.""",
-  verbose=True,
-  allow_delegation=True
+    role='Tech Content Strategist',
+    goal='Craft compelling content on tech advancements',
+    backstory=(
+        "You are a renowned Tech Content Strategist, known for your insightful and engaging articles on technology and innovation. "
+        "With a deep understanding of the tech industry, you transform complex concepts into compelling narratives."
+    ),
+    verbose=True,
+    allow_delegation=True,
+    tools=[search_tool],
+    cache=False,  # Disable cache for this agent
 )
 
 # Create tasks for your agents
-# Being explicit on the task to ask for human feedback.
 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.
-  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
+    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. "
+        "Make sure to check with a human if the draft is good before finalizing your answer."
+    ),
+    expected_output='A comprehensive full report on the latest AI advancements in 2024, leave nothing out',
+    agent=researcher,
+    human_input=True
 )
 
 task2 = Task(
-  description="""Using the insights from the researcher's report, 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.
-  Aim for a narrative that captures the essence of these breakthroughs and their
-  implications for the future.
-  Your final answer MUST be the full blog post of at least 3 paragraphs.""",
-  agent=writer
+    description=(
+        "Using the insights from the researcher\'s report, 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. "
+        "Aim for a narrative that captures the essence of these breakthroughs and their implications for the future."
+    ),
+    expected_output='A compelling 3 paragraphs blog post formatted as markdown about the latest AI advancements in 2024',
+    agent=writer
 )
 
 # Instantiate your crew with a sequential process
 crew = Crew(
-  agents=[researcher, writer],
-  tasks=[task1, task2],
-  verbose=2
+    agents=[researcher, writer],
+    tasks=[task1, task2],
+    verbose=2,
+    memory=True,
 )
 
 # Get your crew to work!

docs/how-to/Installing-CrewAI.md

@@ -0,0 +1,21 @@
+---
+title: Installing crewAI
+description: A comprehensive guide to installing crewAI and its dependencies, including the latest updates and installation methods.
+---
+
+# Installing crewAI
+
+Welcome to crewAI! This guide will walk you through the installation process for crewAI and its dependencies. crewAI is a flexible and powerful AI framework that enables you to create and manage AI agents, tools, and tasks efficiently. Let's get started!
+
+## Installation
+
+To install crewAI, you need to have Python >=3.10 and <=3.13 installed on your system:
+
+```shell
+# Install the main crewAI package
+pip install crewai
+
+# Install the main crewAI package and the tools package
+# that includes a series of helpful tools for your agents
+pip install 'crewai[tools]'
+```

docs/how-to/Kickoff-async.md

@@ -0,0 +1,40 @@
+---
+title: Kickoff Async
+description: Kickoff a Crew Asynchronously
+---
+
+## Introduction
+CrewAI provides the ability to kickoff a crew asynchronously, allowing you to start the crew execution in a non-blocking manner. This feature is particularly useful when you want to run multiple crews concurrently or when you need to perform other tasks while the crew is executing.
+
+## Asynchronous Crew Execution
+To kickoff a crew asynchronously, use the `kickoff_async()` method. This method initiates the crew execution in a separate thread, allowing the main thread to continue executing other tasks.
+
+Here's an example of how to kickoff a crew asynchronously:
+
+```python
+from crewai import Crew, Agent, Task
+
+# Create an agent with code execution enabled
+coding_agent = Agent(
+    role="Python Data Analyst",
+    goal="Analyze data and provide insights using Python",
+    backstory="You are an experienced data analyst with strong Python skills.",
+    allow_code_execution=True
+)
+
+# Create a task that requires code execution
+data_analysis_task = Task(
+    description="Analyze the given dataset and calculate the average age of participants. Ages: {ages}",
+    agent=coding_agent
+)
+
+# Create a crew and add the task
+analysis_crew = Crew(
+    agents=[coding_agent],
+    tasks=[data_analysis_task]
+)
+
+# Execute the crew
+result = analysis_crew.kickoff_async(inputs={"ages": [25, 30, 35, 40, 45]})
+```
+

docs/how-to/Kickoff-for-each.md

@@ -0,0 +1,45 @@
+---
+title: Kickoff For Each
+description: Kickoff a Crew for a List
+---
+
+## Introduction
+CrewAI provides the ability to kickoff a crew for each item in a list, allowing you to execute the crew for each item in the list. This feature is particularly useful when you need to perform the same set of tasks for multiple items.
+
+## Kicking Off a Crew for Each Item
+To kickoff a crew for each item in a list, use the `kickoff_for_each()` method. This method executes the crew for each item in the list, allowing you to process multiple items efficiently.
+
+Here's an example of how to kickoff a crew for each item in a list:
+
+```python
+from crewai import Crew, Agent, Task
+
+# Create an agent with code execution enabled
+coding_agent = Agent(
+    role="Python Data Analyst",
+    goal="Analyze data and provide insights using Python",
+    backstory="You are an experienced data analyst with strong Python skills.",
+    allow_code_execution=True
+)
+
+# Create a task that requires code execution
+data_analysis_task = Task(
+    description="Analyze the given dataset and calculate the average age of participants. Ages: {ages}",
+    agent=coding_agent
+)
+
+# Create a crew and add the task
+analysis_crew = Crew(
+    agents=[coding_agent],
+    tasks=[data_analysis_task]
+)
+
+datasets = [
+  { "ages": [25, 30, 35, 40, 45] },
+  { "ages": [20, 25, 30, 35, 40] },
+  { "ages": [30, 35, 40, 45, 50] }
+]
+
+# Execute the crew
+result = analysis_crew.kickoff_for_each(inputs=datasets)
+```

docs/how-to/LLM-Connections.md

@@ -1,72 +1,172 @@
 ---
 title: Connect CrewAI to LLMs
-description: Guide on integrating CrewAI with various Large Language Models (LLMs).
+description: Comprehensive guide on integrating CrewAI with various Large Language Models (LLMs), including detailed class attributes, methods, and configuration options.
 ---
 
 ## 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. You can change the specific gpt model by setting the `OPENAI_MODEL_NAME` environment variable.
+    By default, CrewAI uses OpenAI's GPT-4 model (specifically, the model specified by the OPENAI_MODEL_NAME environment variable, defaulting to "gpt-4o") for language processing. You can configure your agents to use a different model or API as described in this guide.
 
 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.
 
+## CrewAI Agent Overview
 
-## 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.
+The `Agent` class is the cornerstone for implementing AI solutions in CrewAI. Here's a comprehensive overview of the Agent class attributes and methods:
 
-### Setting Up Ollama
-- **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 `Result` as a stop word and playing with parameters like `top_p` and `temperature`.
-
-### Integrating Ollama with CrewAI
-Instantiate Ollama and pass it to your agents within CrewAI, enhancing them with the local model's capabilities.
+- **Attributes**:
+    - `role`: Defines the agent's role within the solution.
+    - `goal`: Specifies the agent's objective.
+    - `backstory`: Provides a background story to the agent.
+    - `cache` *Optional*: Determines whether the agent should use a cache for tool usage. Default is `True`.
+    - `max_rpm` *Optional*: Maximum number of requests per minute the agent's execution should respect. Optional.
+    - `verbose` *Optional*: Enables detailed logging of the agent's execution. Default is `False`.
+    - `allow_delegation` *Optional*: Allows the agent to delegate tasks to other agents, default is `True`.
+    - `tools`: Specifies the tools available to the agent for task execution. Optional.
+    - `max_iter` *Optional*: Maximum number of iterations for an agent to execute a task, default is 25.
+    - `max_execution_time` *Optional*: Maximum execution time for an agent to execute a task. Optional.
+    - `step_callback` *Optional*: Provides a callback function to be executed after each step. Optional.
+    - `llm` *Optional*: Indicates the Large Language Model the agent uses. By default, it uses the GPT-4 model defined in the environment variable "OPENAI_MODEL_NAME".
+    - `function_calling_llm` *Optional* :  Will turn the ReAct CrewAI agent into a function-calling agent.
+    - `callbacks` *Optional*: A list of callback functions from the LangChain library that are triggered during the agent's execution process.
+    - `system_template` *Optional*: Optional string to define the system format for the agent.
+    - `prompt_template` *Optional*: Optional string to define the prompt format for the agent.
+    - `response_template` *Optional*: Optional string to define the response format for the agent.
 
 ```python
 # Required
-os.environ["OPENAI_API_BASE"]='http://localhost:11434/v1'
-os.environ["OPENAI_MODEL_NAME"]='openhermes'
-os.environ["OPENAI_API_KEY"]=''
+os.environ["OPENAI_MODEL_NAME"]="gpt-4-0125-preview"
 
-local_expert = Agent(
+# Agent will automatically use the model defined in the environment variable
+example_agent = Agent(
   role='Local Expert',
   goal='Provide insights about the city',
   backstory="A knowledgeable local guide.",
-  tools=[SearchTools.search_internet, BrowserTools.scrape_and_summarize_website],
   verbose=True
 )
 ```
 
+## Ollama Integration
+Ollama is preferred for local LLM integration, offering customization and privacy benefits. To integrate Ollama with CrewAI, set the appropriate environment variables as shown below.
+
+### Setting Up Ollama
+- **Environment Variables Configuration**: To integrate Ollama, set the following environment variables:
+```sh
+OPENAI_API_BASE='http://localhost:11434'
+OPENAI_MODEL_NAME='llama2'  # Adjust based on available model
+OPENAI_API_KEY=''
+```
+
+## Ollama Integration (ex. for using Llama 2 locally)
+1. [Download Ollama](https://ollama.com/download).   
+2. After setting up the Ollama, Pull the Llama2 by typing following lines into the terminal ```ollama pull llama2```.   
+3. Enjoy your free Llama2 model that powered up by excellent agents from crewai.   
+```
+from crewai import Agent, Task, Crew
+from langchain.llms import Ollama
+import os
+os.environ["OPENAI_API_KEY"] = "NA"
+
+llm = Ollama(
+    model = "llama2",
+    base_url = "http://localhost:11434")
+
+general_agent = Agent(role = "Math Professor",
+                      goal = """Provide the solution to the students that are asking mathematical questions and give them the answer.""",
+                      backstory = """You are an excellent math professor that likes to solve math questions in a way that everyone can understand your solution""",
+                      allow_delegation = False,
+                      verbose = True,
+                      llm = llm)
+
+task = Task(description="""what is 3 + 5""",
+             agent = general_agent,
+             expected_output="A numerical answer.")
+
+crew = Crew(
+            agents=[general_agent],
+            tasks=[task],
+            verbose=2
+        )
+
+result = crew.kickoff()
+
+print(result)
+```
+
+## HuggingFace Integration
+There are a couple of different ways you can use HuggingFace to host your LLM.
+
+### Your own HuggingFace endpoint
+```python
+from langchain_community.llms import HuggingFaceEndpoint
+
+llm = HuggingFaceEndpoint(
+    endpoint_url="<YOUR_ENDPOINT_URL_HERE>",
+    huggingfacehub_api_token="<HF_TOKEN_HERE>",
+    task="text-generation",
+    max_new_tokens=512
+)
+
+agent = Agent(
+    role="HuggingFace Agent",
+    goal="Generate text using HuggingFace",
+    backstory="A diligent explorer of GitHub docs.",
+    llm=llm
+)
+```
+
+### From HuggingFaceHub endpoint
+```python
+from langchain_community.llms import HuggingFaceHub
+
+llm = HuggingFaceHub(
+    repo_id="HuggingFaceH4/zephyr-7b-beta",
+    huggingfacehub_api_token="<HF_TOKEN_HERE>",
+    task="text-generation",
+)
+```
+
 ## 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.
+Switch between APIs and models seamlessly using environment variables, supporting platforms like FastChat, LM Studio, Groq, and Mistral AI.
 
 ### Configuration Examples
-
-### Ollama
+#### FastChat
 ```sh
-OPENAI_API_BASE='http://localhost:11434/v1'
-OPENAI_MODEL_NAME='openhermes'  # Depending on the model you have available
-OPENAI_API_KEY=NA
-```
-
-### FastChat
-```sh
-
 OPENAI_API_BASE="http://localhost:8001/v1"
-OPENAI_MODEL_NAME='oh-2.5m7b-q51' # Depending on the model you have available
+OPENAI_MODEL_NAME='oh-2.5m7b-q51'
 OPENAI_API_KEY=NA
 ```
 
-### LM Studio
+#### LM Studio
+Launch [LM Studio](https://lmstudio.ai) and go to the Server tab. Then select a model from the dropdown menu and wait for it to load. Once it's loaded, click the green Start Server button and use the URL, port, and API key that's shown (you can modify them). Below is an example of the default settings as of LM Studio 0.2.19:
 ```sh
-OPENAI_API_BASE="http://localhost:8000/v1"
-OPENAI_MODEL_NAME=NA
-OPENAI_API_KEY=NA
+OPENAI_API_BASE="http://localhost:1234/v1"
+OPENAI_API_KEY="lm-studio"
 ```
 
-### Mistral API
+#### Groq API
+```sh
+OPENAI_API_KEY=your-groq-api-key
+OPENAI_MODEL_NAME='llama3-8b-8192'
+OPENAI_API_BASE=https://api.groq.com/openai/v1
+```
+
+#### Mistral API
 ```sh
 OPENAI_API_KEY=your-mistral-api-key
 OPENAI_API_BASE=https://api.mistral.ai/v1
-OPENAI_MODEL_NAME="mistral-small" # Check documentation for available models
+OPENAI_MODEL_NAME="mistral-small"
+```
+
+### Solar
+```python
+from langchain_community.chat_models.solar import SolarChat
+# Initialize language model
+os.environ["SOLAR_API_KEY"] = "your-solar-api-key"
+llm = SolarChat(max_tokens=1024)
+
+# Free developer API key available here: https://console.upstage.ai/services/solar
+# Langchain Example: https://github.com/langchain-ai/langchain/pull/18556
 ```
 
 ### text-gen-web-ui
@@ -76,10 +176,19 @@ OPENAI_MODEL_NAME=NA
 OPENAI_API_KEY=NA
 ```
 
-### Azure Open AI
-Azure's OpenAI API needs a distinct setup, utilizing the `langchain_openai` component for Azure-specific configurations.
+### Cohere
+```python
+from langchain_cohere import ChatCohere
+# Initialize language model
+os.environ["COHERE_API_KEY"] = "your-cohere-api-key"
+llm = ChatCohere()
 
-Configuration settings:
+# Free developer API key available here: https://cohere.com/
+# Langchain Documentation: https://python.langchain.com/docs/integrations/chat/cohere
+```
+
+### Azure Open AI Configuration
+For Azure OpenAI API integration, set the following environment variables:
 ```sh
 AZURE_OPENAI_VERSION="2022-12-01"
 AZURE_OPENAI_DEPLOYMENT=""
@@ -87,22 +196,24 @@ AZURE_OPENAI_ENDPOINT=""
 AZURE_OPENAI_KEY=""
 ```
 
+### Example Agent with Azure LLM
 ```python
 from dotenv import load_dotenv
+from crewai import Agent
 from langchain_openai import AzureChatOpenAI
 
 load_dotenv()
 
-default_llm = AzureChatOpenAI(
+azure_llm = AzureChatOpenAI(
     azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
     api_key=os.environ.get("AZURE_OPENAI_KEY")
 )
 
-example_agent = Agent(
+azure_agent = Agent(
   role='Example Agent',
   goal='Demonstrate custom LLM configuration',
   backstory='A diligent explorer of GitHub docs.',
-  llm=default_llm
+  llm=azure_llm
 )
 ```
 

docs/how-to/Langtrace-Observability.md

@@ -0,0 +1,89 @@
+---
+title: CrewAI Agent Monitoring with Langtrace
+description: How to monitor cost, latency, and performance of CrewAI Agents using Langtrace, an external observability tool.
+---
+
+# Langtrace Overview
+
+Langtrace is an open-source, external tool that helps you set up observability and evaluations for Large Language Models (LLMs), LLM frameworks, and Vector Databases. While not built directly into CrewAI, Langtrace can be used alongside CrewAI to gain deep visibility into the cost, latency, and performance of your CrewAI Agents. This integration allows you to log hyperparameters, monitor performance regressions, and establish a process for continuous improvement of your Agents.
+
+## Setup Instructions
+
+1. Sign up for [Langtrace](https://langtrace.ai/) by visiting [https://langtrace.ai/signup](https://langtrace.ai/signup).
+2. Create a project and generate an API key.
+3. Install Langtrace in your CrewAI project using the following commands:
+
+```bash
+# Install the SDK
+pip install langtrace-python-sdk
+```
+
+## Using Langtrace with CrewAI
+
+To integrate Langtrace with your CrewAI project, follow these steps:
+
+1. Import and initialize Langtrace at the beginning of your script, before any CrewAI imports:
+
+```python
+from langtrace_python_sdk import langtrace
+langtrace.init(api_key='<LANGTRACE_API_KEY>')
+
+# Now import CrewAI modules
+from crewai import Agent, Task, Crew
+```
+
+2. Create your CrewAI agents and tasks as usual.
+
+3. Use Langtrace's tracking functions to monitor your CrewAI operations. For example:
+
+```python
+with langtrace.trace("CrewAI Task Execution"):
+    result = crew.kickoff()
+```
+
+### Features and Their Application to CrewAI
+
+1. **LLM Token and Cost Tracking**
+   - Monitor the token usage and associated costs for each CrewAI agent interaction.
+   - Example:
+     ```python
+     with langtrace.trace("Agent Interaction"):
+         agent_response = agent.execute(task)
+     ```
+
+2. **Trace Graph for Execution Steps**
+   - Visualize the execution flow of your CrewAI tasks, including latency and logs.
+   - Useful for identifying bottlenecks in your agent workflows.
+
+3. **Dataset Curation with Manual Annotation**
+   - Create datasets from your CrewAI task outputs for future training or evaluation.
+   - Example:
+     ```python
+     langtrace.log_dataset_item(task_input, agent_output, {"task_type": "research"})
+     ```
+
+4. **Prompt Versioning and Management**
+   - Keep track of different versions of prompts used in your CrewAI agents.
+   - Useful for A/B testing and optimizing agent performance.
+
+5. **Prompt Playground with Model Comparisons**
+   - Test and compare different prompts and models for your CrewAI agents before deployment.
+
+6. **Testing and Evaluations**
+   - Set up automated tests for your CrewAI agents and tasks.
+   - Example:
+     ```python
+     langtrace.evaluate(agent_output, expected_output, "accuracy")
+     ```
+
+## Monitoring New CrewAI Features
+
+CrewAI has introduced several new features that can be monitored using Langtrace:
+
+1. **Code Execution**: Monitor the performance and output of code executed by agents.
+   ```python
+   with langtrace.trace("Agent Code Execution"):
+       code_output = agent.execute_code(code_snippet)
+   ```
+
+2. **Third-party Agent Integration**: Track interactions with LlamaIndex, LangChain, and Autogen agents.

docs/how-to/Sequential.md

@@ -1,37 +1,45 @@
 ---
-title: Implementing the Sequential Process in CrewAI
-description: A guide to utilizing the sequential process for task execution in CrewAI projects.
+title: Using the Sequential Processes in crewAI
+description: A comprehensive guide to utilizing the sequential processes 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.
+CrewAI offers a flexible framework for executing tasks in a structured manner, supporting both sequential and hierarchical processes. This guide outlines how to effectively implement these processes to ensure efficient task execution and project completion.
 
 ## 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.
+The sequential process ensures tasks are executed one after the other, following a linear progression. This approach is ideal for projects requiring tasks to be completed in a specific order.
 
 ### 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.
+- **Linear Task Flow**: Ensures orderly progression by handling tasks in a predetermined sequence.
+- **Simplicity**: Best suited for projects with clear, step-by-step tasks.
+- **Easy Monitoring**: Facilitates easy tracking of task completion and 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.
+To use the sequential process, assemble your crew and define tasks in the order they need to be executed.
 
 ```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')
+researcher = Agent(
+  role='Researcher',
+  goal='Conduct foundational research',
+  backstory='An experienced researcher with a passion for uncovering insights'
+)
+analyst = Agent(
+  role='Data Analyst',
+  goal='Analyze research findings',
+  backstory='A meticulous analyst with a knack for uncovering patterns'
+)
+writer = Agent(
+  role='Writer',
+  goal='Draft the final report',
+  backstory='A skilled writer with a talent for crafting compelling narratives'
+)
 
-# 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)
+research_task = Task(description='Gather relevant data...', agent=researcher, expected_output='Raw Data')
+analysis_task = Task(description='Analyze the data...', agent=analyst, expected_output='Data Insights')
+writing_task = Task(description='Compose the report...', agent=writer, expected_output='Final Report')
 
 # Form the crew with a sequential process
 report_crew = Crew(
@@ -39,12 +47,39 @@ report_crew = Crew(
   tasks=[research_task, analysis_task, writing_task],
   process=Process.sequential
 )
+
+# Execute the crew
+result = report_crew.kickoff()
 ```
 
 ### 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.
+1. **Initial Task**: In a sequential process, the first agent completes their task and signals completion.
+2. **Subsequent Tasks**: Agents pick up their tasks based on the process type, with outcomes of preceding tasks or manager directives guiding their execution.
+3. **Completion**: The process concludes once the final task is executed, leading to project 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.
+## Advanced Features
+
+### Task Delegation
+In sequential processes, if an agent has `allow_delegation` set to `True`, they can delegate tasks to other agents in the crew. This feature is automatically set up when there are multiple agents in the crew.
+
+### Asynchronous Execution
+Tasks can be executed asynchronously, allowing for parallel processing when appropriate. To create an asynchronous task, set `async_execution=True` when defining the task.
+
+### Memory and Caching
+CrewAI supports both memory and caching features:
+- **Memory**: Enable by setting `memory=True` when creating the Crew. This allows agents to retain information across tasks.
+- **Caching**: By default, caching is enabled. Set `cache=False` to disable it.
+
+### Callbacks
+You can set callbacks at both the task and step level:
+- `task_callback`: Executed after each task completion.
+- `step_callback`: Executed after each step in an agent's execution.
+
+### Usage Metrics
+CrewAI tracks token usage across all tasks and agents. You can access these metrics after execution.
+
+## Best Practices for Sequential Processes
+1. **Order Matters**: Arrange tasks in a logical sequence where each task builds upon the previous one.
+2. **Clear Task Descriptions**: Provide detailed descriptions for each task to guide the agents effectively.
+3. **Appropriate Agent Selection**: Match agents' skills and roles to the requirements of each task.
+4. **Use Context**: Leverage the context from previous tasks to inform subsequent ones

docs/how-to/Start-a-New-CrewAI-Project.md

@@ -0,0 +1,137 @@
+---
+title: Starting a New CrewAI Project
+description: A comprehensive guide to starting a new CrewAI project, including the latest updates and project setup methods.
+---
+
+# Starting Your CrewAI Project
+
+Welcome to the ultimate guide for starting a new CrewAI project. This document will walk you through the steps to create, customize, and run your CrewAI project, ensuring you have everything you need to get started.
+
+## Prerequisites
+
+We assume you have already installed CrewAI. If not, please refer to the [installation guide](how-to/Installing-CrewAI.md) to install CrewAI and its dependencies.
+
+## Creating a New Project
+
+To create a new project, run the following CLI command:
+
+```shell
+$ crewai create my_project
+```
+
+This command will create a new project folder with the following structure:
+
+```shell
+my_project/
+├── .gitignore
+├── pyproject.toml
+├── README.md
+└── src/
+    └── my_project/
+        ├── __init__.py
+        ├── main.py
+        ├── crew.py
+        ├── tools/
+        │   ├── custom_tool.py
+        │   └── __init__.py
+        └── config/
+            ├── agents.yaml
+            └── tasks.yaml
+```
+
+You can now start developing your project by editing the files in the `src/my_project` folder. The `main.py` file is the entry point of your project, and the `crew.py` file is where you define your agents and tasks.
+
+## Customizing Your Project
+
+To customize your project, you can:
+- Modify `src/my_project/config/agents.yaml` to define your agents.
+- Modify `src/my_project/config/tasks.yaml` to define your tasks.
+- Modify `src/my_project/crew.py` to add your own logic, tools, and specific arguments.
+- Modify `src/my_project/main.py` to add custom inputs for your agents and tasks.
+- Add your environment variables into the `.env` file.
+
+### Example: Defining Agents and Tasks
+
+#### agents.yaml
+
+```yaml
+researcher:
+  role: >
+    Job Candidate Researcher
+  goal: >
+    Find potential candidates for the job
+  backstory: >
+    You are adept at finding the right candidates by exploring various online
+    resources. Your skill in identifying suitable candidates ensures the best
+    match for job positions.
+```
+
+#### tasks.yaml
+
+```yaml
+research_candidates_task:
+  description: >
+    Conduct thorough research to find potential candidates for the specified job.
+    Utilize various online resources and databases to gather a comprehensive list of potential candidates.
+    Ensure that the candidates meet the job requirements provided.
+
+    Job Requirements:
+    {job_requirements}
+  expected_output: >
+    A list of 10 potential candidates with their contact information and brief profiles highlighting their suitability.
+```
+
+## Installing Dependencies
+
+To install the dependencies for your project, you can use Poetry. First, navigate to your project directory:
+
+```shell
+$ cd my_project
+$ poetry lock
+$ poetry install
+```
+
+This will install the dependencies specified in the `pyproject.toml` file.
+
+## Interpolating Variables
+
+Any variable interpolated in your `agents.yaml` and `tasks.yaml` files like `{variable}` will be replaced by the value of the variable in the `main.py` file.
+
+#### agents.yaml
+
+```yaml
+research_task:
+  description: >
+    Conduct a thorough research about the customer and competitors in the context
+    of {customer_domain}.
+    Make sure you find any interesting and relevant information given the
+    current year is 2024.
+  expected_output: >
+    A complete report on the customer and their customers and competitors,
+    including their demographics, preferences, market positioning and audience engagement.
+```
+
+#### main.py
+
+```python
+# main.py
+def run():
+    inputs = {
+        "customer_domain": "crewai.com"
+    }
+    MyProjectCrew(inputs).crew().kickoff(inputs=inputs)
+```
+
+## Running Your Project
+
+To run your project, use the following command:
+
+```shell
+$ poetry run my_project
+```
+
+This will initialize your crew of AI agents and begin task execution as defined in your configuration in the `main.py` file.
+
+## Deploying Your Project
+
+The easiest way to deploy your crew is through [CrewAI+](https://www.crewai.com/crewaiplus), where you can deploy your crew in a few clicks.

docs/how-to/Your-Own-Manager-Agent.md

@@ -0,0 +1,87 @@
+---
+title: Setting a Specific Agent as Manager in CrewAI
+description: Learn how to set a custom agent as the manager in CrewAI, providing more control over task management and coordination.
+
+---
+
+# Setting a Specific Agent as Manager in CrewAI
+
+CrewAI allows users to set a specific agent as the manager of the crew, providing more control over the management and coordination of tasks. This feature enables the customization of the managerial role to better fit your project's requirements.
+
+## Using the `manager_agent` Attribute
+
+### Custom Manager Agent
+
+The `manager_agent` attribute allows you to define a custom agent to manage the crew. This agent will oversee the entire process, ensuring that tasks are completed efficiently and to the highest standard.
+
+### Example
+
+```python
+import os
+from crewai import Agent, Task, Crew, Process
+
+# Define your agents
+researcher = Agent(
+    role="Researcher",
+    goal="Conduct thorough research and analysis on AI and AI agents",
+    backstory="You're an expert researcher, specialized in technology, software engineering, AI, and startups. You work as a freelancer and are currently researching for a new client.",
+    allow_delegation=False,
+)
+
+writer = Agent(
+    role="Senior Writer",
+    goal="Create compelling content about AI and AI agents",
+    backstory="You're a senior writer, specialized in technology, software engineering, AI, and startups. You work as a freelancer and are currently writing content for a new client.",
+    allow_delegation=False,
+)
+
+# Define your task
+task = Task(
+    description="Generate a list of 5 interesting ideas for an article, then write one captivating paragraph for each idea that showcases the potential of a full article on this topic. Return the list of ideas with their paragraphs and your notes.",
+    expected_output="5 bullet points, each with a paragraph and accompanying notes.",
+)
+
+# Define the manager agent
+manager = Agent(
+    role="Project Manager",
+    goal="Efficiently manage the crew and ensure high-quality task completion",
+    backstory="You're an experienced project manager, skilled in overseeing complex projects and guiding teams to success. Your role is to coordinate the efforts of the crew members, ensuring that each task is completed on time and to the highest standard.",
+    allow_delegation=True,
+)
+
+# Instantiate your crew with a custom manager
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[task],
+    manager_agent=manager,
+    process=Process.hierarchical,
+)
+
+# Start the crew's work
+result = crew.kickoff()
+```
+
+## Benefits of a Custom Manager Agent
+
+- **Enhanced Control**: Tailor the management approach to fit the specific needs of your project.
+- **Improved Coordination**: Ensure efficient task coordination and management by an experienced agent.
+- **Customizable Management**: Define managerial roles and responsibilities that align with your project's goals.
+
+## Setting a Manager LLM
+
+If you're using the hierarchical process and don't want to set a custom manager agent, you can specify the language model for the manager:
+
+```python
+from langchain_openai import ChatOpenAI
+
+manager_llm = ChatOpenAI(model_name="gpt-4")
+
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[task],
+    process=Process.hierarchical,
+    manager_llm=manager_llm
+)
+```
+
+Note: Either `manager_agent` or `manager_llm` must be set when using the hierarchical process.

docs/index.md

@@ -33,18 +33,43 @@ Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By
                     Crews
                 </a>
             </li>
+            <li>
+                <a href="./core-concepts/Training-Crew">
+                    Training
+                </a>
+            </li>
+            <li>
+                <a href="./core-concepts/Memory">
+                    Memory
+                </a>
+            </li>
         </ul>
     </div>
     <div style="width:30%">
         <h2>How-To Guides</h2>
         <ul>
+            <li>
+                <a href="./how-to/Start-a-New-CrewAI-Project">
+                    Starting Your crewAI Project
+                </a>
+            </li>
+            <li>
+                <a href="./how-to/Installing-CrewAI">
+                    Installing crewAI
+                </a>
+            </li>
             <li>
                 <a href="./how-to/Creating-a-Crew-and-kick-it-off">
                     Getting Started
                 </a>
             </li>
             <li>
-                <a href="./how-to/how-to/Sequential">
+                <a href="./how-to/Create-Custom-Tools">
+                    Create Custom Tools
+                </a>
+            </li>
+            <li>
+                <a href="./how-to/Sequential">
                     Using Sequential Process
                 </a>
             </li>
@@ -63,11 +88,41 @@ Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By
                     Customizing Agents
                 </a>
             </li>
+            <li>
+                <a href="./how-to/Coding-Agents">
+                    Coding Agents
+                </a>
+            </li>
+            <li>
+                <a href="./how-to/Force-Tool-Ouput-as-Result">
+                    Forcing Tool Output as Result
+                </a>
+            </li>
             <li>
                 <a href="./how-to/Human-Input-on-Execution">
                     Human Input on Execution
                 </a>
             </li>
+            <li>
+                <a href="./how-to/Kickoff-async">
+                    Kickoff a Crew Asynchronously
+                </a>
+            </li>
+            <li>
+                <a href="./how-to/Kickoff-for-each">
+                    Kickoff a Crew for a List
+                </a>
+            </li>
+            <li>
+                <a href="./how-to/AgentOps-Observability">
+                    Agent Monitoring with AgentOps
+                </a>
+            </li>
+            <li>
+                <a href="./how-to/Langtrace-Observability">
+                    Agent Monitoring with LangTrace
+                </a>
+            </li>
         </ul>
     </div>
     <div style="width:30%">
@@ -110,4 +165,4 @@ Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By
             </li>
         </ul>
     </div>
-</div>
+</div>

docs/telemetry/Telemetry.md

@@ -1,29 +1,28 @@
+---
+title: Telemetry
+description: Understanding the telemetry data collected by CrewAI and how it contributes to the enhancement of the library.
+---
+
 ## 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.
+CrewAI utilizes anonymous telemetry to gather usage statistics with the primary goal of enhancing the library. Our focus is on improving and developing the features, integrations, and tools most utilized by our users.
 
-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.
+It's pivotal to understand that **NO data is collected** concerning prompts, task descriptions, agents' backstories or goals, usage of tools, API calls, responses, any data processed by the agents, or secrets and environment variables, with the exception of the conditions mentioned. When the `share_crew` feature is enabled, detailed data including task descriptions, agents' backstories or goals, and other specific attributes are collected to provide deeper insights while respecting user privacy.
 
-Data collected includes:
-- Version of crewAI
-  - So we can understand how many users are using the latest version
-- Version of Python
-  - So we can decide on what versions to better support
-- General OS (e.g. number of CPUs, macOS/Windows/Linux)
-  - So we know what OS we should focus on and if we could build specific OS related features
-- Number of agents and tasks in a crew
-  - So we make sure we are testing internally with similar use cases and educate people on the best practices
-- Crew Process being used
-  - Understand where we should focus our efforts
-- If Agents are using memory or allowing delegation
-  - Understand if we improved the features or maybe even drop them
-- If Tasks are being executed in parallel or sequentially
-  - Understand if we should focus more on parallel execution
-- Language model being used
-  - Improved support on most used languages
-- Roles of agents in a crew
-  - Understand high level use cases so we can build better tools, integrations and examples about it
-- Tools names available
-  - Understand out of the publically available tools, which ones are being used the most so we can improve them
+### Data Collected Includes:
+- **Version of CrewAI**: Assessing the adoption rate of our latest version helps us understand user needs and guide our updates.
+- **Python Version**: Identifying the Python versions our users operate with assists in prioritizing our support efforts for these versions.
+- **General OS Information**: Details like the number of CPUs and the operating system type (macOS, Windows, Linux) enable us to focus our development on the most used operating systems and explore the potential for OS-specific features.
+- **Number of Agents and Tasks in a Crew**: Ensures our internal testing mirrors real-world scenarios, helping us guide users towards best practices.
+- **Crew Process Utilization**: Understanding how crews are utilized aids in directing our development focus.
+- **Memory and Delegation Use by Agents**: Insights into how these features are used help evaluate their effectiveness and future.
+- **Task Execution Mode**: Knowing whether tasks are executed in parallel or sequentially influences our emphasis on enhancing parallel execution capabilities.
+- **Language Model Utilization**: Supports our goal to improve support for the most popular languages among our users.
+- **Roles of Agents within a Crew**: Understanding the various roles agents play aids in crafting better tools, integrations, and examples.
+- **Tool Usage**: Identifying which tools are most frequently used allows us to prioritize improvements in those areas.
 
-Users can opt-in sharing the complete telemetry data by setting the `share_crew` attribute to `True` on their Crews.
+### Opt-In Further Telemetry Sharing
+Users can choose to share their complete telemetry data by enabling the `share_crew` attribute to `True` in their crew configurations. This opt-in approach respects user privacy and aligns with data protection standards by ensuring users have control over their data sharing preferences. Enabling `share_crew` results in the collection of detailed crew and task execution data, including `goal`, `backstory`, `context`, and `output` of tasks. This enables a deeper insight into usage patterns while respecting the user's choice to share.
+
+### Updates and Revisions
+We are committed to maintaining the accuracy and transparency of our documentation. Regular reviews and updates are performed to ensure our documentation accurately reflects the latest developments of our codebase and telemetry practices. Users are encouraged to review this section for the most current information on our data collection practices and how they contribute to the improvement of CrewAI.

docs/tools/BrowserbaseLoadTool.md

@@ -0,0 +1,38 @@
+# BrowserbaseLoadTool
+
+## Description
+
+[Browserbase](https://browserbase.com) is a developer platform to reliably run, manage, and monitor headless browsers.
+
+ Power your AI data retrievals with:
+ - [Serverless Infrastructure](https://docs.browserbase.com/under-the-hood) providing reliable browsers to extract data from complex UIs
+ - [Stealth Mode](https://docs.browserbase.com/features/stealth-mode) with included fingerprinting tactics and automatic captcha solving
+ - [Session Debugger](https://docs.browserbase.com/features/sessions) to inspect your Browser Session with networks timeline and logs
+ - [Live Debug](https://docs.browserbase.com/guides/session-debug-connection/browser-remote-control) to quickly debug your automation
+
+## Installation
+
+- Get an API key and Project ID from [browserbase.com](https://browserbase.com) and set it in environment variables (`BROWSERBASE_API_KEY`, `BROWSERBASE_PROJECT_ID`).
+- Install the [Browserbase SDK](http://github.com/browserbase/python-sdk) along with `crewai[tools]` package:
+
+```
+pip install browserbase 'crewai[tools]'
+```
+
+## Example
+
+Utilize the BrowserbaseLoadTool as follows to allow your agent to load websites:
+
+```python
+from crewai_tools import BrowserbaseLoadTool
+
+tool = BrowserbaseLoadTool()
+```
+
+## Arguments
+
+- `api_key` Optional. Browserbase API key. Default is `BROWSERBASE_API_KEY` env variable.
+- `project_id` Optional. Browserbase Project ID. Default is `BROWSERBASE_PROJECT_ID` env variable.
+- `text_content` Retrieve only text content. Default is `False`.
+- `session_id` Optional. Provide an existing Session ID.
+- `proxy` Optional. Enable/Disable Proxies."

docs/tools/CSVSearchTool.md

@@ -0,0 +1,62 @@
+# CSVSearchTool
+
+!!! note "Experimental"
+    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+
+## Description
+
+This tool is used to perform a RAG (Retrieval-Augmented Generation) search within a CSV file's content. It allows users to semantically search for queries in the content of a specified CSV file. This feature is particularly useful for extracting information from large CSV datasets where traditional search methods might be inefficient. All tools with "Search" in their name, including CSVSearchTool, are RAG tools designed for searching different sources of data.
+
+## Installation
+
+Install the crewai_tools package
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Example
+
+```python
+from crewai_tools import CSVSearchTool
+
+# Initialize the tool with a specific CSV file. This setup allows the agent to only search the given CSV file.
+tool = CSVSearchTool(csv='path/to/your/csvfile.csv')
+
+# OR
+
+# Initialize the tool without a specific CSV file. Agent  will need to provide the CSV path at runtime.
+tool = CSVSearchTool()
+```
+
+## Arguments
+
+- `csv` : The path to the CSV file you want to search. This is a mandatory argument if the tool was initialized without a specific CSV file; otherwise, it is optional.
+
+## Custom model and embeddings
+
+By default, the tool uses OpenAI for both embeddings and summarization. To customize the model, you can use a config dictionary as follows:
+
+```python
+tool = CSVSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # or google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # or openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/CodeDocsSearchTool.md

@@ -0,0 +1,65 @@
+# CodeDocsSearchTool
+
+!!! note "Experimental"
+    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+
+## Description
+
+The CodeDocsSearchTool is a powerful RAG (Retrieval-Augmented Generation) tool designed for semantic searches within code documentation. It enables users to efficiently find specific information or topics within code documentation. By providing a `docs_url` during initialization, the tool narrows down the search to that particular documentation site. Alternatively, without a specific `docs_url`, it searches across a wide array of code documentation known or discovered throughout its execution, making it versatile for various documentation search needs.
+
+## Installation
+
+To start using the CodeDocsSearchTool, first, install the crewai_tools package via pip:
+
+```
+pip install 'crewai[tools]'
+```
+
+## Example
+
+Utilize the CodeDocsSearchTool as follows to conduct searches within code documentation:
+
+```python
+from crewai_tools import CodeDocsSearchTool
+
+# To search any code documentation content if the URL is known or discovered during its execution:
+tool = CodeDocsSearchTool()
+
+# OR
+
+# To specifically focus your search on a given documentation site by providing its URL:
+tool = CodeDocsSearchTool(docs_url='https://docs.example.com/reference')
+```
+Note: Substitute 'https://docs.example.com/reference' with your target documentation URL and 'How to use search tool' with the search query relevant to your needs.
+
+## Arguments
+
+- `docs_url`: Optional. Specifies the URL of the code documentation to be searched. Providing this during the tool's initialization focuses the search on the specified documentation content.
+
+## Custom model and embeddings
+
+By default, the tool uses OpenAI for both embeddings and summarization. To customize the model, you can use a config dictionary as follows:
+
+```python
+tool = CodeDocsSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # or google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # or openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/CodeInterpreterTool.md

@@ -0,0 +1,41 @@
+# CodeInterpreterTool
+
+## Description
+This tool is used to give the Agent the ability to run code (Python3) from the code generated by the Agent itself. The code is executed in a sandboxed environment, so it is safe to run any code.
+
+It is incredible useful since it allows the Agent to generate code, run it in the same environment, get the result and use it to make decisions.
+
+## Requirements
+
+- Docker
+
+## Installation
+Install the crewai_tools package
+```shell
+pip install 'crewai[tools]'
+```
+
+## Example
+
+Remember that when using this tool, the code must be generated by the Agent itself. The code must be a Python3 code. And it will take some time for the first time to run because it needs to build the Docker image.
+
+```python
+from crewai import Agent
+from crewai_tools import CodeInterpreterTool
+
+Agent(
+    ...
+    tools=[CodeInterpreterTool()],
+)
+```
+
+We also provide a simple way to use it directly from the Agent.
+
+```python
+from crewai import Agent
+
+agent = Agent(
+    ...
+    allow_code_execution=True,
+)
+```

docs/tools/ComposioTool.md

@@ -0,0 +1,72 @@
+# ComposioTool Documentation
+
+## Description
+
+This tools is a wrapper around the composio toolset and gives your agent access to a wide variety of tools from the composio SDK.
+
+## Installation
+
+To incorporate this tool into your project, follow the installation instructions below:
+
+```shell
+pip install composio-core
+pip install 'crewai[tools]'
+```
+
+after the installation is complete, either run `composio login` or export your composio API key as `COMPOSIO_API_KEY`.
+
+## Example
+
+The following example demonstrates how to initialize the tool and execute a github action:
+
+1. Initialize toolset
+
+```python
+from composio import App
+from crewai_tools import ComposioTool
+from crewai import Agent, Task
+
+
+tools = [ComposioTool.from_action(action=Action.GITHUB_ACTIVITY_STAR_REPO_FOR_AUTHENTICATED_USER)]
+```
+
+If you don't know what action you want to use, use `from_app` and `tags` filter to get relevant actions
+
+```python
+tools = ComposioTool.from_app(App.GITHUB, tags=["important"])
+```
+
+or use `use_case` to search relevant actions
+
+```python
+tools = ComposioTool.from_app(App.GITHUB, use_case="Star a github repository")
+```
+
+2. Define agent
+
+```python
+crewai_agent = Agent(
+    role="Github Agent",
+    goal="You take action on Github using Github APIs",
+    backstory=(
+        "You are AI agent that is responsible for taking actions on Github "
+        "on users behalf. You need to take action on Github using Github APIs"
+    ),
+    verbose=True,
+    tools=tools,
+)
+```
+
+3. Execute task
+
+```python
+task = Task(
+    description="Star a repo ComposioHQ/composio on GitHub",
+    agent=crewai_agent,
+    expected_output="if the star happened",
+)
+
+task.execute()
+```
+
+* More detailed list of tools can be found [here](https://app.composio.dev)

docs/tools/DOCXSearchTool.md

@@ -0,0 +1,60 @@
+# DOCXSearchTool
+
+!!! note "Experimental"
+    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+
+## Description
+The DOCXSearchTool is a RAG tool designed for semantic searching within DOCX documents. It enables users to effectively search and extract relevant information from DOCX files using query-based searches. This tool is invaluable for data analysis, information management, and research tasks, streamlining the process of finding specific information within large document collections.
+
+## Installation
+Install the crewai_tools package by running the following command in your terminal:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Example
+The following example demonstrates initializing the DOCXSearchTool to search within any DOCX file's content or with a specific DOCX file path.
+
+```python
+from crewai_tools import DOCXSearchTool
+
+# Initialize the tool to search within any DOCX file's content
+tool = DOCXSearchTool()
+
+# OR
+
+# Initialize the tool with a specific DOCX file, so the agent can only search the content of the specified DOCX file
+tool = DOCXSearchTool(docx='path/to/your/document.docx')
+```
+
+## Arguments
+- `docx`: An optional file path to a specific DOCX document you wish to search. If not provided during initialization, the tool allows for later specification of any DOCX file's content path for searching.
+
+## Custom model and embeddings
+
+By default, the tool uses OpenAI for both embeddings and summarization. To customize the model, you can use a config dictionary as follows:
+
+```python
+tool = DOCXSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # or google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # or openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/DirectoryReadTool.md

@@ -0,0 +1,37 @@
+```markdown
+# DirectoryReadTool
+
+!!! note "Experimental"
+    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+
+## Description
+The DirectoryReadTool is a powerful utility designed to provide a comprehensive listing of directory contents. It can recursively navigate through the specified directory, offering users a detailed enumeration of all files, including those within subdirectories. This tool is crucial for tasks that require a thorough inventory of directory structures or for validating the organization of files within directories.
+
+## Installation
+To utilize the DirectoryReadTool in your project, install the `crewai_tools` package. If this package is not yet part of your environment, you can install it using pip with the command below:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+This command installs the latest version of the `crewai_tools` package, granting access to the DirectoryReadTool among other utilities.
+
+## Example
+Employing the DirectoryReadTool is straightforward. The following code snippet demonstrates how to set it up and use the tool to list the contents of a specified directory:
+
+```python
+from crewai_tools import DirectoryReadTool
+
+# Initialize the tool so the agent can read any directory's content it learns about during execution
+tool = DirectoryReadTool()
+
+# OR
+
+# Initialize the tool with a specific directory, so the agent can only read the content of the specified directory
+tool = DirectoryReadTool(directory='/path/to/your/directory')
+```
+
+## Arguments
+The DirectoryReadTool requires minimal configuration for use. The essential argument for this tool is as follows:
+
+- `directory`: **Optional**. An argument that specifies the path to the directory whose contents you wish to list. It accepts both absolute and relative paths, guiding the tool to the desired directory for content listing.

docs/tools/DirectorySearchTool.md

@@ -0,0 +1,55 @@
+# DirectorySearchTool
+
+!!! note "Experimental"
+    The DirectorySearchTool is under continuous development. Features and functionalities might evolve, and unexpected behavior may occur as we refine the tool.
+
+## Description
+The DirectorySearchTool enables semantic search within the content of specified directories, leveraging the Retrieval-Augmented Generation (RAG) methodology for efficient navigation through files. Designed for flexibility, it allows users to dynamically specify search directories at runtime or set a fixed directory during initial setup.
+
+## Installation
+To use the DirectorySearchTool, begin by installing the crewai_tools package. Execute the following command in your terminal:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Initialization and Usage
+Import the DirectorySearchTool from the `crewai_tools` package to start. You can initialize the tool without specifying a directory, enabling the setting of the search directory at runtime. Alternatively, the tool can be initialized with a predefined directory.
+
+```python
+from crewai_tools import DirectorySearchTool
+
+# For dynamic directory specification at runtime
+tool = DirectorySearchTool()
+
+# For fixed directory searches
+tool = DirectorySearchTool(directory='/path/to/directory')
+```
+
+## Arguments
+- `directory`: A string argument that specifies the search directory. This is optional during initialization but required for searches if not set initially.
+
+## Custom Model and Embeddings
+The DirectorySearchTool uses OpenAI for embeddings and summarization by default. Customization options for these settings include changing the model provider and configuration, enhancing flexibility for advanced users.
+
+```python
+tool = DirectorySearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # Options include ollama, google, anthropic, llama2, and more
+            config=dict(
+                model="llama2",
+                # Additional configurations here
+            ),
+        ),
+        embedder=dict(
+            provider="google", # or openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/EXASearchTool.md

@@ -0,0 +1,36 @@
+# EXASearchTool Documentation
+
+## Description
+
+The EXASearchTool is designed to perform a semantic search for a specified query from a text's content across the internet. It utilizes the [exa.ai](https://exa.ai/) API to fetch and display the most relevant search results based on the query provided by the user.
+
+## Installation
+
+To incorporate this tool into your project, follow the installation instructions below:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Example
+
+The following example demonstrates how to initialize the tool and execute a search with a given query:
+
+```python
+from crewai_tools import EXASearchTool
+
+# Initialize the tool for internet searching capabilities
+tool = EXASearchTool()
+```
+
+## Steps to Get Started
+
+To effectively use the EXASearchTool, follow these steps:
+
+1. **Package Installation**: Confirm that the `crewai[tools]` package is installed in your Python environment.
+2. **API Key Acquisition**: Acquire a [exa.ai](https://exa.ai/) API key by registering for a free account at [exa.ai](https://exa.ai/).
+3. **Environment Configuration**: Store your obtained API key in an environment variable named `EXA_API_KEY` to facilitate its use by the tool.
+
+## Conclusion
+
+By integrating the EXASearchTool into Python projects, users gain the ability to conduct real-time, relevant searches across the internet directly from their applications. By adhering to the setup and usage guidelines provided, incorporating this tool into projects is streamlined and straightforward.

docs/tools/FileReadTool.md

@@ -0,0 +1,32 @@
+# FileReadTool
+
+!!! note "Experimental"
+    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+
+## Description
+The FileReadTool conceptually represents a suite of functionalities within the crewai_tools package aimed at facilitating file reading and content retrieval. This suite includes tools for processing batch text files, reading runtime configuration files, and importing data for analytics. It supports a variety of text-based file formats such as `.txt`, `.csv`, `.json`, and more. Depending on the file type, the suite offers specialized functionality, such as converting JSON content into a Python dictionary for ease of use.
+
+## Installation
+To utilize the functionalities previously attributed to the FileReadTool, install the crewai_tools package:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Usage Example
+To get started with the FileReadTool:
+
+```python
+from crewai_tools import FileReadTool
+
+# Initialize the tool to read any files the agents knows or lean the path for
+file_read_tool = FileReadTool()
+
+# OR
+
+# Initialize the tool with a specific file path, so the agent can only read the content of the specified file
+file_read_tool = FileReadTool(file_path='path/to/your/file.txt')
+```
+
+## Arguments
+- `file_path`: The path to the file you want to read. It accepts both absolute and relative paths. Ensure the file exists and you have the necessary permissions to access it.

docs/tools/GitHubSearchTool.md

@@ -0,0 +1,67 @@
+# GithubSearchTool
+
+!!! note "Experimental"
+    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+
+## Description
+The GithubSearchTool is a Retrieval-Augmented Generation (RAG) tool specifically designed for conducting semantic searches within GitHub repositories. Utilizing advanced semantic search capabilities, it sifts through code, pull requests, issues, and repositories, making it an essential tool for developers, researchers, or anyone in need of precise information from GitHub.
+
+## Installation
+To use the GithubSearchTool, first ensure the crewai_tools package is installed in your Python environment:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+This command installs the necessary package to run the GithubSearchTool along with any other tools included in the crewai_tools package.
+
+## Example
+Here’s how you can use the GithubSearchTool to perform semantic searches within a GitHub repository:
+```python
+from crewai_tools import GithubSearchTool
+
+# Initialize the tool for semantic searches within a specific GitHub repository
+tool = GithubSearchTool(
+	github_repo='https://github.com/example/repo',
+	content_types=['code', 'issue'] # Options: code, repo, pr, issue
+)
+
+# OR
+
+# Initialize the tool for semantic searches within a specific GitHub repository, so the agent can search any repository if it learns about during its execution
+tool = GithubSearchTool(
+	content_types=['code', 'issue'] # Options: code, repo, pr, issue
+)
+```
+
+## Arguments
+- `github_repo` : The URL of the GitHub repository where the search will be conducted. This is a mandatory field and specifies the target repository for your search.
+- `content_types` : Specifies the types of content to include in your search. You must provide a list of content types from the following options: `code` for searching within the code, `repo` for searching within the repository's general information, `pr` for searching within pull requests, and `issue` for searching within issues. This field is mandatory and allows tailoring the search to specific content types within the GitHub repository.
+
+## Custom model and embeddings
+
+By default, the tool uses OpenAI for both embeddings and summarization. To customize the model, you can use a config dictionary as follows:
+
+```python
+tool = GithubSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # or google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # or openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/JSONSearchTool.md

@@ -0,0 +1,60 @@
+# JSONSearchTool
+
+!!! note "Experimental Status"
+    The JSONSearchTool is currently in an experimental phase. This means the tool is under active development, and users might encounter unexpected behavior or changes. We highly encourage feedback on any issues or suggestions for improvements.
+
+## Description
+The JSONSearchTool is designed to facilitate efficient and precise searches within JSON file contents. It utilizes a RAG (Retrieve and Generate) search mechanism, allowing users to specify a JSON path for targeted searches within a particular JSON file. This capability significantly improves the accuracy and relevance of search results.
+
+## Installation
+To install the JSONSearchTool, use the following pip command:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Usage Examples
+Here are updated examples on how to utilize the JSONSearchTool effectively for searching within JSON files. These examples take into account the current implementation and usage patterns identified in the codebase.
+
+```python
+from crewai.json_tools import JSONSearchTool  # Updated import path
+
+# General JSON content search
+# This approach is suitable when the JSON path is either known beforehand or can be dynamically identified.
+tool = JSONSearchTool()
+
+# Restricting search to a specific JSON file
+# Use this initialization method when you want to limit the search scope to a specific JSON file.
+tool = JSONSearchTool(json_path='./path/to/your/file.json')
+```
+
+## Arguments
+- `json_path` (str, optional): Specifies the path to the JSON file to be searched. This argument is not required if the tool is initialized for a general search. When provided, it confines the search to the specified JSON file.
+
+## Configuration Options
+The JSONSearchTool supports extensive customization through a configuration dictionary. This allows users to select different models for embeddings and summarization based on their requirements.
+
+```python
+tool = JSONSearchTool(
+    config={
+        "llm": {
+            "provider": "ollama",  # Other options include google, openai, anthropic, llama2, etc.
+            "config": {
+                "model": "llama2",
+                # Additional optional configurations can be specified here.
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            },
+        },
+        "embedder": {
+            "provider": "google", # or openai, ollama, ...
+            "config": {
+                "model": "models/embedding-001",
+                "task_type": "retrieval_document",
+                # Further customization options can be added here.
+            },
+        },
+    }
+)
+```

docs/tools/MDXSearchTool.md

@@ -0,0 +1,62 @@
+# MDXSearchTool
+
+!!! note "Experimental"
+    The MDXSearchTool is in continuous development. Features may be added or removed, and functionality could change unpredictably as we refine the tool.
+
+## Description
+The MDX Search Tool is a component of the `crewai_tools` package aimed at facilitating advanced markdown language extraction. It enables users to effectively search and extract relevant information from MD files using query-based searches. This tool is invaluable for data analysis, information management, and research tasks, streamlining the process of finding specific information within large document collections.
+
+## Installation
+Before using the MDX Search Tool, ensure the `crewai_tools` package is installed. If it is not, you can install it with the following command:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Usage Example
+To use the MDX Search Tool, you must first set up the necessary environment variables. Then, integrate the tool into your crewAI project to begin your market research. Below is a basic example of how to do this:
+
+```python
+from crewai_tools import MDXSearchTool
+
+# Initialize the tool to search any MDX content it learns about during execution
+tool = MDXSearchTool()
+
+# OR
+
+# Initialize the tool with a specific MDX file path for an exclusive search within that document
+tool = MDXSearchTool(mdx='path/to/your/document.mdx')
+```
+
+## Parameters
+- mdx: **Optional**. Specifies the MDX file path for the search. It can be provided during initialization.
+
+## Customization of Model and Embeddings
+
+The tool defaults to using OpenAI for embeddings and summarization. For customization, utilize a configuration dictionary as shown below:
+
+```python
+tool = MDXSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # Options include google, openai, anthropic, llama2, etc.
+            config=dict(
+                model="llama2",
+                # Optional parameters can be included here.
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # or openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # Optional title for the embeddings can be added here.
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/PDFSearchTool.md

@@ -0,0 +1,60 @@
+# PDFSearchTool
+
+!!! note "Experimental"
+    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+
+## Description
+The PDFSearchTool is a RAG tool designed for semantic searches within PDF content. It allows for inputting a search query and a PDF document, leveraging advanced search techniques to find relevant content efficiently. This capability makes it especially useful for extracting specific information from large PDF files quickly.
+
+## Installation
+To get started with the PDFSearchTool, first, ensure the crewai_tools package is installed with the following command:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Example
+Here's how to use the PDFSearchTool to search within a PDF document:
+
+```python
+from crewai_tools import PDFSearchTool
+
+# Initialize the tool allowing for any PDF content search if the path is provided during execution
+tool = PDFSearchTool()
+
+# OR
+
+# Initialize the tool with a specific PDF path for exclusive search within that document
+tool = PDFSearchTool(pdf='path/to/your/document.pdf')
+```
+
+## Arguments
+- `pdf`: **Optional** The PDF path for the search. Can be provided at initialization or within the `run` method's arguments. If provided at initialization, the tool confines its search to the specified document.
+
+## Custom model and embeddings
+
+By default, the tool uses OpenAI for both embeddings and summarization. To customize the model, you can use a config dictionary as follows:
+
+```python
+tool = PDFSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # or google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # or openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/PGSearchTool.md

@@ -0,0 +1,60 @@
+# PGSearchTool
+
+!!! note "Under Development"
+    The PGSearchTool is currently under development. This document outlines the intended functionality and interface. As development progresses, please be aware that some features may not be available or could change.
+
+## Description
+The PGSearchTool is envisioned as a powerful tool for facilitating semantic searches within PostgreSQL database tables. By leveraging advanced Retrieve and Generate (RAG) technology, it aims to provide an efficient means for querying database table content, specifically tailored for PostgreSQL databases. The tool's goal is to simplify the process of finding relevant data through semantic search queries, offering a valuable resource for users needing to conduct advanced queries on extensive datasets within a PostgreSQL environment.
+
+## Installation
+The `crewai_tools` package, which will include the PGSearchTool upon its release, can be installed using the following command:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+(Note: The PGSearchTool is not yet available in the current version of the `crewai_tools` package. This installation command will be updated once the tool is released.)
+
+## Example Usage
+Below is a proposed example showcasing how to use the PGSearchTool for conducting a semantic search on a table within a PostgreSQL database:
+
+```python
+from crewai_tools import PGSearchTool
+
+# Initialize the tool with the database URI and the target table name
+tool = PGSearchTool(db_uri='postgresql://user:password@localhost:5432/mydatabase', table_name='employees')
+```
+
+## Arguments
+The PGSearchTool is designed to require the following arguments for its operation:
+
+- `db_uri`: A string representing the URI of the PostgreSQL database to be queried. This argument will be mandatory and must include the necessary authentication details and the location of the database.
+- `table_name`: A string specifying the name of the table within the database on which the semantic search will be performed. This argument will also be mandatory.
+
+## Custom Model and Embeddings
+
+The tool intends to use OpenAI for both embeddings and summarization by default. Users will have the option to customize the model using a config dictionary as follows:
+
+```python
+tool = PGSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # or google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # or openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/ScrapeWebsiteTool.md

@@ -0,0 +1,31 @@
+# ScrapeWebsiteTool
+
+!!! note "Experimental"
+    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+
+## Description
+A tool designed to extract and read the content of a specified website. It is capable of handling various types of web pages by making HTTP requests and parsing the received HTML content. This tool can be particularly useful for web scraping tasks, data collection, or extracting specific information from websites.
+
+## Installation
+Install the crewai_tools package
+```shell
+pip install 'crewai[tools]'
+```
+
+## Example
+```python
+from crewai_tools import ScrapeWebsiteTool
+
+# To enable scrapping any website it finds during it's execution
+tool = ScrapeWebsiteTool()
+
+# Initialize the tool with the website URL, so the agent can only scrap the content of the specified website
+tool = ScrapeWebsiteTool(website_url='https://www.example.com')
+
+# Extract the text from the site
+text = tool.run()
+print(text)
+```
+
+## Arguments
+- `website_url` : Mandatory website URL to read the file. This is the primary input for the tool, specifying which website's content should be scraped and read.

docs/tools/SeleniumScrapingTool.md

@@ -0,0 +1,44 @@
+# SeleniumScrapingTool
+
+!!! note "Experimental"
+    This tool is currently in development. As we refine its capabilities, users may encounter unexpected behavior. Your feedback is invaluable to us for making improvements.
+
+## Description
+The SeleniumScrapingTool is crafted for high-efficiency web scraping tasks. It allows for precise extraction of content from web pages by using CSS selectors to target specific elements. Its design caters to a wide range of scraping needs, offering flexibility to work with any provided website URL.
+
+## Installation
+To get started with the SeleniumScrapingTool, install the crewai_tools package using pip:
+
+```
+pip install 'crewai[tools]'
+```
+
+## Usage Examples
+Below are some scenarios where the SeleniumScrapingTool can be utilized:
+
+```python
+from crewai_tools import SeleniumScrapingTool
+
+# Example 1: Initialize the tool without any parameters to scrape the current page it navigates to
+tool = SeleniumScrapingTool()
+
+# Example 2: Scrape the entire webpage of a given URL
+tool = SeleniumScrapingTool(website_url='https://example.com')
+
+# Example 3: Target and scrape a specific CSS element from a webpage
+tool = SeleniumScrapingTool(website_url='https://example.com', css_element='.main-content')
+
+# Example 4: Perform scraping with additional parameters for a customized experience
+tool = SeleniumScrapingTool(website_url='https://example.com', css_element='.main-content', cookie={'name': 'user', 'value': 'John Doe'}, wait_time=10)
+```
+
+## Arguments
+The following parameters can be used to customize the SeleniumScrapingTool's scraping process:
+
+- `website_url`: **Mandatory**. Specifies the URL of the website from which content is to be scraped.
+- `css_element`: **Mandatory**. The CSS selector for a specific element to target on the website. This enables focused scraping of a particular part of a webpage.
+- `cookie`: **Optional**. A dictionary that contains cookie information. Useful for simulating a logged-in session, thereby providing access to content that might be restricted to non-logged-in users.
+- `wait_time`: **Optional**. Specifies the delay (in seconds) before the content is scraped. This delay allows for the website and any dynamic content to fully load, ensuring a successful scrape.
+
+!!! attention
+    Since the SeleniumScrapingTool is under active development, the parameters and functionality may evolve over time. Users are encouraged to keep the tool updated and report any issues or suggestions for enhancements.

docs/tools/SerperDevTool.md

@@ -0,0 +1,33 @@
+# SerperDevTool Documentation
+
+!!! note "Experimental"
+    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+
+## Description
+This tool is designed to perform a semantic search for a specified query from a text's content across the internet. It utilizes the [serper.dev](https://serper.dev) API to fetch and display the most relevant search results based on the query provided by the user.
+
+## Installation
+To incorporate this tool into your project, follow the installation instructions below:
+```shell
+pip install 'crewai[tools]'
+```
+
+## Example
+The following example demonstrates how to initialize the tool and execute a search with a given query:
+
+```python
+from crewai_tools import SerperDevTool
+
+# Initialize the tool for internet searching capabilities
+tool = SerperDevTool()
+```
+
+## Steps to Get Started
+To effectively use the `SerperDevTool`, follow these steps:
+
+1. **Package Installation**: Confirm that the `crewai[tools]` package is installed in your Python environment.
+2. **API Key Acquisition**: Acquire a `serper.dev` API key by registering for a free account at `serper.dev`.
+3. **Environment Configuration**: Store your obtained API key in an environment variable named `SERPER_API_KEY` to facilitate its use by the tool.
+
+## Conclusion
+By integrating the `SerperDevTool` into Python projects, users gain the ability to conduct real-time, relevant searches across the internet directly from their applications. By adhering to the setup and usage guidelines provided, incorporating this tool into projects is streamlined and straightforward.

docs/tools/TXTSearchTool.md

@@ -0,0 +1,62 @@
+# TXTSearchTool
+
+!!! note "Experimental"
+    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+
+## Description
+This tool is used to perform a RAG (Retrieval-Augmented Generation) search within the content of a text file. It allows for semantic searching of a query within a specified text file's content, making it an invaluable resource for quickly extracting information or finding specific sections of text based on the query provided.
+
+## Installation
+To use the TXTSearchTool, you first need to install the crewai_tools package. This can be done using pip, a package manager for Python. Open your terminal or command prompt and enter the following command:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+This command will download and install the TXTSearchTool along with any necessary dependencies.
+
+## Example
+The following example demonstrates how to use the TXTSearchTool to search within a text file. This example shows both the initialization of the tool with a specific text file and the subsequent search within that file's content.
+
+```python
+from crewai_tools import TXTSearchTool
+
+# Initialize the tool to search within any text file's content the agent learns about during its execution
+tool = TXTSearchTool()
+
+# OR
+
+# Initialize the tool with a specific text file, so the agent can search within the given text file's content
+tool = TXTSearchTool(txt='path/to/text/file.txt')
+```
+
+## Arguments
+- `txt` (str): **Optional**. The path to the text file you want to search. This argument is only required if the tool was not initialized with a specific text file; otherwise, the search will be conducted within the initially provided text file.
+
+## Custom model and embeddings
+
+By default, the tool uses OpenAI for both embeddings and summarization. To customize the model, you can use a config dictionary as follows:
+
+```python
+tool = TXTSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # or google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # or openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/WebsiteSearchTool.md

@@ -0,0 +1,60 @@
+# WebsiteSearchTool
+
+!!! note "Experimental Status"
+    The WebsiteSearchTool is currently in an experimental phase. We are actively working on incorporating this tool into our suite of offerings and will update the documentation accordingly.
+
+## Description
+The WebsiteSearchTool is designed as a concept for conducting semantic searches within the content of websites. It aims to leverage advanced machine learning models like Retrieval-Augmented Generation (RAG) to navigate and extract information from specified URLs efficiently. This tool intends to offer flexibility, allowing users to perform searches across any website or focus on specific websites of interest. Please note, the current implementation details of the WebsiteSearchTool are under development, and its functionalities as described may not yet be accessible.
+
+## Installation
+To prepare your environment for when the WebsiteSearchTool becomes available, you can install the foundational package with:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+This command installs the necessary dependencies to ensure that once the tool is fully integrated, users can start using it immediately.
+
+## Example Usage
+Below are examples of how the WebsiteSearchTool could be utilized in different scenarios. Please note, these examples are illustrative and represent planned functionality:
+
+```python
+from crewai_tools import WebsiteSearchTool
+
+# Example of initiating tool that agents can use to search across any discovered websites
+tool = WebsiteSearchTool()
+
+# Example of limiting the search to the content of a specific website, so now agents can only search within that website
+tool = WebsiteSearchTool(website='https://example.com')
+```
+
+## Arguments
+- `website`: An optional argument intended to specify the website URL for focused searches. This argument is designed to enhance the tool's flexibility by allowing targeted searches when necessary.
+
+## Customization Options
+By default, the tool uses OpenAI for both embeddings and summarization. To customize the model, you can use a config dictionary as follows:
+
+
+```python
+tool = WebsiteSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # or google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # or openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/XMLSearchTool.md

@@ -0,0 +1,60 @@
+# XMLSearchTool
+
+!!! note "Experimental"
+    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+
+## Description
+The XMLSearchTool is a cutting-edge RAG tool engineered for conducting semantic searches within XML files. Ideal for users needing to parse and extract information from XML content efficiently, this tool supports inputting a search query and an optional XML file path. By specifying an XML path, users can target their search more precisely to the content of that file, thereby obtaining more relevant search outcomes.
+
+## Installation
+To start using the XMLSearchTool, you must first install the crewai_tools package. This can be easily done with the following command:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Example
+Here are two examples demonstrating how to use the XMLSearchTool. The first example shows searching within a specific XML file, while the second example illustrates initiating a search without predefining an XML path, providing flexibility in search scope.
+
+```python
+from crewai_tools import XMLSearchTool
+
+# Allow agents to search within any XML file's content as it learns about their paths during execution
+tool = XMLSearchTool()
+
+# OR
+
+# Initialize the tool with a specific XML file path for exclusive search within that document
+tool = XMLSearchTool(xml='path/to/your/xmlfile.xml')
+```
+
+## Arguments
+- `xml`: This is the path to the XML file you wish to search. It is an optional parameter during the tool's initialization but must be provided either at initialization or as part of the `run` method's arguments to execute a search.
+
+## Custom model and embeddings
+
+By default, the tool uses OpenAI for both embeddings and summarization. To customize the model, you can use a config dictionary as follows:
+
+```python
+tool = XMLSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # or google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # or openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/YoutubeChannelSearchTool.md

@@ -0,0 +1,60 @@
+# YoutubeChannelSearchTool
+
+!!! note "Experimental"
+    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+
+## Description
+This tool is designed to perform semantic searches within a specific Youtube channel's content. Leveraging the RAG (Retrieval-Augmented Generation) methodology, it provides relevant search results, making it invaluable for extracting information or finding specific content without the need to manually sift through videos. It streamlines the search process within Youtube channels, catering to researchers, content creators, and viewers seeking specific information or topics.
+
+## Installation
+To utilize the YoutubeChannelSearchTool, the `crewai_tools` package must be installed. Execute the following command in your shell to install:
+
+```shell
+pip install 'crewai[tools]'
+```
+
+## Example
+To begin using the YoutubeChannelSearchTool, follow the example below. This demonstrates initializing the tool with a specific Youtube channel handle and conducting a search within that channel's content.
+
+```python
+from crewai_tools import YoutubeChannelSearchTool
+
+# Initialize the tool to search within any Youtube channel's content the agent learns about during its execution
+tool = YoutubeChannelSearchTool()
+
+# OR
+
+# Initialize the tool with a specific Youtube channel handle to target your search
+tool = YoutubeChannelSearchTool(youtube_channel_handle='@exampleChannel')
+```
+
+## Arguments
+- `youtube_channel_handle` : A mandatory string representing the Youtube channel handle. This parameter is crucial for initializing the tool to specify the channel you want to search within. The tool is designed to only search within the content of the provided channel handle.
+
+## Custom model and embeddings
+
+By default, the tool uses OpenAI for both embeddings and summarization. To customize the model, you can use a config dictionary as follows:
+
+```python
+tool = YoutubeChannelSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # or google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # or openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/YoutubeVideoSearchTool.md

@@ -0,0 +1,64 @@
+# YoutubeVideoSearchTool
+
+!!! note "Experimental"
+    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+
+## Description
+
+This tool is part of the `crewai_tools` package and is designed to perform semantic searches within Youtube video content, utilizing Retrieval-Augmented Generation (RAG) techniques. It is one of several "Search" tools in the package that leverage RAG for different sources. The YoutubeVideoSearchTool allows for flexibility in searches; users can search across any Youtube video content without specifying a video URL, or they can target their search to a specific Youtube video by providing its URL.
+
+## Installation
+
+To utilize the YoutubeVideoSearchTool, you must first install the `crewai_tools` package. This package contains the YoutubeVideoSearchTool among other utilities designed to enhance your data analysis and processing tasks. Install the package by executing the following command in your terminal:
+
+```
+pip install 'crewai[tools]'
+```
+
+## Example
+
+To integrate the YoutubeVideoSearchTool into your Python projects, follow the example below. This demonstrates how to use the tool both for general Youtube content searches and for targeted searches within a specific video's content.
+
+```python
+from crewai_tools import YoutubeVideoSearchTool
+
+# General search across Youtube content without specifying a video URL, so the agent can search within any Youtube video content it learns about irs url during its operation
+tool = YoutubeVideoSearchTool()
+
+# Targeted search within a specific Youtube video's content
+tool = YoutubeVideoSearchTool(youtube_video_url='https://youtube.com/watch?v=example')
+```
+
+## Arguments
+
+The YoutubeVideoSearchTool accepts the following initialization arguments:
+
+- `youtube_video_url`: An optional argument at initialization but required if targeting a specific Youtube video. It specifies the Youtube video URL path you want to search within.
+
+## Custom model and embeddings
+
+By default, the tool uses OpenAI for both embeddings and summarization. To customize the model, you can use a config dictionary as follows:
+
+```python
+tool = YoutubeVideoSearchTool(
+    config=dict(
+        llm=dict(
+            provider="ollama", # or google, openai, anthropic, llama2, ...
+            config=dict(
+                model="llama2",
+                # temperature=0.5,
+                # top_p=1,
+                # stream=true,
+            ),
+        ),
+        embedder=dict(
+            provider="google", # or openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

mkdocs.yml

@@ -126,13 +126,51 @@ nav:
     - Processes: 'core-concepts/Processes.md'
     - Crews: 'core-concepts/Crews.md'
     - Collaboration: 'core-concepts/Collaboration.md'
+    - Training: 'core-concepts/Training-Crew.md'
+    - Memory: 'core-concepts/Memory.md'
+    - Using LangChain Tools: 'core-concepts/Using-LangChain-Tools.md'
+    - Using LlamaIndex Tools: 'core-concepts/Using-LlamaIndex-Tools.md'
   - How to Guides:
+    - Starting Your crewAI Project: 'how-to/Start-a-New-CrewAI-Project.md'
+    - Installing CrewAI: 'how-to/Installing-CrewAI.md'
     - Getting Started: 'how-to/Creating-a-Crew-and-kick-it-off.md'
+    - Create Custom Tools: 'how-to/Create-Custom-Tools.md'
     - Using Sequential Process: 'how-to/Sequential.md'
     - Using Hierarchical Process: 'how-to/Hierarchical.md'
+    - Create your own Manager Agent: 'how-to/Your-Own-Manager-Agent.md'
     - Connecting to any LLM: 'how-to/LLM-Connections.md'
     - Customizing Agents: 'how-to/Customizing-Agents.md'
+    - Coding Agents: 'how-to/Coding-Agents.md'
+    - Forcing Tool Output as Result: 'how-to/Force-Tool-Ouput-as-Result.md'
     - Human Input on Execution: 'how-to/Human-Input-on-Execution.md'
+    - Kickoff a Crew Asynchronously: 'how-to/Kickoff-async.md'
+    - Kickoff a Crew for a List: 'how-to/Kickoff-for-each.md'
+    - Agent Monitoring with AgentOps: 'how-to/AgentOps-Observability.md'
+    - Agent Monitoring with LangTrace: 'how-to/Langtrace-Observability.md'
+  - Tools Docs:
+    - Google Serper Search: 'tools/SerperDevTool.md'
+    - Browserbase Web Loader: 'tools/BrowserbaseLoadTool.md'
+    - Composio Tools: 'tools/ComposioTool.md'
+    - Code Interpreter: 'tools/CodeInterpreterTool.md'
+    - Scrape Website: 'tools/ScrapeWebsiteTool.md'
+    - Directory Read: 'tools/DirectoryReadTool.md'
+    - Exa Serch Web Loader: 'tools/EXASearchTool.md'
+    - File Read: 'tools/FileReadTool.md'
+    - Selenium Scraper: 'tools/SeleniumScrapingTool.md'
+    - Directory RAG Search: 'tools/DirectorySearchTool.md'
+    - PDF RAG Search: 'tools/PDFSearchTool.md'
+    - TXT RAG Search: 'tools/TXTSearchTool.md'
+    - CSV RAG Search: 'tools/CSVSearchTool.md'
+    - XML RAG Search: 'tools/XMLSearchTool.md'
+    - JSON RAG Search: 'tools/JSONSearchTool.md'
+    - Docx Rag Search: 'tools/DOCXSearchTool.md'
+    - MDX RAG Search: 'tools/MDXSearchTool.md'
+    - PG RAG Search: 'tools/PGSearchTool.md'
+    - Website RAG Search: 'tools/WebsiteSearchTool.md'
+    - Github RAG Search: 'tools/GitHubSearchTool.md'
+    - Code Docs RAG Search: 'tools/CodeDocsSearchTool.md'
+    - Youtube Video RAG Search: 'tools/YoutubeVideoSearchTool.md'
+    - Youtube Channel RAG Search: 'tools/YoutubeChannelSearchTool.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"
@@ -149,6 +187,7 @@ extra_css:
 
 plugins:
   - social
+  - search
 
 extra:
   analytics:
@@ -158,4 +197,4 @@ extra:
     - icon: fontawesome/brands/twitter
       link: https://twitter.com/joaomdmoura
     - icon: fontawesome/brands/github
-      link: https://github.com/joaomdmoura/crewAI
+      link: https://github.com/joaomdmoura/crewAI

pyproject.toml

@@ -1,58 +1,66 @@
-
 [tool.poetry]
 name = "crewai"
-version = "0.14.0rc"
+version = "0.36.0"
 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 <joao@crewai.com>"]
 readme = "README.md"
-packages = [
-    { include = "crewai", from = "src" },
-]
-
+packages = [{ include = "crewai", from = "src" }]
 
 [tool.poetry.urls]
-Homepage = "https://crewai.io"
+Homepage = "https://crewai.com"
 Documentation = "https://github.com/joaomdmoura/CrewAI/wiki/Index"
 Repository = "https://github.com/joaomdmoura/crewai"
 
 [tool.poetry.dependencies]
-python = ">=3.10,<3.12"
+python = ">=3.10,<=3.13"
 pydantic = "^2.4.2"
-langchain = "^0.1.0"
-openai = "^1.7.1"
-langchain-openai = "^0.0.5"
+langchain = ">0.2,<=0.3"
+openai = "^1.13.3"
 opentelemetry-api = "^1.22.0"
 opentelemetry-sdk = "^1.22.0"
 opentelemetry-exporter-otlp-proto-http = "^1.22.0"
-instructor = "^0.5.2"
+instructor = "1.3.3"
 regex = "^2023.12.25"
-crewai-tools = "^0.0.3"
+crewai-tools = { version = "^0.4.8", optional = true }
+click = "^8.1.7"
+python-dotenv = "^1.0.0"
+appdirs = "^1.4.4"
+jsonref = "^1.1.0"
+agentops = { version = "^0.1.9", optional = true }
+embedchain = "^0.1.114"
+json-repair = "^0.25.2"
+
+[tool.poetry.extras]
+tools = ["crewai-tools"]
+agentops = ["agentops"]
 
 [tool.poetry.group.dev.dependencies]
 isort = "^5.13.2"
-pyright = ">=1.1.350,<2.0.0"
-black = {git = "https://github.com/psf/black.git", rev = "stable"}
+mypy = "1.10.0"
 autoflake = "^2.2.1"
 pre-commit = "^3.6.0"
 mkdocs = "^1.4.3"
 mkdocstrings = "^0.22.0"
 mkdocstrings-python = "^1.1.2"
-mkdocs-material = {extras = ["imaging"], version = "^9.5.7"}
+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"
-known_first_party = ["crewai"]
-
-
+crewai-tools = "^0.4.8"
 
 [tool.poetry.group.test.dependencies]
 pytest = "^8.0.0"
 pytest-vcr = "^1.0.2"
 python-dotenv = "1.0.0"
 
+[tool.poetry.scripts]
+crewai = "crewai.cli.cli:crewai"
+
+[tool.mypy]
+ignore_missing_imports = true
+disable_error_code = 'import-untyped'
+exclude = ["cli/templates/main.py", "cli/templates/crew.py"]
+
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"

src/crewai/__init__.py

@@ -2,3 +2,5 @@ from crewai.agent import Agent
 from crewai.crew import Crew
 from crewai.process import Process
 from crewai.task import Task
+
+__all__ = ["Agent", "Crew", "Process", "Task"]

src/crewai/agent.py

@@ -1,31 +1,39 @@
 import os
-import uuid
+from inspect import signature
 from typing import Any, List, Optional, Tuple
 
-from crewai_tools import BaseTool as CrewAITool
 from langchain.agents.agent import RunnableAgent
+from langchain.agents.tools import BaseTool
 from langchain.agents.tools import tool as LangChainTool
-from langchain.memory import ConversationSummaryMemory
-from langchain.tools.render import render_text_description
 from langchain_core.agents import AgentAction
+from langchain_core.callbacks import BaseCallbackHandler
 from langchain_openai import ChatOpenAI
-from pydantic import (
-    UUID4,
-    BaseModel,
-    ConfigDict,
-    Field,
-    InstanceOf,
-    PrivateAttr,
-    field_validator,
-    model_validator,
-)
-from pydantic_core import PydanticCustomError
+from pydantic import Field, InstanceOf, PrivateAttr, model_validator
 
-from crewai.agents import CacheHandler, CrewAgentExecutor, CrewAgentParser, ToolsHandler
-from crewai.utilities import I18N, Logger, Prompts, RPMController
+from crewai.agents import CacheHandler, CrewAgentExecutor, CrewAgentParser
+from crewai.agents.agent_builder.base_agent import BaseAgent
+from crewai.memory.contextual.contextual_memory import ContextualMemory
+from crewai.tools.agent_tools import AgentTools
+from crewai.utilities import Converter, Prompts
+from crewai.utilities.constants import TRAINED_AGENTS_DATA_FILE, TRAINING_DATA_FILE
+from crewai.utilities.token_counter_callback import TokenCalcHandler
+from crewai.utilities.training_handler import CrewTrainingHandler
+
+agentops = None
+try:
+    import agentops  # type: ignore # Name "agentops" already defined on line 21
+    from agentops import track_agent
+except ImportError:
+
+    def track_agent():
+        def noop(f):
+            return f
+
+        return noop
 
 
-class Agent(BaseModel):
+@track_agent()
+class Agent(BaseAgent):
     """Represents an agent in a system.
 
     Each agent has a role, a goal, a backstory, and an optional language model (llm).
@@ -36,8 +44,9 @@ class Agent(BaseModel):
             role: The role of the agent.
             goal: The objective of the agent.
             backstory: The backstory of the agent.
+            config: Dict representation of agent configuration.
             llm: The language model that will run the agent.
-            function_calling_llm: The language model that will the tool calling for this agent, it overrides the crew function_calling_llm.
+            function_calling_llm: The language model that will handle the tool calling for this agent, it overrides the crew function_calling_llm.
             max_iter: Maximum number of iterations for an agent to execute a task.
             memory: Whether the agent should have memory or not.
             max_rpm: Maximum number of requests per minute for the agent execution to be respected.
@@ -45,87 +54,88 @@ class Agent(BaseModel):
             allow_delegation: Whether the agent is allowed to delegate tasks to other agents.
             tools: Tools at agents disposal
             step_callback: Callback to be executed after each step of the agent execution.
+            callbacks: A list of callback functions from the langchain library that are triggered during the agent's execution process
+            allow_code_execution: Enable code execution for the agent.
+            max_retry_limit: Maximum number of retries for an agent to execute a task when an error occurs.
     """
 
-    __hash__ = object.__hash__  # type: ignore
-    _logger: Logger = PrivateAttr()
-    _rpm_controller: RPMController = PrivateAttr(default=None)
-    _request_within_rpm_limit: Any = PrivateAttr(default=None)
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-    id: UUID4 = Field(
-        default_factory=uuid.uuid4,
-        frozen=True,
-        description="Unique identifier for the object, not set by user.",
-    )
-    role: str = Field(description="Role of the agent")
-    goal: str = Field(description="Objective of the agent")
-    backstory: str = Field(description="Backstory of the agent")
-    max_rpm: Optional[int] = Field(
+    _times_executed: int = PrivateAttr(default=0)
+    max_execution_time: Optional[int] = Field(
         default=None,
-        description="Maximum number of requests per minute for the agent execution to be respected.",
-    )
-    memory: bool = Field(
-        default=True, description="Whether the agent should have memory or not"
-    )
-    verbose: bool = Field(
-        default=False, description="Verbose mode for the Agent Execution"
-    )
-    allow_delegation: bool = Field(
-        default=True, description="Allow delegation of tasks to agents"
-    )
-    tools: Optional[List[Any]] = Field(
-        default_factory=list, description="Tools at agents disposal"
-    )
-    max_iter: Optional[int] = Field(
-        default=15, description="Maximum iterations for an agent to execute a task"
-    )
-    agent_executor: InstanceOf[CrewAgentExecutor] = Field(
-        default=None, description="An instance of the CrewAgentExecutor class."
-    )
-    tools_handler: InstanceOf[ToolsHandler] = Field(
-        default=None, description="An instance of the ToolsHandler class."
+        description="Maximum execution time for an agent to execute a task",
     )
+    agent_ops_agent_name: str = None  # type: ignore # Incompatible types in assignment (expression has type "None", variable has type "str")
+    agent_ops_agent_id: str = None  # type: ignore # Incompatible types in assignment (expression has type "None", variable has type "str")
     cache_handler: InstanceOf[CacheHandler] = Field(
-        default=CacheHandler(), description="An instance of the CacheHandler class."
+        default=None, description="An instance of the CacheHandler class."
     )
     step_callback: Optional[Any] = Field(
         default=None,
         description="Callback to be executed after each step of the agent execution.",
     )
-    i18n: I18N = Field(default=I18N(), description="Internationalization settings.")
     llm: Any = Field(
         default_factory=lambda: ChatOpenAI(
-            model=os.environ.get("OPENAI_MODEL_NAME", "gpt-4")
+            model=os.environ.get("OPENAI_MODEL_NAME", "gpt-4o")
         ),
         description="Language model that will run the agent.",
     )
     function_calling_llm: Optional[Any] = Field(
         description="Language model that will run the agent.", default=None
     )
+    callbacks: Optional[List[InstanceOf[BaseCallbackHandler]]] = Field(
+        default=None, description="Callback to be executed"
+    )
+    system_template: Optional[str] = Field(
+        default=None, description="System format for the agent."
+    )
+    prompt_template: Optional[str] = Field(
+        default=None, description="Prompt format for the agent."
+    )
+    response_template: Optional[str] = Field(
+        default=None, description="Response format for the agent."
+    )
+    tools_results: Optional[List[Any]] = Field(
+        default=[], description="Results of the tools used by the agent."
+    )
+    allow_code_execution: Optional[bool] = Field(
+        default=False, description="Enable code execution for the agent."
+    )
+    max_retry_limit: int = Field(
+        default=2,
+        description="Maximum number of retries for an agent to execute a task when an error occurs.",
+    )
 
-    @field_validator("id", mode="before")
-    @classmethod
-    def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
-        if v:
-            raise PydanticCustomError(
-                "may_not_set_field", "This field is not to be set by the user.", {}
-            )
+    def __init__(__pydantic_self__, **data):
+        config = data.pop("config", {})
+        super().__init__(**config, **data)
+        __pydantic_self__.agent_ops_agent_name = __pydantic_self__.role
 
     @model_validator(mode="after")
-    def set_private_attrs(self):
-        """Set private attributes."""
-        self._logger = Logger(self.verbose)
-        if self.max_rpm and not self._rpm_controller:
-            self._rpm_controller = RPMController(
-                max_rpm=self.max_rpm, logger=self._logger
-            )
-        return self
+    def set_agent_executor(self) -> "Agent":
+        """Ensure agent executor and token process are set."""
+        if hasattr(self.llm, "model_name"):
+            token_handler = TokenCalcHandler(self.llm.model_name, self._token_process)
+
+            # Ensure self.llm.callbacks is a list
+            if not isinstance(self.llm.callbacks, list):
+                self.llm.callbacks = []
+
+            # Check if an instance of TokenCalcHandler already exists in the list
+            if not any(
+                isinstance(handler, TokenCalcHandler) for handler in self.llm.callbacks
+            ):
+                self.llm.callbacks.append(token_handler)
+
+            if agentops and not any(
+                isinstance(handler, agentops.LangchainCallbackHandler)
+                for handler in self.llm.callbacks
+            ):
+                agentops.stop_instrumenting()
+                self.llm.callbacks.append(agentops.LangchainCallbackHandler())
 
-    @model_validator(mode="after")
-    def check_agent_executor(self) -> "Agent":
-        """Check if the agent executor is set."""
         if not self.agent_executor:
+            if not self.cache_handler:
+                self.cache_handler = CacheHandler()
             self.set_cache_handler(self.cache_handler)
         return self
 
@@ -145,6 +155,9 @@ class Agent(BaseModel):
         Returns:
             Output of the agent
         """
+        if self.tools_handler:
+            self.tools_handler.last_used_tool = {}  # type: ignore # Incompatible types in assignment (expression has type "dict[Never, Never]", variable has type "ToolCalling")
+
         task_prompt = task.prompt()
 
         if context:
@@ -152,51 +165,79 @@ class Agent(BaseModel):
                 task=task_prompt, context=context
             )
 
-        tools = self._parse_tools(tools or self.tools)
-        self.agent_executor.tools = tools
-        self.agent_executor.task = task
-        self.agent_executor.tools_description = render_text_description(tools)
-        self.agent_executor.tools_names = self.__tools_names(tools)
+        if self.crew and self.crew.memory:
+            contextual_memory = ContextualMemory(
+                self.crew._short_term_memory,
+                self.crew._long_term_memory,
+                self.crew._entity_memory,
+            )
+            memory = contextual_memory.build_context_for_task(task, context)
+            if memory.strip() != "":
+                task_prompt += self.i18n.slice("memory").format(memory=memory)
 
-        result = self.agent_executor.invoke(
-            {
-                "input": task_prompt,
-                "tool_names": self.agent_executor.tools_names,
-                "tools": self.agent_executor.tools_description,
-            }
-        )["output"]
+        tools = tools or self.tools or []
+        parsed_tools = self._parse_tools(tools)
+        self.create_agent_executor(tools=tools)
+        self.agent_executor.tools = parsed_tools
+        self.agent_executor.task = task
+
+        self.agent_executor.tools_description = self._render_text_description_and_args(
+            parsed_tools
+        )
+        self.agent_executor.tools_names = self.__tools_names(parsed_tools)
+
+        if self.crew and self.crew._train:
+            task_prompt = self._training_handler(task_prompt=task_prompt)
+        else:
+            task_prompt = self._use_trained_data(task_prompt=task_prompt)
+
+        try:
+            result = self.agent_executor.invoke(
+                {
+                    "input": task_prompt,
+                    "tool_names": self.agent_executor.tools_names,
+                    "tools": self.agent_executor.tools_description,
+                }
+            )["output"]
+        except Exception as e:
+            self._times_executed += 1
+            if self._times_executed > self.max_retry_limit:
+                raise e
+            self.execute_task(task, context, tools)
 
         if self.max_rpm:
             self._rpm_controller.stop_rpm_counter()
 
+        # If there was any tool in self.tools_results that had result_as_answer
+        # set to True, return the results of the last tool that had
+        # result_as_answer set to True
+        for tool_result in self.tools_results:  # type: ignore # Item "None" of "list[Any] | None" has no attribute "__iter__" (not iterable)
+            if tool_result.get("result_as_answer", False):
+                result = tool_result["result"]
+
         return result
 
-    def set_cache_handler(self, cache_handler: CacheHandler) -> None:
-        """Set the cache handler for the agent.
+    def format_log_to_str(
+        self,
+        intermediate_steps: List[Tuple[AgentAction, str]],
+        observation_prefix: str = "Observation: ",
+        llm_prefix: str = "",
+    ) -> str:
+        """Construct the scratchpad that lets the agent continue its thought process."""
+        thoughts = ""
+        for action, observation in intermediate_steps:
+            thoughts += action.log
+            thoughts += f"\n{observation_prefix}{observation}\n{llm_prefix}"
+        return thoughts
 
-        Args:
-            cache_handler: An instance of the CacheHandler class.
-        """
-        self.cache_handler = cache_handler
-        self.tools_handler = ToolsHandler(cache=self.cache_handler)
-        self.create_agent_executor()
-
-    def set_rpm_controller(self, rpm_controller: RPMController) -> None:
-        """Set the rpm controller for the agent.
-
-        Args:
-            rpm_controller: An instance of the RPMController class.
-        """
-        if not self._rpm_controller:
-            self._rpm_controller = rpm_controller
-            self.create_agent_executor()
-
-    def create_agent_executor(self) -> None:
+    def create_agent_executor(self, tools=None) -> None:
         """Create an agent executor for the agent.
 
         Returns:
             An instance of the CrewAgentExecutor class.
         """
+        tools = tools or self.tools or []
+
         agent_args = {
             "input": lambda x: x["input"],
             "tools": lambda x: x["tools"],
@@ -209,31 +250,32 @@ class Agent(BaseModel):
         executor_args = {
             "llm": self.llm,
             "i18n": self.i18n,
-            "tools": self._parse_tools(self.tools),
+            "crew": self.crew,
+            "crew_agent": self,
+            "tools": self._parse_tools(tools),
             "verbose": self.verbose,
+            "original_tools": tools,
             "handle_parsing_errors": True,
             "max_iterations": self.max_iter,
+            "max_execution_time": self.max_execution_time,
             "step_callback": self.step_callback,
             "tools_handler": self.tools_handler,
             "function_calling_llm": self.function_calling_llm,
+            "callbacks": self.callbacks,
         }
 
         if self._rpm_controller:
-            executor_args[
-                "request_within_rpm_limit"
-            ] = self._rpm_controller.check_or_wait
-
-        if self.memory:
-            summary_memory = ConversationSummaryMemory(
-                llm=self.llm, input_key="input", memory_key="chat_history"
+            executor_args["request_within_rpm_limit"] = (
+                self._rpm_controller.check_or_wait
             )
-            executor_args["memory"] = summary_memory
-            agent_args["chat_history"] = lambda x: x["chat_history"]
-            prompt = Prompts(
-                i18n=self.i18n, tools=self.tools
-            ).task_execution_with_memory()
-        else:
-            prompt = Prompts(i18n=self.i18n, tools=self.tools).task_execution()
+
+        prompt = Prompts(
+            i18n=self.i18n,
+            tools=tools,
+            system_template=self.system_template,
+            prompt_template=self.prompt_template,
+            response_template=self.response_template,
+        ).task_execution()
 
         execution_prompt = prompt.partial(
             goal=self.goal,
@@ -241,35 +283,130 @@ class Agent(BaseModel):
             backstory=self.backstory,
         )
 
-        bind = self.llm.bind(stop=[self.i18n.slice("observation")])
-        inner_agent = agent_args | execution_prompt | bind | CrewAgentParser()
+        stop_words = [self.i18n.slice("observation")]
+
+        if self.response_template:
+            stop_words.append(
+                self.response_template.split("{{ .Response }}")[1].strip()
+            )
+
+        bind = self.llm.bind(stop=stop_words)
+
+        inner_agent = agent_args | execution_prompt | bind | CrewAgentParser(agent=self)
         self.agent_executor = CrewAgentExecutor(
             agent=RunnableAgent(runnable=inner_agent), **executor_args
         )
 
-    def _parse_tools(self, tools: List[Any]) -> List[LangChainTool]:
+    def get_delegation_tools(self, agents: List[BaseAgent]):
+        agent_tools = AgentTools(agents=agents)
+        tools = agent_tools.tools()
+        return tools
+
+    def get_code_execution_tools(self):
+        try:
+            from crewai_tools import CodeInterpreterTool
+
+            return [CodeInterpreterTool()]
+        except ModuleNotFoundError:
+            self._logger.log(
+                "info", "Coding tools not available. Install crewai_tools. "
+            )
+
+    def get_output_converter(self, llm, text, model, instructions):
+        return Converter(llm=llm, text=text, model=model, instructions=instructions)
+
+    def _parse_tools(self, tools: List[Any]) -> List[LangChainTool]:  # type: ignore # Function "langchain_core.tools.tool" is not valid as a type
         """Parse tools to be used for the task."""
         tools_list = []
-        for tool in tools:
-            if isinstance(tool, CrewAITool):
-                tools_list.append(tool.to_langchain())
-            else:
+        try:
+            # tentatively try to import from crewai_tools import BaseTool as CrewAITool
+            from crewai_tools import BaseTool as CrewAITool
+
+            for tool in tools:
+                if isinstance(tool, CrewAITool):
+                    tools_list.append(tool.to_langchain())
+                else:
+                    tools_list.append(tool)
+        except ModuleNotFoundError:
+            tools_list = []
+            for tool in tools:
                 tools_list.append(tool)
+
         return tools_list
 
-    def format_log_to_str(
-        self,
-        intermediate_steps: List[Tuple[AgentAction, str]],
-        observation_prefix: str = "Result: ",
-        llm_prefix: str = "",
-    ) -> str:
-        """Construct the scratchpad that lets the agent continue its thought process."""
-        thoughts = ""
-        for action, observation in intermediate_steps:
-            thoughts += action.log
-            thoughts += f"\n{observation_prefix}{observation}\n{llm_prefix}"
-        return thoughts
+    def _training_handler(self, task_prompt: str) -> str:
+        """Handle training data for the agent task prompt to improve output on Training."""
+        if data := CrewTrainingHandler(TRAINING_DATA_FILE).load():
+            agent_id = str(self.id)
+
+            if data.get(agent_id):
+                human_feedbacks = [
+                    i["human_feedback"] for i in data.get(agent_id, {}).values()
+                ]
+                task_prompt += "You MUST follow these feedbacks: \n " + "\n - ".join(
+                    human_feedbacks
+                )
+
+        return task_prompt
+
+    def _use_trained_data(self, task_prompt: str) -> str:
+        """Use trained data for the agent task prompt to improve output."""
+        if data := CrewTrainingHandler(TRAINED_AGENTS_DATA_FILE).load():
+            if trained_data_output := data.get(self.role):
+                task_prompt += "You MUST follow these feedbacks: \n " + "\n - ".join(
+                    trained_data_output["suggestions"]
+                )
+        return task_prompt
+
+    def _render_text_description(self, tools: List[BaseTool]) -> str:
+        """Render the tool name and description in plain text.
+
+        Output will be in the format of:
+
+        .. code-block:: markdown
+
+            search: This tool is used for search
+            calculator: This tool is used for math
+        """
+        description = "\n".join(
+            [
+                f"Tool name: {tool.name}\nTool description:\n{tool.description}"
+                for tool in tools
+            ]
+        )
+
+        return description
+
+    def _render_text_description_and_args(self, tools: List[BaseTool]) -> str:
+        """Render the tool name, description, and args in plain text.
+
+        Output will be in the format of:
+
+        .. code-block:: markdown
+
+            search: This tool is used for search, args: {"query": {"type": "string"}}
+            calculator: This tool is used for math, \
+    args: {"expression": {"type": "string"}}
+        """
+        tool_strings = []
+        for tool in tools:
+            args_schema = str(tool.args)
+            if hasattr(tool, "func") and tool.func:
+                sig = signature(tool.func)
+                description = (
+                    f"Tool Name: {tool.name}{sig}\nTool Description: {tool.description}"
+                )
+            else:
+                description = (
+                    f"Tool Name: {tool.name}\nTool Description: {tool.description}"
+                )
+            tool_strings.append(f"{description}\nTool Arguments: {args_schema}")
+
+        return "\n".join(tool_strings)
 
     @staticmethod
     def __tools_names(tools) -> str:
         return ", ".join([t.name for t in tools])
+
+    def __repr__(self):
+        return f"Agent(role={self.role}, goal={self.goal}, backstory={self.backstory})"

src/crewai/agents/agent_builder/base_agent.py

@@ -0,0 +1,256 @@
+import uuid
+from abc import ABC, abstractmethod
+from copy import copy as shallow_copy
+from typing import Any, Dict, List, Optional, TypeVar
+
+from pydantic import (
+    UUID4,
+    BaseModel,
+    ConfigDict,
+    Field,
+    InstanceOf,
+    PrivateAttr,
+    field_validator,
+    model_validator,
+)
+from pydantic_core import PydanticCustomError
+
+from crewai.agents.agent_builder.utilities.base_token_process import TokenProcess
+from crewai.agents.cache.cache_handler import CacheHandler
+from crewai.agents.tools_handler import ToolsHandler
+from crewai.utilities import I18N, Logger, RPMController
+
+T = TypeVar("T", bound="BaseAgent")
+
+
+class BaseAgent(ABC, BaseModel):
+    """Abstract Base Class for all third party agents compatible with CrewAI.
+
+    Attributes:
+        id (UUID4): Unique identifier for the agent.
+        role (str): Role of the agent.
+        goal (str): Objective of the agent.
+        backstory (str): Backstory of the agent.
+        cache (bool): Whether the agent should use a cache for tool usage.
+        config (Optional[Dict[str, Any]]): Configuration for the agent.
+        verbose (bool): Verbose mode for the Agent Execution.
+        max_rpm (Optional[int]): Maximum number of requests per minute for the agent execution.
+        allow_delegation (bool): Allow delegation of tasks to agents.
+        tools (Optional[List[Any]]): Tools at the agent's disposal.
+        max_iter (Optional[int]): Maximum iterations for an agent to execute a task.
+        agent_executor (InstanceOf): An instance of the CrewAgentExecutor class.
+        llm (Any): Language model that will run the agent.
+        crew (Any): Crew to which the agent belongs.
+        i18n (I18N): Internationalization settings.
+        cache_handler (InstanceOf[CacheHandler]): An instance of the CacheHandler class.
+        tools_handler (InstanceOf[ToolsHandler]): An instance of the ToolsHandler class.
+
+
+    Methods:
+        execute_task(task: Any, context: Optional[str] = None, tools: Optional[List[Any]] = None) -> str:
+            Abstract method to execute a task.
+        create_agent_executor(tools=None) -> None:
+            Abstract method to create an agent executor.
+        _parse_tools(tools: List[Any]) -> List[Any]:
+            Abstract method to parse tools.
+        get_delegation_tools(agents: List["BaseAgent"]):
+            Abstract method to set the agents task tools for handling delegation and question asking to other agents in crew.
+        get_output_converter(llm, model, instructions):
+            Abstract method to get the converter class for the agent to create json/pydantic outputs.
+        interpolate_inputs(inputs: Dict[str, Any]) -> None:
+            Interpolate inputs into the agent description and backstory.
+        set_cache_handler(cache_handler: CacheHandler) -> None:
+            Set the cache handler for the agent.
+        increment_formatting_errors() -> None:
+            Increment formatting errors.
+        copy() -> "BaseAgent":
+            Create a copy of the agent.
+        set_rpm_controller(rpm_controller: RPMController) -> None:
+            Set the rpm controller for the agent.
+        set_private_attrs() -> "BaseAgent":
+            Set private attributes.
+    """
+
+    __hash__ = object.__hash__  # type: ignore
+    _logger: Logger = PrivateAttr()
+    _rpm_controller: RPMController = PrivateAttr(default=None)
+    _request_within_rpm_limit: Any = PrivateAttr(default=None)
+    formatting_errors: int = 0
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
+    role: str = Field(description="Role of the agent")
+    goal: str = Field(description="Objective of the agent")
+    backstory: str = Field(description="Backstory of the agent")
+    cache: bool = Field(
+        default=True, description="Whether the agent should use a cache for tool usage."
+    )
+    config: Optional[Dict[str, Any]] = Field(
+        description="Configuration for the agent", default=None
+    )
+    verbose: bool = Field(
+        default=False, description="Verbose mode for the Agent Execution"
+    )
+    max_rpm: Optional[int] = Field(
+        default=None,
+        description="Maximum number of requests per minute for the agent execution to be respected.",
+    )
+    allow_delegation: bool = Field(
+        default=True, description="Allow delegation of tasks to agents"
+    )
+    tools: Optional[List[Any]] = Field(
+        default_factory=list, description="Tools at agents' disposal"
+    )
+    max_iter: Optional[int] = Field(
+        default=25, description="Maximum iterations for an agent to execute a task"
+    )
+    agent_executor: InstanceOf = Field(
+        default=None, description="An instance of the CrewAgentExecutor class."
+    )
+    llm: Any = Field(
+        default=None, description="Language model that will run the agent."
+    )
+    crew: Any = Field(default=None, description="Crew to which the agent belongs.")
+    i18n: I18N = Field(default=I18N(), description="Internationalization settings.")
+    cache_handler: InstanceOf[CacheHandler] = Field(
+        default=None, description="An instance of the CacheHandler class."
+    )
+    tools_handler: InstanceOf[ToolsHandler] = Field(
+        default=None, description="An instance of the ToolsHandler class."
+    )
+
+    _original_role: str | None = None
+    _original_goal: str | None = None
+    _original_backstory: str | None = None
+    _token_process: TokenProcess = TokenProcess()
+
+    def __init__(__pydantic_self__, **data):
+        config = data.pop("config", {})
+        super().__init__(**config, **data)
+
+    @model_validator(mode="after")
+    def set_config_attributes(self):
+        if self.config:
+            for key, value in self.config.items():
+                setattr(self, key, value)
+        return self
+
+    @field_validator("id", mode="before")
+    @classmethod
+    def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
+        if v:
+            raise PydanticCustomError(
+                "may_not_set_field", "This field is not to be set by the user.", {}
+            )
+
+    @model_validator(mode="after")
+    def set_attributes_based_on_config(self) -> "BaseAgent":
+        """Set attributes based on the agent configuration."""
+        if self.config:
+            for key, value in self.config.items():
+                setattr(self, key, value)
+        return self
+
+    @model_validator(mode="after")
+    def set_private_attrs(self):
+        """Set private attributes."""
+        self._logger = Logger(self.verbose)
+        if self.max_rpm and not self._rpm_controller:
+            self._rpm_controller = RPMController(
+                max_rpm=self.max_rpm, logger=self._logger
+            )
+        if not self._token_process:
+            self._token_process = TokenProcess()
+        return self
+
+    @abstractmethod
+    def execute_task(
+        self,
+        task: Any,
+        context: Optional[str] = None,
+        tools: Optional[List[Any]] = None,
+    ) -> str:
+        pass
+
+    @abstractmethod
+    def create_agent_executor(self, tools=None) -> None:
+        pass
+
+    @abstractmethod
+    def _parse_tools(self, tools: List[Any]) -> List[Any]:
+        pass
+
+    @abstractmethod
+    def get_delegation_tools(self, agents: List["BaseAgent"]):
+        """Set the task tools that init BaseAgenTools class."""
+        pass
+
+    @abstractmethod
+    def get_output_converter(
+        self, llm: Any, text: str, model: type[BaseModel] | None, instructions: str
+    ):
+        """Get the converter class for the agent to create json/pydantic outputs."""
+        pass
+
+    def copy(self: T) -> T:  # type: ignore # Signature of "copy" incompatible with supertype "BaseModel"
+        """Create a deep copy of the Agent."""
+        exclude = {
+            "id",
+            "_logger",
+            "_rpm_controller",
+            "_request_within_rpm_limit",
+            "_token_process",
+            "agent_executor",
+            "tools",
+            "tools_handler",
+            "cache_handler",
+            "llm",
+        }
+
+        # Copy llm and clear callbacks
+        existing_llm = shallow_copy(self.llm)
+        existing_llm.callbacks = []
+        copied_data = self.model_dump(exclude=exclude)
+        copied_data = {k: v for k, v in copied_data.items() if v is not None}
+
+        copied_agent = type(self)(**copied_data, llm=existing_llm, tools=self.tools)
+
+        return copied_agent
+
+    def interpolate_inputs(self, inputs: Dict[str, Any]) -> None:
+        """Interpolate inputs into the agent description and backstory."""
+        if self._original_role is None:
+            self._original_role = self.role
+        if self._original_goal is None:
+            self._original_goal = self.goal
+        if self._original_backstory is None:
+            self._original_backstory = self.backstory
+
+        if inputs:
+            self.role = self._original_role.format(**inputs)
+            self.goal = self._original_goal.format(**inputs)
+            self.backstory = self._original_backstory.format(**inputs)
+
+    def set_cache_handler(self, cache_handler: CacheHandler) -> None:
+        """Set the cache handler for the agent.
+
+        Args:
+            cache_handler: An instance of the CacheHandler class.
+        """
+        self.tools_handler = ToolsHandler()
+        if self.cache:
+            self.cache_handler = cache_handler
+            self.tools_handler.cache = cache_handler
+        self.create_agent_executor()
+
+    def increment_formatting_errors(self) -> None:
+        self.formatting_errors += 1
+
+    def set_rpm_controller(self, rpm_controller: RPMController) -> None:
+        """Set the rpm controller for the agent.
+
+        Args:
+            rpm_controller: An instance of the RPMController class.
+        """
+        if not self._rpm_controller:
+            self._rpm_controller = rpm_controller
+            self.create_agent_executor()

src/crewai/agents/agent_builder/base_agent_executor_mixin.py

@@ -0,0 +1,109 @@
+import time
+from typing import TYPE_CHECKING, Optional
+
+from crewai.memory.entity.entity_memory_item import EntityMemoryItem
+from crewai.memory.long_term.long_term_memory_item import LongTermMemoryItem
+from crewai.memory.short_term.short_term_memory_item import ShortTermMemoryItem
+from crewai.utilities.converter import ConverterError
+from crewai.utilities.evaluators.task_evaluator import TaskEvaluator
+from crewai.utilities import I18N
+
+
+if TYPE_CHECKING:
+    from crewai.crew import Crew
+    from crewai.task import Task
+    from crewai.agents.agent_builder.base_agent import BaseAgent
+
+
+class CrewAgentExecutorMixin:
+    crew: Optional["Crew"]
+    crew_agent: Optional["BaseAgent"]
+    task: Optional["Task"]
+    iterations: int
+    force_answer_max_iterations: int
+    have_forced_answer: bool
+    _i18n: I18N
+
+    def _should_force_answer(self) -> bool:
+        """Determine if a forced answer is required based on iteration count."""
+        return (
+            self.iterations == self.force_answer_max_iterations
+        ) and not self.have_forced_answer
+
+    def _create_short_term_memory(self, output) -> None:
+        """Create and save a short-term memory item if conditions are met."""
+        if (
+            self.crew
+            and self.crew_agent
+            and self.task
+            and "Action: Delegate work to coworker" not in output.log
+        ):
+            try:
+                memory = ShortTermMemoryItem(
+                    data=output.log,
+                    agent=self.crew_agent.role,
+                    metadata={
+                        "observation": self.task.description,
+                    },
+                )
+                if (
+                    hasattr(self.crew, "_short_term_memory")
+                    and self.crew._short_term_memory
+                ):
+                    self.crew._short_term_memory.save(memory)
+            except Exception as e:
+                print(f"Failed to add to short term memory: {e}")
+                pass
+
+    def _create_long_term_memory(self, output) -> None:
+        """Create and save long-term and entity memory items based on evaluation."""
+        if (
+            self.crew
+            and self.crew.memory
+            and self.crew._long_term_memory
+            and self.crew._entity_memory
+            and self.task
+            and self.crew_agent
+        ):
+            try:
+                ltm_agent = TaskEvaluator(self.crew_agent)
+                evaluation = ltm_agent.evaluate(self.task, output.log)
+
+                if isinstance(evaluation, ConverterError):
+                    return
+
+                long_term_memory = LongTermMemoryItem(
+                    task=self.task.description,
+                    agent=self.crew_agent.role,
+                    quality=evaluation.quality,
+                    datetime=str(time.time()),
+                    expected_output=self.task.expected_output,
+                    metadata={
+                        "suggestions": evaluation.suggestions,
+                        "quality": evaluation.quality,
+                    },
+                )
+                self.crew._long_term_memory.save(long_term_memory)
+
+                for entity in evaluation.entities:
+                    entity_memory = EntityMemoryItem(
+                        name=entity.name,
+                        type=entity.type,
+                        description=entity.description,
+                        relationships="\n".join(
+                            [f"- {r}" for r in entity.relationships]
+                        ),
+                    )
+                    self.crew._entity_memory.save(entity_memory)
+            except AttributeError as e:
+                print(f"Missing attributes for long term memory: {e}")
+                pass
+            except Exception as e:
+                print(f"Failed to add to long term memory: {e}")
+                pass
+
+    def _ask_human_input(self, final_answer: dict) -> str:
+        """Prompt human input for final decision making."""
+        return input(
+            self._i18n.slice("getting_input").format(final_answer=final_answer)
+        )

src/crewai/agents/agent_builder/utilities/base_agent_tool.py

@@ -0,0 +1,86 @@
+from abc import ABC, abstractmethod
+from typing import List, Optional, Union
+
+from pydantic import BaseModel, Field
+
+from crewai.agents.agent_builder.base_agent import BaseAgent
+from crewai.task import Task
+from crewai.utilities import I18N
+
+
+class BaseAgentTools(BaseModel, ABC):
+    """Default tools around agent delegation"""
+
+    agents: List[BaseAgent] = Field(description="List of agents in this crew.")
+    i18n: I18N = Field(default=I18N(), description="Internationalization settings.")
+
+    @abstractmethod
+    def tools(self):
+        pass
+
+    def _get_coworker(self, coworker: Optional[str], **kwargs) -> Optional[str]:
+        coworker = coworker or kwargs.get("co_worker") or kwargs.get("coworker")
+        if coworker:
+            is_list = coworker.startswith("[") and coworker.endswith("]")
+            if is_list:
+                coworker = coworker[1:-1].split(",")[0]
+
+        return coworker
+
+    def delegate_work(
+        self, task: str, context: str, coworker: Optional[str] = None, **kwargs
+    ):
+        """Useful to delegate a specific task to a coworker passing all necessary context and names."""
+        coworker = self._get_coworker(coworker, **kwargs)
+        return self._execute(coworker, task, context)
+
+    def ask_question(
+        self, question: str, context: str, coworker: Optional[str] = None, **kwargs
+    ):
+        """Useful to ask a question, opinion or take from a coworker passing all necessary context and names."""
+        coworker = self._get_coworker(coworker, **kwargs)
+        return self._execute(coworker, question, context)
+
+    def _execute(
+        self, agent_name: Union[str, None], task: str, context: Union[str, None]
+    ):
+        """Execute the command."""
+        try:
+            if agent_name is None:
+                agent_name = ""
+
+            # It is important to remove the quotes from the agent name.
+            # The reason we have to do this is because less-powerful LLM's
+            # have difficulty producing valid JSON.
+            # As a result, we end up with invalid JSON that is truncated like this:
+            # {"task": "....", "coworker": "....
+            # when it should look like this:
+            # {"task": "....", "coworker": "...."}
+            agent_name = agent_name.casefold().replace('"', "").replace("\n", "")
+
+            agent = [  # type: ignore # Incompatible types in assignment (expression has type "list[BaseAgent]", variable has type "str | None")
+                available_agent
+                for available_agent in self.agents
+                if available_agent.role.casefold().replace("\n", "") == agent_name
+            ]
+        except Exception as _:
+            return self.i18n.errors("agent_tool_unexsiting_coworker").format(
+                coworkers="\n".join(
+                    [f"- {agent.role.casefold()}" for agent in self.agents]
+                )
+            )
+
+        if not agent:
+            return self.i18n.errors("agent_tool_unexsiting_coworker").format(
+                coworkers="\n".join(
+                    [f"- {agent.role.casefold()}" for agent in self.agents]
+                )
+            )
+
+        agent = agent[0]
+        task_with_assigned_agent = Task(  # type: ignore # Incompatible types in assignment (expression has type "Task", variable has type "str")
+            description=task,
+            agent=agent,
+            expected_output="Your best answer to your coworker asking you this, accounting for the context shared.",
+        )
+        return agent.execute_task(task_with_assigned_agent, context)

src/crewai/agents/agent_builder/utilities/base_output_converter.py

@@ -0,0 +1,47 @@
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+
+class OutputConverter(BaseModel, ABC):
+    """
+    Abstract base class for converting task results into structured formats.
+
+    This class provides a framework for converting unstructured text into
+    either Pydantic models or JSON, tailored for specific agent requirements.
+    It uses a language model to interpret and structure the input text based
+    on given instructions.
+
+    Attributes:
+        text (str): The input text to be converted.
+        llm (Any): The language model used for conversion.
+        model (Any): The target model for structuring the output.
+        instructions (str): Specific instructions for the conversion process.
+        max_attempts (int): Maximum number of conversion attempts (default: 3).
+    """
+
+    text: str = Field(description="Text to be converted.")
+    llm: Any = Field(description="The language model to be used to convert the text.")
+    model: Any = Field(description="The model to be used to convert the text.")
+    instructions: str = Field(description="Conversion instructions to the LLM.")
+    max_attempts: Optional[int] = Field(
+        description="Max number of attempts to try to get the output formatted.",
+        default=3,
+    )
+
+    @abstractmethod
+    def to_pydantic(self, current_attempt=1):
+        """Convert text to pydantic."""
+        pass
+
+    @abstractmethod
+    def to_json(self, current_attempt=1):
+        """Convert text to json."""
+        pass
+
+    @property
+    @abstractmethod
+    def is_gpt(self) -> bool:
+        """Return if llm provided is of gpt from openai."""
+        pass

src/crewai/agents/agent_builder/utilities/base_token_process.py

@@ -0,0 +1,27 @@
+from typing import Any, Dict
+
+
+class TokenProcess:
+    total_tokens: int = 0
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    successful_requests: int = 0
+
+    def sum_prompt_tokens(self, tokens: int):
+        self.prompt_tokens = self.prompt_tokens + tokens
+        self.total_tokens = self.total_tokens + tokens
+
+    def sum_completion_tokens(self, tokens: int):
+        self.completion_tokens = self.completion_tokens + tokens
+        self.total_tokens = self.total_tokens + tokens
+
+    def sum_successful_requests(self, requests: int):
+        self.successful_requests = self.successful_requests + requests
+
+    def get_summary(self) -> Dict[str, Any]:
+        return {
+            "total_tokens": self.total_tokens,
+            "prompt_tokens": self.prompt_tokens,
+            "completion_tokens": self.completion_tokens,
+            "successful_requests": self.successful_requests,
+        }

src/crewai/agents/executor.py

@@ -1,3 +1,4 @@
+import threading
 import time
 from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
 
@@ -6,37 +7,39 @@ from langchain.agents.agent import ExceptionTool
 from langchain.callbacks.manager import CallbackManagerForChainRun
 from langchain_core.agents import AgentAction, AgentFinish, AgentStep
 from langchain_core.exceptions import OutputParserException
-from langchain_core.pydantic_v1 import root_validator
 from langchain_core.tools import BaseTool
 from langchain_core.utils.input import get_color_mapping
 from pydantic import InstanceOf
 
+from crewai.agents.agent_builder.base_agent_executor_mixin import CrewAgentExecutorMixin
 from crewai.agents.tools_handler import ToolsHandler
 from crewai.tools.tool_usage import ToolUsage, ToolUsageErrorException
 from crewai.utilities import I18N
+from crewai.utilities.constants import TRAINING_DATA_FILE
+from crewai.utilities.training_handler import CrewTrainingHandler
 
 
-class CrewAgentExecutor(AgentExecutor):
+class CrewAgentExecutor(AgentExecutor, CrewAgentExecutorMixin):
     _i18n: I18N = I18N()
+    should_ask_for_human_input: bool = False
     llm: Any = None
     iterations: int = 0
     task: Any = None
     tools_description: str = ""
     tools_names: str = ""
+    original_tools: List[Any] = []
+    crew_agent: Any = None
+    crew: Any = None
     function_calling_llm: Any = None
     request_within_rpm_limit: Any = None
-    tools_handler: InstanceOf[ToolsHandler] = None
+    tools_handler: Optional[InstanceOf[ToolsHandler]] = None
     max_iterations: Optional[int] = 15
-    force_answer_max_iterations: Optional[int] = None
+    have_forced_answer: bool = False
+    force_answer_max_iterations: Optional[int] = None  # type: ignore # Incompatible types in assignment (expression has type "int | None", base class "CrewAgentExecutorMixin" defined the type as "int")
     step_callback: Optional[Any] = None
-
-    @root_validator()
-    def set_force_answer_max_iterations(cls, values: Dict) -> Dict:
-        values["force_answer_max_iterations"] = values["max_iterations"] - 2
-        return values
-
-    def _should_force_answer(self) -> bool:
-        return True if self.iterations == self.force_answer_max_iterations else False
+    system_template: Optional[str] = None
+    prompt_template: Optional[str] = None
+    response_template: Optional[str] = None
 
     def _call(
         self,
@@ -48,13 +51,19 @@ class CrewAgentExecutor(AgentExecutor):
         name_to_tool_map = {tool.name: tool for tool in self.tools}
         # We construct a mapping from each tool to a color, used for logging.
         color_mapping = get_color_mapping(
-            [tool.name for tool in self.tools], excluded_colors=["green", "red"]
+            [tool.name.casefold() for tool in self.tools],
+            excluded_colors=["green", "red"],
         )
         intermediate_steps: List[Tuple[AgentAction, str]] = []
+        # Allowing human input given task setting
+        if self.task.human_input:
+            self.should_ask_for_human_input = True
+
         # Let's start tracking the number of iterations and time elapsed
         self.iterations = 0
         time_elapsed = 0.0
         start_time = time.time()
+
         # We now enter the agent loop (until it returns something).
         while self._should_continue(self.iterations, time_elapsed):
             if not self.request_within_rpm_limit or self.request_within_rpm_limit():
@@ -70,11 +79,18 @@ class CrewAgentExecutor(AgentExecutor):
                     self.step_callback(next_step_output)
 
                 if isinstance(next_step_output, AgentFinish):
+                    # Creating long term memory
+                    create_long_term_memory = threading.Thread(
+                        target=self._create_long_term_memory, args=(next_step_output,)
+                    )
+                    create_long_term_memory.start()
+
                     return self._return(
                         next_step_output, intermediate_steps, run_manager=run_manager
                     )
 
                 intermediate_steps.extend(next_step_output)
+
                 if len(next_step_output) == 1:
                     next_step_action = next_step_output[0]
                     # See if tool should return directly
@@ -83,11 +99,13 @@ class CrewAgentExecutor(AgentExecutor):
                         return self._return(
                             tool_return, intermediate_steps, run_manager=run_manager
                         )
+
                 self.iterations += 1
                 time_elapsed = time.time() - start_time
         output = self.agent.return_stopped_response(
             self.early_stopping_method, intermediate_steps, **inputs
         )
+
         return self._return(output, intermediate_steps, run_manager=run_manager)
 
     def _iter_next_step(
@@ -103,31 +121,22 @@ class CrewAgentExecutor(AgentExecutor):
         Override this to take control of how the agent makes and acts on choices.
         """
         try:
+            if self._should_force_answer():
+                error = self._i18n.errors("force_final_answer")
+                output = AgentAction("_Exception", error, error)
+                self.have_forced_answer = True
+                yield AgentStep(action=output, observation=error)
+                return
+
             intermediate_steps = self._prepare_intermediate_steps(intermediate_steps)
+
             # Call the LLM to see what to do.
-            output = self.agent.plan(
+            output = self.agent.plan(  # type: ignore #  Incompatible types in assignment (expression has type "AgentAction | AgentFinish | list[AgentAction]", variable has type "AgentAction")
                 intermediate_steps,
                 callbacks=run_manager.get_child() if run_manager else None,
                 **inputs,
             )
 
-            if self._should_force_answer():
-                if isinstance(output, AgentFinish):
-                    yield output
-                    return
-
-                if isinstance(output, AgentAction):
-                    output = output
-                else:
-                    raise ValueError(
-                        f"Unexpected output type from agent: {type(output)}"
-                    )
-
-                yield AgentStep(
-                    action=output, observation=self._i18n.errors("force_final_answer")
-                )
-                return
-
         except OutputParserException as e:
             if isinstance(self.handle_parsing_errors, bool):
                 raise_error = not self.handle_parsing_errors
@@ -140,11 +149,11 @@ class CrewAgentExecutor(AgentExecutor):
                     "again, pass `handle_parsing_errors=True` to the AgentExecutor. "
                     f"This is the error: {str(e)}"
                 )
-            text = str(e)
+            str(e)
             if isinstance(self.handle_parsing_errors, bool):
                 if e.send_to_llm:
                     observation = f"\n{str(e.observation)}"
-                    text = str(e.llm_output)
+                    str(e.llm_output)
                 else:
                     observation = ""
             elif isinstance(self.handle_parsing_errors, str):
@@ -153,22 +162,24 @@ class CrewAgentExecutor(AgentExecutor):
                 observation = f"\n{self.handle_parsing_errors(e)}"
             else:
                 raise ValueError("Got unexpected type of `handle_parsing_errors`")
-            output = AgentAction("_Exception", observation, text)
+            output = AgentAction("_Exception", observation, "")
+
             if run_manager:
                 run_manager.on_agent_action(output, color="green")
+
             tool_run_kwargs = self.agent.tool_run_logging_kwargs()
             observation = ExceptionTool().run(
                 output.tool_input,
-                verbose=self.verbose,
+                verbose=False,
                 color=None,
                 callbacks=run_manager.get_child() if run_manager else None,
                 **tool_run_kwargs,
             )
 
             if self._should_force_answer():
-                yield AgentStep(
-                    action=output, observation=self._i18n.errors("force_final_answer")
-                )
+                error = self._i18n.errors("force_final_answer")
+                output = AgentAction("_Exception", error, error)
+                yield AgentStep(action=output, observation=error)
                 return
 
             yield AgentStep(action=output, observation=observation)
@@ -176,37 +187,94 @@ class CrewAgentExecutor(AgentExecutor):
 
         # If the tool chosen is the finishing tool, then we end and return.
         if isinstance(output, AgentFinish):
-            yield output
-            return
+            if self.should_ask_for_human_input:
+                human_feedback = self._ask_human_input(output.return_values["output"])
+
+                if self.crew and self.crew._train:
+                    self._handle_crew_training_output(output, human_feedback)
+
+                # Making sure we only ask for it once, so disabling for the next thought loop
+                self.should_ask_for_human_input = False
+                action = AgentAction(
+                    tool="Human Input", tool_input=human_feedback, log=output.log
+                )
+
+                yield AgentStep(
+                    action=action,
+                    observation=self._i18n.slice("human_feedback").format(
+                        human_feedback=human_feedback
+                    ),
+                )
+                return
+
+            else:
+                if self.crew and self.crew._train:
+                    self._handle_crew_training_output(output)
+
+                yield output
+                return
+
+        self._create_short_term_memory(output)
 
         actions: List[AgentAction]
         actions = [output] if isinstance(output, AgentAction) else output
         yield from actions
+
         for agent_action in actions:
             if run_manager:
                 run_manager.on_agent_action(agent_action, color="green")
-            # Otherwise we lookup the tool
+
             tool_usage = ToolUsage(
-                tools_handler=self.tools_handler,
-                tools=self.tools,
+                tools_handler=self.tools_handler,  # type: ignore # Argument "tools_handler" to "ToolUsage" has incompatible type "ToolsHandler | None"; expected "ToolsHandler"
+                tools=self.tools,  # type: ignore # Argument "tools" to "ToolUsage" has incompatible type "Sequence[BaseTool]"; expected "list[BaseTool]"
+                original_tools=self.original_tools,
                 tools_description=self.tools_description,
                 tools_names=self.tools_names,
                 function_calling_llm=self.function_calling_llm,
-                llm=self.llm,
                 task=self.task,
+                agent=self.crew_agent,
+                action=agent_action,
             )
             tool_calling = tool_usage.parse(agent_action.log)
 
             if isinstance(tool_calling, ToolUsageErrorException):
                 observation = tool_calling.message
             else:
-                if tool_calling.tool_name.lower().strip() in [
-                    name.lower().strip() for name in name_to_tool_map
+                if tool_calling.tool_name.casefold().strip() in [
+                    name.casefold().strip() for name in name_to_tool_map
                 ]:
                     observation = tool_usage.use(tool_calling, agent_action.log)
                 else:
                     observation = self._i18n.errors("wrong_tool_name").format(
                         tool=tool_calling.tool_name,
-                        tools=", ".join([tool.name for tool in self.tools]),
+                        tools=", ".join([tool.name.casefold() for tool in self.tools]),
                     )
             yield AgentStep(action=agent_action, observation=observation)
+
+    def _handle_crew_training_output(
+        self, output: AgentFinish, human_feedback: str | None = None
+    ) -> None:
+        """Function to handle the process of the training data."""
+        agent_id = str(self.crew_agent.id)
+
+        if (
+            CrewTrainingHandler(TRAINING_DATA_FILE).load()
+            and not self.should_ask_for_human_input
+        ):
+            training_data = CrewTrainingHandler(TRAINING_DATA_FILE).load()
+            if training_data.get(agent_id):
+                training_data[agent_id][self.crew._train_iteration][
+                    "improved_output"
+                ] = output.return_values["output"]
+                CrewTrainingHandler(TRAINING_DATA_FILE).save(training_data)
+
+        if self.should_ask_for_human_input and human_feedback is not None:
+            training_data = {
+                "initial_output": output.return_values["output"],
+                "human_feedback": human_feedback,
+                "agent": agent_id,
+                "agent_role": self.crew_agent.role,
+            }
+            CrewTrainingHandler(TRAINING_DATA_FILE).append(
+                self.crew._train_iteration, agent_id, training_data
+            )

src/crewai/agents/parser.py

@@ -1,18 +1,21 @@
-from typing import Union
+import re
+from typing import Any, Union
 
+from json_repair import repair_json
 from langchain.agents.output_parsers import ReActSingleInputOutputParser
 from langchain_core.agents import AgentAction, AgentFinish
 from langchain_core.exceptions import OutputParserException
 
 from crewai.utilities import I18N
 
-TOOL_USAGE_SECTION = "Use Tool:"
 FINAL_ANSWER_ACTION = "Final Answer:"
-FINAL_ANSWER_AND_TOOL_ERROR_MESSAGE = "I tried to use a tool and give a final answer at the same time, I must choose only one."
+MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE = "I did it wrong. Invalid Format: I missed the 'Action:' after 'Thought:'. I will do right next, and don't use a tool I have already used.\n"
+MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE = "I did it wrong. Invalid Format: I missed the 'Action Input:' after 'Action:'. I will do right next, and don't use a tool I have already used.\n"
+FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE = "I did it wrong. Tried to both perform Action and give a Final Answer at the same time, I must do one or the other"
 
 
 class CrewAgentParser(ReActSingleInputOutputParser):
-    """Parses Crew-style LLM calls that have a single tool input.
+    """Parses ReAct-style LLM calls that have a single tool input.
 
     Expects output to be in one of two formats.
 
@@ -20,41 +23,99 @@ class CrewAgentParser(ReActSingleInputOutputParser):
     should be in the below format. This will result in an AgentAction
     being returned.
 
-    ```
-    Use Tool: All context for using the tool here
-    ```
+    Thought: agent thought here
+    Action: search
+    Action Input: what is the temperature in SF?
 
     If the output signals that a final answer should be given,
     should be in the below format. This will result in an AgentFinish
     being returned.
 
-    ```
+    Thought: agent thought here
     Final Answer: The temperature is 100 degrees
-    ```
     """
 
     _i18n: I18N = I18N()
+    agent: Any = None
 
     def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
         includes_answer = FINAL_ANSWER_ACTION in text
-        includes_tool = TOOL_USAGE_SECTION in text
-
-        if includes_tool:
+        regex = (
+            r"Action\s*\d*\s*:[\s]*(.*?)[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
+        )
+        action_match = re.search(regex, text, re.DOTALL)
+        if action_match:
             if includes_answer:
-                raise OutputParserException(f"{FINAL_ANSWER_AND_TOOL_ERROR_MESSAGE}")
+                raise OutputParserException(
+                    f"{FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE}: {text}"
+                )
+            action = action_match.group(1)
+            clean_action = self._clean_action(action)
 
-            return AgentAction("", "", text)
+            action_input = action_match.group(2).strip()
+
+            tool_input = action_input.strip(" ").strip('"')
+            safe_tool_input = self._safe_repair_json(tool_input)
+
+            return AgentAction(clean_action, safe_tool_input, text)
 
         elif includes_answer:
             return AgentFinish(
                 {"output": text.split(FINAL_ANSWER_ACTION)[-1].strip()}, text
             )
 
-        format = self._i18n.slice("format_without_tools")
-        error = f"{format}"
-        raise OutputParserException(
-            error,
-            observation=error,
-            llm_output=text,
-            send_to_llm=True,
-        )
+        if not re.search(r"Action\s*\d*\s*:[\s]*(.*?)", text, re.DOTALL):
+            self.agent.increment_formatting_errors()
+            raise OutputParserException(
+                f"Could not parse LLM output: `{text}`",
+                observation=f"{MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE}\n{self._i18n.slice('final_answer_format')}",
+                llm_output=text,
+                send_to_llm=True,
+            )
+        elif not re.search(
+            r"[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)", text, re.DOTALL
+        ):
+            self.agent.increment_formatting_errors()
+            raise OutputParserException(
+                f"Could not parse LLM output: `{text}`",
+                observation=MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE,
+                llm_output=text,
+                send_to_llm=True,
+            )
+        else:
+            format = self._i18n.slice("format_without_tools")
+            error = f"{format}"
+            self.agent.increment_formatting_errors()
+            raise OutputParserException(
+                error,
+                observation=error,
+                llm_output=text,
+                send_to_llm=True,
+            )
+
+    def _clean_action(self, text: str) -> str:
+        """Clean action string by removing non-essential formatting characters."""
+        return re.sub(r"^\s*\*+\s*|\s*\*+\s*$", "", text).strip()
+
+    def _safe_repair_json(self, tool_input: str) -> str:
+        UNABLE_TO_REPAIR_JSON_RESULTS = ['""', "{}"]
+
+        # Skip repair if the input starts and ends with square brackets
+        # Explanation: The JSON parser has issues handling inputs that are enclosed in square brackets ('[]').
+        # These are typically valid JSON arrays or strings that do not require repair. Attempting to repair such inputs
+        # might lead to unintended alterations, such as wrapping the entire input in additional layers or modifying
+        # the structure in a way that changes its meaning. By skipping the repair for inputs that start and end with
+        # square brackets, we preserve the integrity of these valid JSON structures and avoid unnecessary modifications.
+        if tool_input.startswith("[") and tool_input.endswith("]"):
+            return tool_input
+
+        # Before repair, handle common LLM issues:
+        # 1. Replace """ with " to avoid JSON parser errors
+
+        tool_input = tool_input.replace('"""', '"')
+
+        result = repair_json(tool_input)
+        if result in UNABLE_TO_REPAIR_JSON_RESULTS:
+            return tool_input
+
+        return str(result)

src/crewai/agents/tools_handler.py

@@ -1,25 +1,30 @@
-from typing import Any
+from typing import Any, Optional, Union
 
 from ..tools.cache_tools import CacheTools
-from ..tools.tool_calling import ToolCalling
+from ..tools.tool_calling import InstructorToolCalling, ToolCalling
 from .cache.cache_handler import CacheHandler
 
 
 class ToolsHandler:
     """Callback handler for tool usage."""
 
-    last_used_tool: ToolCalling = {}
-    cache: CacheHandler
+    last_used_tool: ToolCalling = {}  # type: ignore # BUG?: Incompatible types in assignment (expression has type "Dict[...]", variable has type "ToolCalling")
+    cache: Optional[CacheHandler]
 
-    def __init__(self, cache: CacheHandler):
+    def __init__(self, cache: Optional[CacheHandler] = None):
         """Initialize the callback handler."""
         self.cache = cache
-        self.last_used_tool = {}
+        self.last_used_tool = {}  # type: ignore # BUG?: same as above
 
-    def on_tool_use(self, calling: ToolCalling, output: str) -> Any:
+    def on_tool_use(
+        self,
+        calling: Union[ToolCalling, InstructorToolCalling],
+        output: str,
+        should_cache: bool = True,
+    ) -> Any:
         """Run when tool ends running."""
-        self.last_used_tool = calling
-        if calling.tool_name != CacheTools().name:
+        self.last_used_tool = calling  # type: ignore # BUG?: Incompatible types in assignment (expression has type "Union[ToolCalling, InstructorToolCalling]", variable has type "ToolCalling")
+        if self.cache and should_cache and calling.tool_name != CacheTools().name:
             self.cache.add(
                 tool=calling.tool_name,
                 input=calling.arguments,

src/crewai/cli/cli.py

@@ -0,0 +1,52 @@
+import click
+import pkg_resources
+
+from .create_crew import create_crew
+from .train_crew import train_crew
+
+
+@click.group()
+def crewai():
+    """Top-level command group for crewai."""
+
+
+@crewai.command()
+@click.argument("project_name")
+def create(project_name):
+    """Create a new crew."""
+    create_crew(project_name)
+
+
+@crewai.command()
+@click.option(
+    "--tools", is_flag=True, help="Show the installed version of crewai tools"
+)
+def version(tools):
+    """Show the installed version of crewai."""
+    crewai_version = pkg_resources.get_distribution("crewai").version
+    click.echo(f"crewai version: {crewai_version}")
+
+    if tools:
+        try:
+            tools_version = pkg_resources.get_distribution("crewai-tools").version
+            click.echo(f"crewai tools version: {tools_version}")
+        except pkg_resources.DistributionNotFound:
+            click.echo("crewai tools not installed")
+
+
+@crewai.command()
+@click.option(
+    "-n",
+    "--n_iterations",
+    type=int,
+    default=5,
+    help="Number of iterations to train the crew",
+)
+def train(n_iterations: int):
+    """Train the crew."""
+    click.echo(f"Training the crew for {n_iterations} iterations")
+    train_crew(n_iterations)
+
+
+if __name__ == "__main__":
+    crewai()

src/crewai/cli/create_crew.py

@@ -0,0 +1,80 @@
+import os
+from pathlib import Path
+
+import click
+
+
+def create_crew(name):
+    """Create a new crew."""
+    folder_name = name.replace(" ", "_").replace("-", "_").lower()
+    class_name = name.replace("_", " ").replace("-", " ").title().replace(" ", "")
+
+    click.secho(f"Creating folder {folder_name}...", fg="green", bold=True)
+
+    if not os.path.exists(folder_name):
+        os.mkdir(folder_name)
+        os.mkdir(folder_name + "/tests")
+        os.mkdir(folder_name + "/src")
+        os.mkdir(folder_name + f"/src/{folder_name}")
+        os.mkdir(folder_name + f"/src/{folder_name}/tools")
+        os.mkdir(folder_name + f"/src/{folder_name}/config")
+        with open(folder_name + "/.env", "w") as file:
+            file.write("OPENAI_API_KEY=YOUR_API_KEY")
+    else:
+        click.secho(
+            f"\tFolder {folder_name} already exists. Please choose a different name.",
+            fg="red",
+        )
+        return
+
+    package_dir = Path(__file__).parent
+    templates_dir = package_dir / "templates"
+
+    # List of template files to copy
+    root_template_files = [
+        ".gitignore",
+        "pyproject.toml",
+        "README.md",
+    ]
+    tools_template_files = ["tools/custom_tool.py", "tools/__init__.py"]
+    config_template_files = ["config/agents.yaml", "config/tasks.yaml"]
+    src_template_files = ["__init__.py", "main.py", "crew.py"]
+
+    for file_name in root_template_files:
+        src_file = templates_dir / file_name
+        dst_file = Path(folder_name) / file_name
+        copy_template(src_file, dst_file, name, class_name, folder_name)
+
+    for file_name in src_template_files:
+        src_file = templates_dir / file_name
+        dst_file = Path(folder_name) / "src" / folder_name / file_name
+        copy_template(src_file, dst_file, name, class_name, folder_name)
+
+    for file_name in tools_template_files:
+        src_file = templates_dir / file_name
+        dst_file = Path(folder_name) / "src" / folder_name / file_name
+        copy_template(src_file, dst_file, name, class_name, folder_name)
+
+    for file_name in config_template_files:
+        src_file = templates_dir / file_name
+        dst_file = Path(folder_name) / "src" / folder_name / file_name
+        copy_template(src_file, dst_file, name, class_name, folder_name)
+
+    click.secho(f"Crew {name} created successfully!", fg="green", bold=True)
+
+
+def copy_template(src, dst, name, class_name, folder_name):
+    """Copy a file from src to dst."""
+    with open(src, "r") as file:
+        content = file.read()
+
+    # Interpolate the content
+    content = content.replace("{{name}}", name)
+    content = content.replace("{{crew_name}}", class_name)
+    content = content.replace("{{folder_name}}", folder_name)
+
+    # Write the interpolated content to the new file
+    with open(dst, "w") as file:
+        file.write(content)
+
+    click.secho(f"  - Created {dst}", fg="green")

src/crewai/cli/templates/.gitignore

@@ -0,0 +1,2 @@
+.env
+__pycache__/

src/crewai/cli/templates/README.md

@@ -0,0 +1,57 @@
+# {{crew_name}} Crew
+
+Welcome to the {{crew_name}} Crew project, powered by [crewAI](https://crewai.com). This template is designed to help you set up a multi-agent AI system with ease, leveraging the powerful and flexible framework provided by crewAI. Our goal is to enable your agents to collaborate effectively on complex tasks, maximizing their collective intelligence and capabilities.
+
+## Installation
+
+Ensure you have Python >=3.10 <=3.13 installed on your system. This project uses [Poetry](https://python-poetry.org/) for dependency management and package handling, offering a seamless setup and execution experience.
+
+First, if you haven't already, install Poetry:
+
+```bash
+pip install poetry
+```
+
+Next, navigate to your project directory and install the dependencies:
+
+1. First lock the dependencies and then install them:
+```bash
+poetry lock
+```
+```bash
+poetry install
+```
+### Customizing
+
+**Add your `OPENAI_API_KEY` into the `.env` file**
+
+- Modify `src/{{folder_name}}/config/agents.yaml` to define your agents
+- Modify `src/{{folder_name}}/config/tasks.yaml` to define your tasks
+- Modify `src/{{folder_name}}/crew.py` to add your own logic, tools and specific args
+- Modify `src/{{folder_name}}/main.py` to add custom inputs for your agents and tasks
+
+## Running the Project
+
+To kickstart your crew of AI agents and begin task execution, run this from the root folder of your project:
+
+```bash
+poetry run {{folder_name}}
+```
+
+This command initializes the {{name}} Crew, assembling the agents and assigning them tasks as defined in your configuration.
+
+This example, unmodified, will run the create a `report.md` file with the output of a research on LLMs in the root folder.
+
+## Understanding Your Crew
+
+The {{name}} Crew is composed of multiple AI agents, each with unique roles, goals, and tools. These agents collaborate on a series of tasks, defined in `config/tasks.yaml`, leveraging their collective skills to achieve complex objectives. The `config/agents.yaml` file outlines the capabilities and configurations of each agent in your crew.
+
+## Support
+
+For support, questions, or feedback regarding the {{crew_name}} Crew or crewAI.
+- Visit our [documentation](https://docs.crewai.com)
+- Reach out to us through our [GitHub repository](https://github.com/joaomdmoura/crewai)
+- [Join our Discord](https://discord.com/invite/X4JWnZnxPb)
+- [Chat with our docs](https://chatg.pt/DWjSBZn)
+
+Let's create wonders together with the power and simplicity of crewAI.

src/crewai/cli/templates/config/agents.yaml

@@ -0,0 +1,19 @@
+researcher:
+  role: >
+    {topic} Senior Data Researcher
+  goal: >
+    Uncover cutting-edge developments in {topic}
+  backstory: >
+    You're a seasoned researcher with a knack for uncovering the latest
+    developments in {topic}. Known for your ability to find the most relevant
+    information and present it in a clear and concise manner.
+
+reporting_analyst:
+  role: >
+    {topic} Reporting Analyst
+  goal: >
+    Create detailed reports based on {topic} data analysis and research findings
+  backstory: >
+    You're a meticulous analyst with a keen eye for detail. You're known for
+    your ability to turn complex data into clear and concise reports, making
+    it easy for others to understand and act on the information you provide.

src/crewai/cli/templates/config/tasks.yaml

@@ -0,0 +1,15 @@
+research_task:
+  description: >
+    Conduct a thorough research about {topic}
+    Make sure you find any interesting and relevant information given
+    the current year is 2024.
+  expected_output: >
+    A list with 10 bullet points of the most relevant information about {topic}
+
+reporting_task:
+  description: >
+    Review the context you got and expand each topic into a full section for a report.
+    Make sure the report is detailed and contains any and all relevant information.
+  expected_output: >
+    A fully fledge reports with the mains topics, each with a full section of information.
+    Formatted as markdown without '```'

src/crewai/cli/templates/crew.py

@@ -0,0 +1,55 @@
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+
+# Uncomment the following line to use an example of a custom tool
+# from {{folder_name}}.tools.custom_tool import MyCustomTool
+
+# Check our tools documentations for more information on how to use them
+# from crewai_tools import SerperDevTool
+
+@CrewBase
+class {{crew_name}}Crew():
+	"""{{crew_name}} crew"""
+	agents_config = 'config/agents.yaml'
+	tasks_config = 'config/tasks.yaml'
+
+	@agent
+	def researcher(self) -> Agent:
+		return Agent(
+			config=self.agents_config['researcher'],
+			# tools=[MyCustomTool()], # Example of custom tool, loaded on the beginning of file
+			verbose=True
+		)
+
+	@agent
+	def reporting_analyst(self) -> Agent:
+		return Agent(
+			config=self.agents_config['reporting_analyst'],
+			verbose=True
+		)
+
+	@task
+	def research_task(self) -> Task:
+		return Task(
+			config=self.tasks_config['research_task'],
+			agent=self.researcher()
+		)
+
+	@task
+	def reporting_task(self) -> Task:
+		return Task(
+			config=self.tasks_config['reporting_task'],
+			agent=self.reporting_analyst(),
+			output_file='report.md'
+		)
+
+	@crew
+	def crew(self) -> Crew:
+		"""Creates the {{crew_name}} crew"""
+		return Crew(
+			agents=self.agents, # Automatically created by the @agent decorator
+			tasks=self.tasks, # Automatically created by the @task decorator
+			process=Process.sequential,
+			verbose=2,
+			# process=Process.hierarchical, # In case you wanna use that instead https://docs.crewai.com/how-to/Hierarchical/
+		)

src/crewai/cli/templates/main.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+import sys
+from {{folder_name}}.crew import {{crew_name}}Crew
+
+
+def run():
+    # Replace with your inputs, it will automatically interpolate any tasks and agents information
+    inputs = {
+        'topic': 'AI LLMs'
+    }
+    {{crew_name}}Crew().crew().kickoff(inputs=inputs)
+
+
+def train():
+    """
+    Train the crew for a given number of iterations.
+    """
+    inputs = {"topic": "AI LLMs"}
+    try:
+        {{crew_name}}Crew().crew().train(n_iterations=int(sys.argv[1]), inputs=inputs)
+
+    except Exception as e:
+        raise Exception(f"An error occurred while training the crew: {e}")

src/crewai/cli/templates/pyproject.toml

@@ -0,0 +1,17 @@
+[tool.poetry]
+name = "{{folder_name}}"
+version = "0.1.0"
+description = "{{name}} using crewAI"
+authors = ["Your Name <you@example.com>"]
+
+[tool.poetry.dependencies]
+python = ">=3.10,<=3.13"
+crewai = { extras = ["tools"], version = "^0.35.8" }
+
+[tool.poetry.scripts]
+{{folder_name}} = "{{folder_name}}.main:run"
+train = "{{folder_name}}.main:train"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

src/crewai/cli/templates/tools/custom_tool.py

@@ -0,0 +1,12 @@
+from crewai_tools import BaseTool
+
+
+class MyCustomTool(BaseTool):
+    name: str = "Name of my tool"
+    description: str = (
+        "Clear description for what this tool is useful for, you agent will need this information to use it."
+    )
+
+    def _run(self, argument: str) -> str:
+        # Implementation goes here
+        return "this is an example of a tool output, ignore it and move along."

src/crewai/cli/train_crew.py

@@ -0,0 +1,29 @@
+import subprocess
+
+import click
+
+
+def train_crew(n_iterations: int) -> None:
+    """
+    Train the crew by running a command in the Poetry environment.
+
+    Args:
+        n_iterations (int): The number of iterations to train the crew.
+    """
+    command = ["poetry", "run", "train", str(n_iterations)]
+
+    try:
+        if n_iterations <= 0:
+            raise ValueError("The number of iterations must be a positive integer.")
+
+        result = subprocess.run(command, capture_output=False, text=True, check=True)
+
+        if result.stderr:
+            click.echo(result.stderr, err=True)
+
+    except subprocess.CalledProcessError as e:
+        click.echo(f"An error occurred while training the crew: {e}", err=True)
+        click.echo(e.output, err=True)
+
+    except Exception as e:
+        click.echo(f"An unexpected error occurred: {e}", err=True)

src/crewai/crew.py

@@ -1,27 +1,48 @@
+import asyncio
 import json
 import uuid
-from typing import Any, Dict, List, Optional, Union
+from concurrent.futures import Future
+from typing import Any, Dict, List, Optional, Tuple, Union
 
+from langchain_core.callbacks import BaseCallbackHandler
 from pydantic import (
-    UUID4,
-    BaseModel,
-    ConfigDict,
-    Field,
-    InstanceOf,
-    Json,
-    PrivateAttr,
-    field_validator,
-    model_validator,
+  UUID4,
+  BaseModel,
+  ConfigDict,
+  Field,
+  InstanceOf,
+  Json,
+  PrivateAttr,
+  field_validator,
+  model_validator,
 )
 from pydantic_core import PydanticCustomError
 
 from crewai.agent import Agent
+from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.agents.cache import CacheHandler
+from crewai.crews.crew_output import CrewOutput
+from crewai.memory.entity.entity_memory import EntityMemory
+from crewai.memory.long_term.long_term_memory import LongTermMemory
+from crewai.memory.short_term.short_term_memory import ShortTermMemory
 from crewai.process import Process
 from crewai.task import Task
-from crewai.telemtry import Telemetry
+from crewai.tasks.task_output import TaskOutput
+from crewai.telemetry import Telemetry
 from crewai.tools.agent_tools import AgentTools
-from crewai.utilities import I18N, Logger, RPMController
+from crewai.utilities import I18N, FileHandler, Logger, RPMController
+from crewai.utilities.constants import TRAINED_AGENTS_DATA_FILE, TRAINING_DATA_FILE
+from crewai.utilities.evaluators.task_evaluator import TaskEvaluator
+from crewai.utilities.formatter import (
+    aggregate_raw_outputs_from_task_outputs,
+    aggregate_raw_outputs_from_tasks,
+)
+from crewai.utilities.training_handler import CrewTrainingHandler
+
+try:
+    import agentops
+except ImportError:
+    agentops = None
 
 
 class Crew(BaseModel):
@@ -32,34 +53,62 @@ class Crew(BaseModel):
         tasks: List of tasks assigned to the crew.
         agents: List of agents part of this crew.
         manager_llm: The language model that will run manager agent.
+        manager_agent: Custom agent that will be used as manager.
+        memory: Whether the crew should use memory to store memories of it's execution.
+        manager_callbacks: The callback handlers to be executed by the manager agent when hierarchical process is used
+        cache: Whether the crew should use a cache to store the results of the tools execution.
         function_calling_llm: The language model that will run the tool calling for all the agents.
-        process: The process flow that the crew will follow (e.g., sequential).
+        process: The process flow that the crew will follow (e.g., sequential, hierarchical).
         verbose: Indicates the verbosity level for logging during execution.
         config: Configuration settings for the crew.
         max_rpm: Maximum number of requests per minute for the crew execution to be respected.
+        prompt_file: Path to the prompt json file to be used for the crew.
         id: A unique identifier for the crew instance.
-        full_output: Whether the crew should return the full output with all tasks outputs or just the final output.
+        task_callback: Callback to be executed after each task for every agents execution.
         step_callback: Callback to be executed after each step for every agents execution.
-        share_crew: Whether you want to share the complete crew infromation and execution with crewAI to make the library better, and allow us to train models.
+        share_crew: Whether you want to share the complete crew information and execution with crewAI to make the library better, and allow us to train models.
     """
 
     __hash__ = object.__hash__  # type: ignore
     _execution_span: Any = PrivateAttr()
     _rpm_controller: RPMController = PrivateAttr()
     _logger: Logger = PrivateAttr()
+    _file_handler: FileHandler = PrivateAttr()
     _cache_handler: InstanceOf[CacheHandler] = PrivateAttr(default=CacheHandler())
+    _short_term_memory: Optional[InstanceOf[ShortTermMemory]] = PrivateAttr()
+    _long_term_memory: Optional[InstanceOf[LongTermMemory]] = PrivateAttr()
+    _entity_memory: Optional[InstanceOf[EntityMemory]] = PrivateAttr()
+    _train: Optional[bool] = PrivateAttr(default=False)
+    _train_iteration: Optional[int] = PrivateAttr()
+
+    cache: bool = Field(default=True)
     model_config = ConfigDict(arbitrary_types_allowed=True)
     tasks: List[Task] = Field(default_factory=list)
-    agents: List[Agent] = Field(default_factory=list)
+    agents: List[BaseAgent] = Field(default_factory=list)
     process: Process = Field(default=Process.sequential)
     verbose: Union[int, bool] = Field(default=0)
-    full_output: Optional[bool] = Field(
+    memory: bool = Field(
         default=False,
-        description="Whether the crew should return the full output with all tasks outputs or just the final output.",
+        description="Whether the crew should use memory to store memories of it's execution",
+    )
+    embedder: Optional[dict] = Field(
+        default={"provider": "openai"},
+        description="Configuration for the embedder to be used for the crew.",
+    )
+    usage_metrics: Optional[dict] = Field(
+        default=None,
+        description="Metrics for the LLM usage during all tasks execution.",
     )
     manager_llm: Optional[Any] = Field(
         description="Language model that will run the agent.", default=None
     )
+    manager_agent: Optional[BaseAgent] = Field(
+        description="Custom agent that will be used as manager.", default=None
+    )
+    manager_callbacks: Optional[List[InstanceOf[BaseCallbackHandler]]] = Field(
+        default=None,
+        description="A list of callback handlers to be executed by the manager agent when hierarchical process is used",
+    )
     function_calling_llm: Optional[Any] = Field(
         description="Language model that will run the agent.", default=None
     )
@@ -70,13 +119,21 @@ class Crew(BaseModel):
         default=None,
         description="Callback to be executed after each step for all agents execution.",
     )
+    task_callback: Optional[Any] = Field(
+        default=None,
+        description="Callback to be executed after each task for all agents execution.",
+    )
     max_rpm: Optional[int] = Field(
         default=None,
         description="Maximum number of requests per minute for the crew execution to be respected.",
     )
-    language: str = Field(
-        default="en",
-        description="Language used for the crew, defaults to English.",
+    prompt_file: str = Field(
+        default=None,
+        description="Path to the prompt json file to be used for the crew.",
+    )
+    output_log_file: Optional[Union[bool, str]] = Field(
+        default=False,
+        description="output_log_file",
     )
 
     @field_validator("id", mode="before")
@@ -108,21 +165,44 @@ class Crew(BaseModel):
         """Set private attributes."""
         self._cache_handler = CacheHandler()
         self._logger = Logger(self.verbose)
+        if self.output_log_file:
+            self._file_handler = FileHandler(self.output_log_file)
         self._rpm_controller = RPMController(max_rpm=self.max_rpm, logger=self._logger)
         self._telemetry = Telemetry()
         self._telemetry.set_tracer()
-        self._telemetry.crew_creation(self)
+        return self
+
+    @model_validator(mode="after")
+    def create_crew_memory(self) -> "Crew":
+        """Set private attributes."""
+        if self.memory:
+            self._long_term_memory = LongTermMemory()
+            self._short_term_memory = ShortTermMemory(
+                crew=self, embedder_config=self.embedder
+            )
+            self._entity_memory = EntityMemory(crew=self, embedder_config=self.embedder)
         return self
 
     @model_validator(mode="after")
     def check_manager_llm(self):
         """Validates that the language model is set when using hierarchical process."""
-        if self.process == Process.hierarchical and not self.manager_llm:
-            raise PydanticCustomError(
-                "missing_manager_llm",
-                "Attribute `manager_llm` is required when using hierarchical process.",
-                {},
-            )
+        if self.process == Process.hierarchical:
+            if not self.manager_llm and not self.manager_agent:
+                raise PydanticCustomError(
+                    "missing_manager_llm_or_manager_agent",
+                    "Attribute `manager_llm` or `manager_agent` is required when using hierarchical process.",
+                    {},
+                )
+
+            if (self.manager_agent is not None) and (
+                self.agents.count(self.manager_agent) > 0
+            ):
+                raise PydanticCustomError(
+                    "manager_agent_in_agents",
+                    "Manager agent should not be included in agents list.",
+                    {},
+                )
+
         return self
 
     @model_validator(mode="after")
@@ -140,11 +220,96 @@ class Crew(BaseModel):
 
         if self.agents:
             for agent in self.agents:
-                agent.set_cache_handler(self._cache_handler)
+                if self.cache:
+                    agent.set_cache_handler(self._cache_handler)
                 if self.max_rpm:
                     agent.set_rpm_controller(self._rpm_controller)
         return self
 
+    @model_validator(mode="after")
+    def validate_tasks(self):
+        if self.process == Process.sequential:
+            for task in self.tasks:
+                if task.agent is None:
+                    raise PydanticCustomError(
+                        "missing_agent_in_task",
+                        f"Sequential process error: Agent is missing in the task with the following description: {task.description}",  # type: ignore # Argument of type "str" cannot be assigned to parameter "message_template" of type "LiteralString"
+                        {},
+                    )
+
+        return self
+
+    @model_validator(mode="after")
+    def check_tasks_in_hierarchical_process_not_async(self):
+        """Validates that the tasks in hierarchical process are not flagged with async_execution."""
+        if self.process == Process.hierarchical:
+            for task in self.tasks:
+                if task.async_execution:
+                    raise PydanticCustomError(
+                        "async_execution_in_hierarchical_process",
+                        "Hierarchical process error: Tasks cannot be flagged with async_execution.",
+                        {},
+                    )
+
+        return self
+
+    @model_validator(mode="after")
+    def validate_end_with_at_most_one_async_task(self):
+        """Validates that the crew ends with at most one asynchronous task."""
+        final_async_task_count = 0
+
+        # Traverse tasks backward
+        for task in reversed(self.tasks):
+            if task.async_execution:
+                final_async_task_count += 1
+            else:
+                break  # Stop traversing as soon as a non-async task is encountered
+
+        if final_async_task_count > 1:
+            raise PydanticCustomError(
+                "async_task_count",
+                "The crew must end with at most one asynchronous task.",
+                {},
+            )
+
+        return self
+
+    @model_validator(mode="after")
+    def validate_async_task_cannot_include_sequential_async_tasks_in_context(self):
+        """
+        Validates that if a task is set to be executed asynchronously,
+        it cannot include other asynchronous tasks in its context unless
+        separated by a synchronous task.
+        """
+        for i, task in enumerate(self.tasks):
+            if task.async_execution and task.context:
+                for context_task in task.context:
+                    if context_task.async_execution:
+                        for j in range(i - 1, -1, -1):
+                            if self.tasks[j] == context_task:
+                                raise ValueError(
+                                    f"Task '{task.description}' is asynchronous and cannot include other sequential asynchronous tasks in its context."
+                                )
+                            if not self.tasks[j].async_execution:
+                                break
+        return self
+
+    @model_validator(mode="after")
+    def validate_context_no_future_tasks(self):
+        """Validates that a task's context does not include future tasks."""
+        task_indices = {id(task): i for i, task in enumerate(self.tasks)}
+
+        for task in self.tasks:
+            if task.context:
+                for context_task in task.context:
+                    if id(context_task) not in task_indices:
+                        continue  # Skip context tasks not in the main tasks list
+                    if task_indices[id(context_task)] > task_indices[id(task)]:
+                        raise ValueError(
+                            f"Task '{task.description}' has a context dependency on a future task '{context_task.description}', which is not allowed."
+                        )
+        return self
+
     def _setup_from_config(self):
         assert self.config is not None, "Config should not be None."
 
@@ -173,93 +338,456 @@ class Crew(BaseModel):
         del task_config["agent"]
         return Task(**task_config, agent=task_agent)
 
-    def kickoff(self) -> str:
-        """Starts the crew to work on its assigned tasks."""
-        self._execution_span = self._telemetry.crew_execution_span(self)
+    def _setup_for_training(self) -> None:
+        """Sets up the crew for training."""
+        self._train = True
+
+        for task in self.tasks:
+            task.human_input = True
 
         for agent in self.agents:
-            agent.i18n = I18N(language=self.language)
+            agent.allow_delegation = False
 
-            if not agent.function_calling_llm:
-                agent.function_calling_llm = self.function_calling_llm
-                agent.create_agent_executor()
-            if not agent.step_callback:
-                agent.step_callback = self.step_callback
-                agent.create_agent_executor()
+        CrewTrainingHandler(TRAINING_DATA_FILE).initialize_file()
+        CrewTrainingHandler(TRAINED_AGENTS_DATA_FILE).initialize_file()
+
+    def train(self, n_iterations: int, inputs: Optional[Dict[str, Any]] = {}) -> None:
+        """Trains the crew for a given number of iterations."""
+        self._setup_for_training()
+
+        for n_iteration in range(n_iterations):
+            self._train_iteration = n_iteration
+            self.kickoff(inputs=inputs)
+
+        training_data = CrewTrainingHandler(TRAINING_DATA_FILE).load()
+
+        for agent in self.agents:
+            result = TaskEvaluator(agent).evaluate_training_data(
+                training_data=training_data, agent_id=str(agent.id)
+            )
+
+            CrewTrainingHandler(TRAINED_AGENTS_DATA_FILE).save_trained_data(
+                agent_id=str(agent.role), trained_data=result.model_dump()
+            )
+
+    def kickoff(
+        self,
+        inputs: Optional[Dict[str, Any]] = None,
+    ) -> CrewOutput:
+        """Starts the crew to work on its assigned tasks."""
+        self._execution_span = self._telemetry.crew_execution_span(self, inputs)
+        if inputs is not None:
+            self._interpolate_inputs(inputs)
+        self._set_tasks_callbacks()
+
+        i18n = I18N(prompt_file=self.prompt_file)
+
+        for agent in self.agents:
+            agent.i18n = i18n
+            # type: ignore[attr-defined] # Argument 1 to "_interpolate_inputs" of "Crew" has incompatible type "dict[str, Any] | None"; expected "dict[str, Any]"
+            agent.crew = self  # type: ignore[attr-defined]
+            # TODO: Create an AgentFunctionCalling protocol for future refactoring
+            if not agent.function_calling_llm:  # type: ignore # "BaseAgent" has no attribute "function_calling_llm"
+                agent.function_calling_llm = self.function_calling_llm  # type: ignore # "BaseAgent" has no attribute "function_calling_llm"
+
+            if agent.allow_code_execution:  # type: ignore # BaseAgent" has no attribute "allow_code_execution"
+                agent.tools += agent.get_code_execution_tools()  # type: ignore # "BaseAgent" has no attribute "get_code_execution_tools"; maybe "get_delegation_tools"?
+
+            if not agent.step_callback:  # type: ignore # "BaseAgent" has no attribute "step_callback"
+                agent.step_callback = self.step_callback  # type: ignore # "BaseAgent" has no attribute "step_callback"
+
+            agent.create_agent_executor()
+
+        metrics = []
 
         if self.process == Process.sequential:
-            return self._run_sequential_process()
-        if self.process == Process.hierarchical:
-            return self._run_hierarchical_process()
+            result = self._run_sequential_process()
+        elif self.process == Process.hierarchical:
+            result = self._run_hierarchical_process()  # type: ignore # Incompatible types in assignment (expression has type "str | dict[str, Any]", variable has type "str")
+        else:
+            raise NotImplementedError(
+                f"The process '{self.process}' is not implemented yet."
+            )
+        metrics += [agent._token_process.get_summary() for agent in self.agents]
 
-        raise NotImplementedError(
-            f"The process '{self.process}' is not implemented yet."
-        )
+        self.usage_metrics = {
+            key: sum([m[key] for m in metrics if m is not None]) for key in metrics[0]
+        }
 
-    def _run_sequential_process(self) -> str:
+        return result
+
+    def kickoff_for_each(self, inputs: List[Dict[str, Any]]) -> List[CrewOutput]:
+        """Executes the Crew's workflow for each input in the list and aggregates results."""
+        results: List[CrewOutput] = []
+
+        # Initialize the parent crew's usage metrics
+        total_usage_metrics = {
+            "total_tokens": 0,
+            "prompt_tokens": 0,
+            "completion_tokens": 0,
+            "successful_requests": 0,
+        }
+
+        for input_data in inputs:
+            crew = self.copy()
+
+            output = crew.kickoff(inputs=input_data)
+
+            if crew.usage_metrics:
+                for key in total_usage_metrics:
+                    total_usage_metrics[key] += crew.usage_metrics.get(key, 0)
+
+            results.append(output)
+
+        self.usage_metrics = total_usage_metrics
+        return results
+
+    async def kickoff_async(self, inputs: Optional[Dict[str, Any]] = {}) -> CrewOutput:
+        """Asynchronous kickoff method to start the crew execution."""
+        return await asyncio.to_thread(self.kickoff, inputs)
+
+    async def kickoff_for_each_async(self, inputs: List[Dict]) -> List[CrewOutput]:
+        crew_copies = [self.copy() for _ in inputs]
+
+        async def run_crew(crew, input_data):
+            return await crew.kickoff_async(inputs=input_data)
+
+        tasks = [
+            asyncio.create_task(run_crew(crew_copies[i], inputs[i]))
+            for i in range(len(inputs))
+        ]
+        tasks = [
+            asyncio.create_task(run_crew(crew_copies[i], inputs[i]))
+            for i in range(len(inputs))
+        ]
+
+        results = await asyncio.gather(*tasks)
+
+        total_usage_metrics = {
+            "total_tokens": 0,
+            "prompt_tokens": 0,
+            "completion_tokens": 0,
+            "successful_requests": 0,
+        }
+        for crew in crew_copies:
+            if crew.usage_metrics:
+                for key in total_usage_metrics:
+                    total_usage_metrics[key] += crew.usage_metrics.get(key, 0)
+
+        self.usage_metrics = total_usage_metrics
+
+        total_usage_metrics = {
+            "total_tokens": 0,
+            "prompt_tokens": 0,
+            "completion_tokens": 0,
+            "successful_requests": 0,
+        }
+        for crew in crew_copies:
+            if crew.usage_metrics:
+                for key in total_usage_metrics:
+                    total_usage_metrics[key] += crew.usage_metrics.get(key, 0)
+
+        self.usage_metrics = total_usage_metrics
+
+        return results
+
+    def _run_sequential_process(self) -> CrewOutput:
         """Executes tasks sequentially and returns the final output."""
-        task_output = ""
+        task_outputs: List[TaskOutput] = []
+        futures: List[Tuple[Task, Future[TaskOutput]]] = []
+
         for task in self.tasks:
-            if task.agent is not None and task.agent.allow_delegation:
+            if task.agent and task.agent.allow_delegation:
                 agents_for_delegation = [
                     agent for agent in self.agents if agent != task.agent
                 ]
-                task.tools += AgentTools(agents=agents_for_delegation).tools()
+                if len(self.agents) > 1 and len(agents_for_delegation) > 0:
+                    delegation_tools = task.agent.get_delegation_tools(
+                        agents_for_delegation
+                    )
+
+                    # Add tools if they are not already in task.tools
+                    for new_tool in delegation_tools:
+                        # Find the index of the tool with the same name
+                        existing_tool_index = next(
+                            (
+                                index
+                                for index, tool in enumerate(task.tools or [])
+                                if tool.name == new_tool.name
+                            ),
+                            None,
+                        )
+                        if not task.tools:
+                            task.tools = []
+
+                        if existing_tool_index is not None:
+                            # Replace the existing tool
+                            task.tools[existing_tool_index] = new_tool 
+                        else:
+                            # Add the new tool
+                            task.tools.append(new_tool)
 
             role = task.agent.role if task.agent is not None else "None"
-            self._logger.log("debug", f"Working Agent: {role}")
-            self._logger.log("info", f"Starting Task: {task.description}")
+            self._logger.log("debug", f"== Working Agent: {role}", color="bold_purple")
+            self._logger.log(
+                "info", f"== Starting Task: {task.description}", color="bold_purple"
+            )
 
-            output = task.execute(context=task_output)
-            if not task.async_execution:
-                task_output = output
+            if self.output_log_file:
+                self._file_handler.log(
+                    agent=role, task=task.description, status="started"
+                )
 
-            role = task.agent.role if task.agent is not None else "None"
-            self._logger.log("debug", f"[{role}] Task output: {task_output}\n\n")
+            if task.async_execution:
+                context = (
+                    aggregate_raw_outputs_from_tasks(task.context)
+                    if task.context
+                    else aggregate_raw_outputs_from_task_outputs(task_outputs)
+                )
+                future = task.execute_async(
+                    agent=task.agent, context=context, tools=task.tools
+                )
+                futures.append((task, future))
+            else:
+                # Before executing a synchronous task, wait for all async tasks to complete
+                if futures:
+                    # Clear task_outputs before processing async tasks
+                    task_outputs = []
+                    for future_task, future in futures:
+                        task_output = future.result()
+                        task_outputs.append(task_output)
+                        self._process_task_result(future_task, task_output)
 
-        self._finish_execution(task_output)
-        return self._format_output(task_output)
+                    # Clear the futures list after processing all async results
+                    futures.clear()
 
-    def _run_hierarchical_process(self) -> str:
-        """Creates and assigns a manager agent to make sure the crew completes the tasks."""
+                context = (
+                    aggregate_raw_outputs_from_tasks(task.context)
+                    if task.context
+                    else aggregate_raw_outputs_from_task_outputs(task_outputs)
+                )
+                task_output = task.execute_sync(
+                    agent=task.agent, context=context, tools=task.tools
+                )
+                task_outputs = [task_output]
+                self._process_task_result(task, task_output)
 
-        i18n = I18N(language=self.language)
-        manager = Agent(
-            role=i18n.retrieve("hierarchical_manager_agent", "role"),
-            goal=i18n.retrieve("hierarchical_manager_agent", "goal"),
-            backstory=i18n.retrieve("hierarchical_manager_agent", "backstory"),
-            tools=AgentTools(agents=self.agents).tools(),
-            llm=self.manager_llm,
-            verbose=True,
+        if futures:
+            # Clear task_outputs before processing async tasks
+            task_outputs = []
+            for future_task, future in futures:
+                task_output = future.result()
+                task_outputs.append(task_output)
+                self._process_task_result(future_task, task_output)
+
+        # Important: There should only be one task output in the list
+        #            If there are more or 0, something went wrong.
+        if len(task_outputs) != 1:
+            raise ValueError(
+                "Something went wrong. Kickoff should return only one task output."
+            )
+
+        final_task_output = task_outputs[0]
+
+        final_string_output = final_task_output.raw
+        self._finish_execution(final_string_output)
+
+        token_usage = self.calculate_usage_metrics()
+
+        return CrewOutput(
+            raw=final_task_output.raw,
+            pydantic=final_task_output.pydantic,
+            json_dict=final_task_output.json_dict,
+            tasks_output=[task.output for task in self.tasks if task.output],
+            token_usage=token_usage,
         )
 
-        task_output = ""
+    def _process_task_result(self, task: Task, output: TaskOutput) -> None:
+        role = task.agent.role if task.agent is not None else "None"
+        self._logger.log("debug", f"== [{role}] Task output: {output}\n\n")
+        if self.output_log_file:
+            self._file_handler.log(agent=role, task=output, status="completed")
+
+    # TODO: @joao, Breaking change. Changed return type. Usage metrics is included in crewoutput
+    def _run_hierarchical_process(self) -> CrewOutput:
+        """Creates and assigns a manager agent to make sure the crew completes the tasks."""
+        i18n = I18N(prompt_file=self.prompt_file)
+        if self.manager_agent is not None:
+            self.manager_agent.allow_delegation = True
+            manager = self.manager_agent
+            if manager.tools is not None and len(manager.tools) > 0:
+                raise Exception("Manager agent should not have tools")
+            manager.tools = self.manager_agent.get_delegation_tools(self.agents)
+        else:
+            manager = Agent(
+                role=i18n.retrieve("hierarchical_manager_agent", "role"),
+                goal=i18n.retrieve("hierarchical_manager_agent", "goal"),
+                backstory=i18n.retrieve("hierarchical_manager_agent", "backstory"),
+                tools=AgentTools(agents=self.agents).tools(),
+                llm=self.manager_llm,
+                verbose=self.verbose,
+            )
+            self.manager_agent = manager
+
+        task_outputs: List[TaskOutput] = []
+        futures: List[Tuple[Task, Future[TaskOutput]]] = []
+
+        # TODO: IF USER OVERRIDE THE CONTEXT, PASS THAT
         for task in self.tasks:
             self._logger.log("debug", f"Working Agent: {manager.role}")
             self._logger.log("info", f"Starting Task: {task.description}")
 
-            task_output = task.execute(
-                agent=manager, context=task_output, tools=manager.tools
+            if self.output_log_file:
+                self._file_handler.log(
+                    agent=manager.role, task=task.description, status="started"
+                )
+
+            if task.async_execution:
+                context = (
+                    aggregate_raw_outputs_from_tasks(task.context)
+                    if task.context
+                    else aggregate_raw_outputs_from_task_outputs(task_outputs)
+                )
+                future = task.execute_async(
+                    agent=manager, context=context, tools=manager.tools
+                )
+                futures.append((task, future))
+            else:
+                # Before executing a synchronous task, wait for all async tasks to complete
+                if futures:
+                    # Clear task_outputs before processing async tasks
+                    task_outputs = []
+                    for future_task, future in futures:
+                        task_output = future.result()
+                        task_outputs.append(task_output)
+                        self._process_task_result(future_task, task_output)
+
+                    # Clear the futures list after processing all async results
+                    futures.clear()
+
+                context = (
+                    aggregate_raw_outputs_from_tasks(task.context)
+                    if task.context
+                    else aggregate_raw_outputs_from_task_outputs(task_outputs)
+                )
+                task_output = task.execute_sync(
+                    agent=manager, context=context, tools=manager.tools
+                )
+                task_outputs = [task_output]
+                self._process_task_result(task, task_output)
+
+        # Process any remaining async results
+        if futures:
+            # Clear task_outputs before processing async tasks
+            task_outputs = []
+            for future_task, future in futures:
+                task_output = future.result()
+                task_outputs.append(task_output)
+                self._process_task_result(future_task, task_output)
+
+        # Important: There should only be one task output in the list
+        #            If there are more or 0, something went wrong.
+        if len(task_outputs) != 1:
+            raise ValueError(
+                "Something went wrong. Kickoff should return only one task output."
             )
 
-            self._logger.log(
-                "debug", f"[{manager.role}] Task output: {task_output}\n\n"
+        final_task_output = task_outputs[0]
+
+        final_string_output = final_task_output.raw
+        self._finish_execution(final_string_output)
+
+        token_usage = self.calculate_usage_metrics()
+
+        return CrewOutput(
+            raw=final_task_output.raw,
+            pydantic=final_task_output.pydantic,
+            json_dict=final_task_output.json_dict,
+            tasks_output=[task.output for task in self.tasks if task.output],
+            token_usage=token_usage,
+        )
+
+    def copy(self):
+        """Create a deep copy of the Crew."""
+
+        exclude = {
+            "id",
+            "_rpm_controller",
+            "_logger",
+            "_execution_span",
+            "_file_handler",
+            "_cache_handler",
+            "_short_term_memory",
+            "_long_term_memory",
+            "_entity_memory",
+            "_telemetry",
+            "agents",
+            "tasks",
+        }
+
+        cloned_agents = [agent.copy() for agent in self.agents]
+        cloned_tasks = [task.copy(cloned_agents) for task in self.tasks]
+
+        copied_data = self.model_dump(exclude=exclude)
+        copied_data = {k: v for k, v in copied_data.items() if v is not None}
+
+        copied_data.pop("agents", None)
+        copied_data.pop("tasks", None)
+
+        copied_crew = Crew(**copied_data, agents=cloned_agents, tasks=cloned_tasks)
+
+        return copied_crew
+
+    def _set_tasks_callbacks(self) -> None:
+        """Sets callback for every task suing task_callback"""
+        for task in self.tasks:
+            if not task.callback:
+                task.callback = self.task_callback
+
+    def _interpolate_inputs(self, inputs: Dict[str, Any]) -> None:
+        """Interpolates the inputs in the tasks and agents."""
+        [
+            task.interpolate_inputs(
+                # type: ignore # "interpolate_inputs" of "Task" does not return a value (it only ever returns None)
+                inputs
             )
+            for task in self.tasks
+        ]
+        # type: ignore # "interpolate_inputs" of "Agent" does not return a value (it only ever returns None)
+        for agent in self.agents:
+            agent.interpolate_inputs(inputs)
 
-        self._finish_execution(task_output)
-        return self._format_output(task_output)
-
-    def _format_output(self, output: str) -> str:
-        """Formats the output of the crew execution."""
-        if self.full_output:
-            return {
-                "final_output": output,
-                "tasks_outputs": [task.output for task in self.tasks],
-            }
-        else:
-            return output
-
-    def _finish_execution(self, output) -> None:
+    def _finish_execution(self, final_string_output: str) -> None:
         if self.max_rpm:
             self._rpm_controller.stop_rpm_counter()
-        self._telemetry.end_crew(self, output)
+        if agentops:
+            agentops.end_session(
+                end_state="Success",
+                end_state_reason="Finished Execution",
+            )
+        self._telemetry.end_crew(self, final_string_output)
+
+    def calculate_usage_metrics(self) -> Dict[str, int]:
+        """Calculates and returns the usage metrics."""
+        total_usage_metrics = {
+            "total_tokens": 0,
+            "prompt_tokens": 0,
+            "completion_tokens": 0,
+            "successful_requests": 0,
+        }
+
+        for agent in self.agents:
+            if hasattr(agent, "_token_process"):
+                token_sum = agent._token_process.get_summary()
+                for key in total_usage_metrics:
+                    total_usage_metrics[key] += token_sum.get(key, 0)
+
+        if self.manager_agent and hasattr(self.manager_agent, "_token_process"):
+            token_sum = self.manager_agent._token_process.get_summary()
+            for key in total_usage_metrics:
+                total_usage_metrics[key] += token_sum.get(key, 0)
+
+        return total_usage_metrics
+
+    def __repr__(self):
+        return f"Crew(id={self.id}, process={self.process}, number_of_agents={len(self.agents)}, number_of_tasks={len(self.tasks)})"

src/crewai/crews/__init__.py

@@ -0,0 +1 @@
+from .crew_output import CrewOutput

src/crewai/crews/crew_output.py

@@ -0,0 +1,60 @@
+import json
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, Field
+
+from crewai.tasks.output_format import OutputFormat
+from crewai.tasks.task_output import TaskOutput
+
+
+class CrewOutput(BaseModel):
+    """Class that represents the result of a crew."""
+
+    raw: str = Field(description="Raw output of crew", default="")
+    pydantic: Optional[BaseModel] = Field(
+        description="Pydantic output of Crew", default=None
+    )
+    json_dict: Optional[Dict[str, Any]] = Field(
+        description="JSON dict output of Crew", default=None
+    )
+    tasks_output: list[TaskOutput] = Field(
+        description="Output of each task", default=[]
+    )
+    token_usage: Dict[str, Any] = Field(
+        description="Processed token summary", default={}
+    )
+
+    # TODO: Joao - Adding this safety check breakes when people want to see
+    #                   The full output of a CrewOutput.
+    # @property
+    # def pydantic(self) -> Optional[BaseModel]:
+    #     # Check if the final task output included a pydantic model
+    #     if self.tasks_output[-1].output_format != OutputFormat.PYDANTIC:
+    #         raise ValueError(
+    #             "No pydantic model found in the final task. Please make sure to set the output_pydantic property in the final task in your crew."
+    #         )
+
+    #     return self._pydantic
+
+    @property
+    def json(self) -> Optional[str]:
+        if self.tasks_output[-1].output_format != OutputFormat.JSON:
+            raise ValueError(
+                "No JSON output found in the final task. Please make sure to set the output_json property in the final task in your crew."
+            )
+
+        return json.dumps(self.json_dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        if self.json_dict:
+            return self.json_dict
+        if self.pydantic:
+            return self.pydantic.model_dump()
+        raise ValueError("No output to convert to dictionary")
+
+    def __str__(self):
+        if self.pydantic:
+            return str(self.pydantic)
+        if self.json_dict:
+            return str(self.json_dict)
+        return self.raw

src/crewai/memory/__init__.py

@@ -0,0 +1,3 @@
+from .entity.entity_memory import EntityMemory
+from .long_term.long_term_memory import LongTermMemory
+from .short_term.short_term_memory import ShortTermMemory