preparing new version

* fix the issue where the suggestions were split at character level

* Update contextual_memory.py

---------

Co-authored-by: rajib76 <rajib76@yahoo.com>
Co-authored-by: João Moura <joaomdmoura@gmail.com>

.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

.gitignore

@@ -7,4 +7,5 @@ assets/*
 .idea
 test/
 docs_crew/
-chroma.sqlite3
+chroma.sqlite3
+old_en.json

README.md

@@ -49,7 +49,7 @@ To get started with CrewAI, follow these simple steps:
 pip install crewai
 ```
 
-If you want to also install crewai-tools, which is a package with tools that can be used by the agents, but more dependencies, you can install it with, example bellow uses it:
+If you want to also install crewai-tools, which is a package with tools that can be used by the agents, but more dependencies, you can install it with, example below uses it:
 
 ```shell
 pip install 'crewai[tools]'

docs/CNAME

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

docs/core-concepts/Agents.md

@@ -10,26 +10,27 @@ 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>
+    </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** *(optional)*                 | The language model used by the agent to process and generate text. It dynamically fetches the model name from the `OPENAI_MODEL_NAME` environment variable, defaulting to "gpt-4" if not specified.                                            |
-| **Tools** *(optional)*               | Set of capabilities or functions that the agent can use to perform tasks. Tools can be shared or exclusive to specific agents. It's an attribute that can be set during the initialization of an agent, with a default value of an empty list.  |
-| **Function Calling LLM** *(optional)*  | If passed, this agent will use this LLM to execute function calling for tools instead of relying on the main LLM output.                                                                                                                       |
-| **Max Iter** *(optional)*            | The maximum number of iterations the agent can perform before being forced to give its best answer. Default is `15`.                                                                                                                           |
-| **Max RPM** *(optional)*             | 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`.                                                                               |
-| **Verbose** *(optional)*             | Enables detailed logging of the agent's execution for debugging or monitoring purposes when set to True. Default is `False`.                                                                                                                    |
-| **Allow Delegation** *(optional)*    | 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)*       | 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`.                                                                |
-| **Memory** *(optional)*             | Indicates whether the agent should have memory or not, with a default value of False. This impacts the agent's ability to remember past interactions. Default is `False`.                                                                      |
+| 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** *(optional)*       | 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)*     | 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)* | 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)*  | The maximum number of iterations the agent can perform before being forced to give its best answer. Default is `25`.                                                                                                                           |
+| **Max RPM** *(optional)*   | 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)*   | Maximum execution time for an agent to execute a task It's optional and can be left unspecified, with a default value of `None`, menaning no max execution time                                                                     |
+| **Verbose** *(optional)*   | Setting this to `True` configures the internal logger to provide detailed execution logs, aiding in debugging and monitoring. Default is `False`.                                                                                              |
+| **Allow Delegation** *(optional)* | 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)* | 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)*     | Indicates if the agent should use a cache for tool usage. Default is `True`.                                                                                                                                                                  |
 
 ## Creating an Agent
 
@@ -58,7 +59,7 @@ agent = Agent(
   verbose=True,  # Optional
   allow_delegation=True,  # Optional
   step_callback=my_intermediate_step_callback,  # Optional
-  memory=True  # Optional
+  cache=True  # Optional
 )
 ```
 

docs/core-concepts/Collaboration.md

@@ -14,16 +14,17 @@ description: Exploring the dynamics of agent collaboration within the CrewAI fra
 ## 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. It's important to note that `manager_llm` is mandatory when using a hierarchical process for ensuring proper execution flow.
+- **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.
 - **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.
-- **Configuration (`config`)**: Allows extensive customization to tailor the crew's behavior according to specific requirements.
-- **Rate Limiting (`max_rpm`)**: Ensures efficient utilization of resources by limiting requests per minute.
-- **Internationalization Support (`language`)**: Facilitates operation in multiple languages, enhancing global usability.
-- **Execution and Output Handling (`full_output`)**: Distinguishes between full and final outputs for nuanced control over task results.
-- **Callback and Telemetry (`step_callback`)**: Integrates callbacks for step-wise execution monitoring and telemetry for performance analytics.
-- **Crew Sharing (`share_crew`)**: Enables sharing of crew information with CrewAI for continuous improvement and training models.
-- **Usage Metrics (`usage_metrics`)**: Store all metrics for the language model (LLM) usage during all tasks' execution, providing insights into operational efficiency and areas for improvement, you can check it after the crew 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 Support (`language`, `language_file`)**: Facilitates operation in multiple languages, enhancing global usability. Supported languages and the process for utilizing the `language_file` attribute for customization should be clearly documented.
+- **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.
 
 ## Delegation: Dividing to Conquer
 Delegation enhances functionality by allowing agents to intelligently assign tasks or seek help, thereby amplifying the crew's overall capability.
@@ -35,4 +36,4 @@ Setting up a crew involves defining the roles and capabilities of each agent. Cr
 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
-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.
+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,36 +1,41 @@
 ---
 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** *(optional)*              | The process flow (e.g., sequential, hierarchical) the crew follows. |
-| **Verbose** *(optional)*              | The verbosity level for logging during execution.            |
-| **Manager LLM** *(optional)*          | The language model used by the manager agent in a hierarchical process. **Required when using a hierarchical process.** |
+| Attribute                   | Description                                                  |
+| :-------------------------- | :----------------------------------------------------------- |
+| **Tasks**                   | A list of tasks assigned to the crew.                        |
+| **Agents**                  | A list of agents that are part of the crew.                  |
+| **Process** *(optional)*    | The process flow (e.g., sequential, hierarchical) the crew follows. |
+| **Verbose** *(optional)*    | The verbosity level for logging during execution.            |
+| **Manager LLM** *(optional)*| The language model used by the manager agent in a hierarchical process. **Required when using a hierarchical process.** |
 | **Function Calling LLM** *(optional)* | 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)*               | Optional configuration settings for the crew, in `Json` or `Dict[str, Any]` format. |
-| **Max RPM** *(optional)*              | Maximum requests per minute the crew adheres to during execution. |
-| **Language**  *(optional)*            | Language used for the crew, defaults to English.             |
-| **Full Output** *(optional)*          | Whether the crew should return the full output with all tasks outputs or just the final output. |
-| **Step Callback** *(optional)*        | 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** *(optional)*           | 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. |
+| **Config** *(optional)*     | Optional configuration settings for the crew, in `Json` or `Dict[str, Any]` format. |
+| **Max RPM** *(optional)*    | Maximum requests per minute the crew adheres to during execution. |
+| **Language**  *(optional)*  | Language used for the crew, defaults to English.             |
+| **Language File** *(optional)* | Path to the language file to be used for the crew.          |
+| **Memory** *(optional)*     | Utilized for storing execution memories (short-term, long-term, entity memory). |
+| **Cache** *(optional)*      | Specifies whether to use a cache for storing the results of tools' execution. |
+| **Embedder** *(optional)*   | Configuration for the embedder to be used by the crew. mostly used by memory for now       |
+| **Full Output** *(optional)*| Whether the crew should return the full output with all tasks outputs or just the final output. |
+| **Step Callback** *(optional)* | 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)* | A function that is called after the completion of each task. Useful for monitoring or additional operations post-task execution. |
+| **Share Crew** *(optional)* | 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)* | 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 and it will be called logs.txt or passing a string with the full path and name of the file. |
+
 
 !!! 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
 
@@ -71,6 +76,14 @@ my_crew = Crew(
 )
 ```
 
+## 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.

docs/core-concepts/Memory.md

@@ -0,0 +1,171 @@
+---
+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 newly identified 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. |
+| **Long-Term Memory** | Preserves valuable insights and learnings from past executions, allowing agents to build and refine their knowledge over time. |
+| **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, 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

@@ -10,14 +10,14 @@ description: Detailed guide on workflow management through processes in CrewAI,
 ## Process Implementations
 
 - **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. Note: A manager language model (`manager_llm`) must be specified in the crew to enable the hierarchical process, allowing for the creation and management of tasks by the manager.
-- **Consensual Process (Planned)**: Currently under consideration for future development, this process type aims for collaborative decision-making among agents on task execution, introducing a more democratic approach to task management within CrewAI. As of now, it is not implemented in the codebase.
+- **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`) 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 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
-To assign a process to a crew, specify the process type upon crew creation to set the execution strategy. Note: For a hierarchical process, ensure to define `manager_llm` for the manager agent.
+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` for the manager agent.
 
 ```python
 from crewai import Crew
@@ -48,13 +48,15 @@ This method mirrors dynamic team workflows, progressing through tasks in a thoug
 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
-Emulates a corporate hierarchy, crewAI creates a manager automatically for you, requiring the specification of a manager language model (`manager_llm`) for the manager agent. 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.
+Emulates a corporate hierarchy, CrewAI automatically creates a manager for you, requiring the specification of a manager language model (`manager_llm`) for the manager agent. 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.
 
 ## 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`, and future `consensual`). This design choice guarantees that only valid processes are utilized within the CrewAI framework.
+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.
 
-## Planned Future Processes
-- **Consensual Process**: This collaborative decision-making process among agents on task execution is under consideration but not currently implemented. This future enhancement aims to introduce a more democratic approach to task management within CrewAI.
+## 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
-The structured collaboration facilitated by processes within CrewAI is crucial for enabling systematic teamwork among agents. Documentation will be regularly updated to reflect new processes and enhancements, ensuring users have access to the most current and comprehensive information.
+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,32 +1,34 @@
 ---
 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, 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**      | 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)*      | Indicates whether the task should be executed asynchronously, allowing the crew to continue with the next task without waiting for completion. |
-| **Context**  *(optional)*     | Other tasks that will have their output used as context for this task. If a task is asynchronous, the system will wait for that to finish before using its output as context. |
-| **Output JSON**  *(optional)*     | Takes a pydantic model and returns the output as a JSON object. **Agent LLM needs to be using an 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 an 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              | Description                                                                                   |
+| :----------------------| :-------------------------------------------------------------------------------------------- |
+| **Description**        | A clear, concise statement of what the task entails.                                          |
+| **Agent**              | The agent responsible for the task, assigned either directly or by the crew's process.        |
+| **Expected Output**    | A detailed description of what the task's completion looks like.                              |
+| **Tools** *(optional)* | The functions or capabilities the agent can utilize to perform the task.                      |
+| **Async Execution** *(optional)* | If set, the task executes asynchronously, allowing progression without waiting for completion.|
+| **Context**  *(optional)* | Specifies tasks whose outputs are used as context for this task.                              |
+| **Config** *(optional)* | Additional configuration details for the agent executing the task, allowing further customization. |
+| **Output JSON**  *(optional)* | Outputs a JSON object, requiring an OpenAI client. Only one output format can be set.         |
+| **Output Pydantic**  *(optional)* | Outputs a Pydantic model object, requiring an OpenAI client. Only one output format can be set. |
+| **Output File**  *(optional)* | Saves the task output to a file. If used with `Output JSON` or `Output Pydantic`, specifies how the output is saved. |
+| **Callback**  *(optional)* | A Python callable that is executed with the task's output upon completion.                    |
+| **Human Input** *(optional)* | Indicates if the task requires human feedback at the end, useful for tasks needing human oversight. |
 
 ## Creating a Task
 
-This is the simplest 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
@@ -36,12 +38,13 @@ task = Task(
     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
 
@@ -54,12 +57,12 @@ from crewai import Agent, Task, Crew
 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
 )
 
 search_tool = SerperDevTool()
@@ -93,26 +96,26 @@ This is useful when you have a task that depends on the output of another task t
 # ...
 
 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]
+    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]
+    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 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]
+    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]
 )
 
 #...
@@ -128,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 an 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, 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
+    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
 )
 
 #...
@@ -159,20 +162,20 @@ The callback function is executed after the task is completed, allowing for acti
 # ...
 
 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.raw_output}
-	""")
+    # 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
 )
 
 #...
@@ -185,27 +188,27 @@ Once a crew finishes running, you can access the output of a specific task by us
 ```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.raw_output}
+    Task completed!
+    Task: {task1.output.description}
+    Output: {task1.output.raw_output}
 """)
 ```
 

docs/core-concepts/Tools.md

@@ -15,6 +15,8 @@ CrewAI tools empower agents with capabilities ranging from web searching and dat
 - **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
 
@@ -91,34 +93,22 @@ crew.kickoff()
 
 ## Available crewAI Tools
 
-Most of the tools in the crewAI toolkit offer the ability to set specific arguments or let them to be more wide open, this is the case for most of the tools, for example:
+- **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 finner control over the caching mechanism, using `cache_function` attribute on the tool.
 
-```python
-from crewai_tools import DirectoryReadTool
-
-# This will allow the agent with this tool to read any directory it wants during it's execution
-tool = DirectoryReadTool()
-
-# OR
-
-# This will allow the agent with this tool to read only the directory specified during it's execution
-toos = DirectoryReadTool(directory='./directory')
-```
-
-Specific per tool docs are coming soon.
 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.|
+| **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.          |
+| **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.|
 | **SeperDevTool**            | 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.      |
+| **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.    |
@@ -132,9 +122,11 @@ Here is a list of the available tools and their descriptions:
 | **YoutubeVideoSearchTool**  | A RAG tool aimed at searching within YouTube videos, ideal for video data extraction.          |
 
 ## Creating your own Tools
+
 !!! example "Custom Tool Creation"
     Developers can craft custom tools tailored for their agent’s needs or utilize pre-built options:
 
+
 To create your own crewAI tools you will need to install our extra tools package:
 
 ```bash
@@ -142,7 +134,6 @@ pip install 'crewai[tools]'
 ```
 
 Once you do that there are two main ways for one to create a crewAI tool:
-
 ### Subclassing `BaseTool`
 
 ```python
@@ -157,42 +148,44 @@ class MyCustomTool(BaseTool):
         return "Result from custom tool"
 ```
 
-Define a new class inheriting from `BaseTool`, specifying `name`, `description`, and the `_run` method for operational logic.
-
-
 ### Utilizing the `tool` Decorator
 
-For a simpler approach, create a `Tool` object directly with the required attributes and a functional logic.
-
 ```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, you 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
-import json
-import requests
-from crewai import Agent
-from crewai.tools import tool
-from unstructured.partition.html import partition_html
+from crewai_tools import tool
 
-    # Annotate the function with the tool decorator from crewAI
-@tool("Integration with a given API")
-def integration_tool(argument: str) -> str:
-    """Integration with a given API"""
-    # Code here
-    return resutls # string to be sent back to the agent
+@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
 
-# 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=[integration_tool]
-)
+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 lesssons of math for kids.",
+        backstory="You're an expert in writting and you love to teach kids but you know nothing of math.",
+        tools=[multiplcation_tool],
+        allow_delegation=False,
+    )
+    #...
 ```
 
 ## Using LangChain Tools
@@ -228,4 +221,4 @@ agent = Agent(
 ```
 
 ## 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.
+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/how-to/AgentOps-Observability.md

@@ -0,0 +1,72 @@
+---
+title: (AgentOps) Observability using 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 the agent is performing, how users are interacting with the agent, and how the agent is responding to user inputs. 
+
+AgentOps is a product, idependent of crewAI that provides a comprehensive observability solution for agents. 
+
+This notebook will provide an overview of AgentOps and how to use it with crewAI.
+
+## AgentOps
+
+[AgentOps](https://agentops.ai) provides session replays, metrics, and monitoring for agents.
+[AgentOps Repo](https://github.com/AgentOps-AI/agentops)
+
+### Overview
+AgentOps provides monotoring for agents in development and production. It provides a dashboard for monitoring agent performance, session replays, and custom reporting.
+
+![agentops-overview.png](..%2Fassets%2Fagentops-overview.png)
+
+Additionally, AgentOps provides session drilldowns that allows users to view the agent's interactions with users in real-time. This feature is useful for debugging and understanding how the agent interacts with users.
+
+![agentops-session.png](..%2Fassets%2Fagentops-session.png)
+![agentops-replay.png](..%2Fassets%2Fagentops-replay.png)
+
+### Features
+- LLM Cost management and tracking
+- Replay Analytics
+- Recursive thought detection
+- Custom Reporting
+- Analytics Dashboard
+- Public Model Testing
+- Custom Tests
+- Time Travel Debugging
+- Compliance and Security
+
+### Using AgentOps
+
+Create a user API key here: app.agentops.ai/account
+
+Add your API key to your environment variables
+
+```
+AGENTOPS_API_KEY=<YOUR_AGENTOPS_API_KEY>
+```
+
+Install AgentOps with:
+```
+pip install crewai[agentops]
+```
+or
+```
+pip install agentops
+```
+
+Before using `Crew` in your script, include these lines:
+
+```python
+import agentops
+agentops.init()
+```
+
+### 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)
+
+
+### Futher Information
+To implement more features and better observability, please see the [AgentOps Repo](https://github.com/AgentOps-AI/agentops)

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

@@ -1,91 +1,62 @@
 ---
-title: Creating your own Tools
-description: Guide on how to create and use custom tools within the crewAI framework.
+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 your own Tools
-!!! example "Custom Tool Creation"
-    Developers can craft custom tools tailored for their agent’s needs or utilize pre-built options:
+## 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.
 
-To create your own crewAI tools you will need to install our extra tools package:
+### Prerequisites
+Before creating your own tools, ensure you have the crewAI extra tools package installed:
 
 ```bash
 pip install 'crewai[tools]'
 ```
 
-Once you do that there are two main ways for one to create a crewAI tool:
-
 ### 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 = "Clear description for what this tool is useful for, you agent will need this information to use it."
+    description: str = "What this tool does. It's vital for effective utilization."
 
     def _run(self, argument: str) -> str:
-        # Implementation goes here
-        return "Result from custom tool"
+        # Your tool's logic here
+        return "Tool's result"
 ```
 
-Define a new class inheriting from `BaseTool`, specifying `name`, `description`, and the `_run` method for operational logic.
+### Using the `tool` Decorator
 
-
-### Utilizing the `tool` Decorator
-
-For a simpler approach, create a `Tool` object directly with the required attributes and a functional logic.
+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("Name of my tool")
-def my_tool(question: str) -> str:
-    """Clear description for what this tool is useful for, you agent will need this information to use it."""
-    # Function logic here
+
+@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
-import json
-import requests
-from crewai import Agent
-from crewai.tools import tool
-from unstructured.partition.html import partition_html
+@tool("Tool with Caching")
+def cached_tool(argument: str) -> str:
+    """Tool functionality description."""
+    return "Cachable result"
 
-    # Annotate the function with the tool decorator from crewAI
-@tool("Integration with a given API")
-def integtation_tool(argument: str) -> str:
-    """Integration with a given API"""
-    # Code here
-    return resutls # string to be sent back to the agent
+def my_cache_strategy(arguments: dict, result: str) -> bool:
+    # Define custom caching logic
+    return True if some_condition else False
 
-# 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=[integtation_tool]
-)
+cached_tool.cache_function = my_cache_strategy
 ```
 
-
-
-### Using the `Tool` function from langchain
-
-For another simple approach, create a function in python directly with the required attributes and a functional logic.
-
-```python
-def combine(a, b):
-    return a + b
-```
-
-Then you can add that function into the your tool by using 'func' variable in the Tool function.
-
-```python
-from langchain.agents import Tool
-
-math_tool = Tool(
-            name="Math tool",
-            func=math_tool,
-            description="Useful for adding two numbers together, in other words combining them."
-        )
-```
+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,13 +1,14 @@
 ---
 title: Assembling and Activating Your CrewAI Team
-description: A comprehensive guide to creating a dynamic CrewAI team for your projects, with updated functionalities including verbose mode, memory capabilities, and more.
+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, and more.
+
 ---
 
 ## Introduction
-Embark on your CrewAI journey by setting up your environment and initiating your AI crew with enhanced features. This guide ensures a seamless start, incorporating the latest updates.
+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.
 
 ## Step 0: Installation
-Install CrewAI and any necessary packages for your project.
+Install CrewAI and any necessary packages for your project. CrewAI is compatible with Python >=3.10,<=3.13.
 
 ```shell
 pip install crewai
@@ -15,11 +16,11 @@ pip install 'crewai[tools]'
 ```
 
 ## Step 1: Assemble Your Agents
-Define your agents with distinct roles, backstories, and now, enhanced capabilities such as verbose mode and memory usage. These elements add depth and guide their task execution and interaction within the crew.
+Define your agents with distinct roles, backstories, and enhanced capabilities like verbose mode and memory usage. These elements add depth and guide their task execution and interaction within the crew.
 
 ```python
 import os
-os.environ["SERPER_API_KEY"] = "Your Key" # serper.dev API key
+os.environ["SERPER_API_KEY"] = "Your Key"  # serper.dev API key
 os.environ["OPENAI_API_KEY"] = "Your Key"
 
 from crewai import Agent
@@ -68,7 +69,7 @@ research_task = Task(
   description=(
     "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"
+    "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.',
@@ -92,21 +93,25 @@ write_task = Task(
 ```
 
 ## Step 3: Form the Crew
-Combine your agents into a crew, setting the workflow process they'll follow to accomplish the tasks, now with the option to configure language models for enhanced interaction.
+Combine your agents into a crew, setting the workflow process they'll follow to accomplish the tasks. Now with options to configure language models for enhanced interaction and additional configurations for optimizing performance.
 
 ```python
 from crewai import Crew, Process
 
-# Forming the tech-focused crew with enhanced configurations
+# Forming the tech-focused crew with some enhanced configurations
 crew = Crew(
   agents=[researcher, writer],
   tasks=[research_task, write_task],
-  process=Process.sequential  # Optional: Sequential task execution is default
+  process=Process.sequential,  # Optional: Sequential task execution is default
+  memory=True,
+  cache=True,
+  max_rpm=100,
+  share_crew=True
 )
 ```
 
 ## Step 4: Kick It Off
-Initiate the process with your enhanced crew ready. Observe as your agents collaborate, leveraging their new capabilities for a successful project outcome. You can also pass the inputs that will be interpolated into the agents and tasks.
+Initiate the process with your enhanced crew ready. Observe as your agents collaborate, leveraging their new capabilities for a successful project outcome. Input variables will be interpolated into the agents and tasks for a personalized approach.
 
 ```python
 # Starting the task execution process with enhanced feedback
@@ -115,4 +120,4 @@ print(result)
 ```
 
 ## Conclusion
-Building and activating a crew in CrewAI has evolved with new functionalities. By incorporating verbose mode, memory capabilities, asynchronous task execution, output customization, and language model configuration, your AI team is more equipped than ever to tackle challenges efficiently. The depth of agent backstories and the precision of their objectives enrich collaboration, leading to successful project outcomes.
+Building and activating a crew in CrewAI has evolved with new functionalities. By incorporating verbose mode, memory capabilities, asynchronous task execution, output customization, language model configuration, and enhanced crew configurations, your AI team is more equipped than ever to tackle challenges efficiently. The depth of agent backstories and the precision of their objectives enrich collaboration, leading to successful project outcomes. This guide aims to provide you with a clear and detailed understanding of setting up and utilizing the CrewAI framework to its full potential.

docs/how-to/Customizing-Agents.md

@@ -4,7 +4,7 @@ description: A comprehensive guide to tailoring agents for specific roles, tasks
 ---
 
 ## Customizable Attributes
-Crafting an efficient CrewAI team hinges on the ability to tailor your AI agents dynamically to meet the unique requirements of any project. This section covers the foundational attributes you can customize.
+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**: Specifies the agent's job within the crew, such as 'Analyst' or 'Customer Service Rep'.
@@ -16,24 +16,20 @@ Crafting an efficient CrewAI team hinges on the ability to tailor your AI agents
 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.
-By default crewAI agents are ReAct agents, but by setting the `function_calling_llm` you can turn them into a function calling agents.
-
-### Enabling Memory for Agents
-CrewAI supports memory for agents, enabling them to remember past interactions. This feature is critical for tasks requiring awareness of previous contexts or decisions.
+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`), controlling the agent's query frequency to external services.
+- **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 15, providing a balance between thoroughness and efficiency. Once the agent approaches this number it will try it's best to give a good answer.
+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 15, 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 and tools during initialization. Tools are critical for an agent's functionality, enabling them to perform specialized tasks. In this example we will use the crewAI tools package to create a tool for a research analyst agent.
+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]'
@@ -58,16 +54,16 @@ agent = Agent(
   goal='Provide up-to-date market analysis',
   backstory='An expert analyst with a keen eye for market trends.',
   tools=[search_tool],
-  memory=True,
+  memory=True, # Enable memory
   verbose=True,
-  max_rpm=10, # Optional: Limit requests to 10 per minute, preventing API abuse
-  max_iter=5, # Optional: Limit task iterations to 5 before the agent tries to give its best answer
+  max_rpm=None, # No limit on requests per minute
+  max_iter=15, # Default value for maximum iterations
   allow_delegation=False
 )
 ```
 
 ## Delegation and Autonomy
-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.
+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
@@ -75,7 +71,7 @@ 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
 )
 ```
 

docs/how-to/Hierarchical.md

@@ -21,7 +21,7 @@ By default, tasks in CrewAI are managed through a sequential process. However, a
 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 and Agent Assignment"
-    Assign tools at the agent level to facilitate task delegation and execution by the designated agents under the manager's guidance.
+    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 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.
@@ -30,32 +30,38 @@ To utilize the hierarchical process, it's essential to explicitly set the proces
 from langchain_openai import ChatOpenAI
 from crewai import Crew, Process, Agent
 
-# Agents are defined with an optional tools parameter
+# Agents are defined with attributes for backstory, cache, and verbose mode
 researcher = Agent(
     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',
+    backstory='Creative writer passionate about storytelling in technical domains.',
+    cache=True,
+    verbose=False,
     # tools=[]  # Optionally specify tools; defaults to an empty list
 )
 
-# Establishing the crew with a hierarchical process
+# Establishing the crew with a hierarchical process and additional configurations
 project_crew = Crew(
     tasks=[...],  # Tasks to be delegated and executed under the manager's supervision
     agents=[researcher, writer],
     manager_llm=ChatOpenAI(temperature=0, model="gpt-4"),  # Mandatory for hierarchical process
-    process=Process.hierarchical  # Specifies the hierarchical management approach
+    process=Process.hierarchical,  # Specifies the hierarchical management approach
+    memory=True,  # Enable memory usage for enhanced task execution
 )
 ```
 
 ### Workflow in Action
-1. **Task Assignment**: The manager assigns tasks strategically, considering each agent's capabilities.
-2. **Execution and Review**: Agents complete their tasks, with the manager ensuring quality standards.
+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
 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.

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

@@ -1,21 +1,20 @@
 ---
 title: Human Input on Execution
-description: Comprehensive guide on integrating CrewAI with human input during execution in complex decision-making processes or when needed help during complex tasks. 
+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 Input in Agent Execution
 
-Human input plays a pivotal role in several agent execution scenarios, enabling agents to seek additional information or clarification when necessary. This capability is invaluable in complex decision-making processes or when agents need more details to complete a task effectively.
+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
 
-Incorporating human input with CrewAI is straightforward, enhancing the agent's ability to make informed decisions. While the documentation previously mentioned using a "LangChain Tool" and a specific "DuckDuckGoSearchRun" tool from `langchain_community.tools`, it's important to clarify that the integration of such tools should align with the actual capabilities and configurations defined within your `Agent` class setup.
+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
-pip install 'crewai[tools]'
 ```
 
 ```python
@@ -23,17 +22,13 @@ import os
 from crewai import Agent, Task, Crew
 from crewai_tools import SerperDevTool
 
-from langchain.agents import load_tools
-
 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, goals, and tools
+# 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',
@@ -44,7 +39,8 @@ researcher = Agent(
   ),
   verbose=True,
   allow_delegation=False,
-  tools=[search_tool]+human_tools # Passing human tools to the agent
+  tools=[search_tool],
+  max_rpm=100
 )
 writer = Agent(
   role='Tech Content Strategist',
@@ -54,7 +50,9 @@ writer = Agent(
     "With a deep understanding of the tech industry, you transform complex concepts into compelling narratives."
   ),
   verbose=True,
-  allow_delegation=True
+  allow_delegation=True,
+  tools=[search_tool],
+  cache=False, # Disable cache for this agent
 )
 
 # Create tasks for your agents
@@ -67,6 +65,7 @@ task1 = Task(
   ),
   expected_output='A comprehensive full report on the latest AI advancements in 2024, leave nothing out',
   agent=researcher,
+  human_input=True,
 )
 
 task2 = Task(
@@ -91,4 +90,4 @@ result = crew.kickoff()
 
 print("######################")
 print(result)
-```
+```

docs/how-to/LLM-Connections.md

@@ -5,7 +5,7 @@ description: Comprehensive guide on integrating CrewAI with various Large Langua
 
 ## 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 through environment variables and direct instantiation.
+    By default, CrewAI uses OpenAI's GPT-4 model for language processing. You can configure your agents to use a different model or API. This guide shows how to connect your agents to various LLMs through environment variables and direct instantiation.
 
 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.
 
@@ -16,15 +16,16 @@ The `Agent` class is the cornerstone for implementing AI solutions in CrewAI. He
     - `role`: Defines the agent's role within the solution.
     - `goal`: Specifies the agent's objective.
     - `backstory`: Provides a background story to the agent.
-    - `llm`: Indicates the Large Language Model the agent uses.
-    - `function_calling_llm` *Optinal*: Will turn the ReAct crewAI agent into a function calling agent.
+    - `llm`: The language model that will run the agent. By default, it uses the GPT-4 model defined in the environment variable "OPENAI_MODEL_NAME".
+    - `function_calling_llm`: The language model that will handle the tool calling for this agent, overriding the crew function_calling_llm. Optional.
     - `max_iter`: Maximum number of iterations for an agent to execute a task, default is 15.
-    - `memory`: Enables the agent to retain information during the execution.
-    - `max_rpm`: Sets the maximum number of requests per minute.
-    - `verbose`: Enables detailed logging of the agent's execution.
+    - `memory`: Enables the agent to retain information during and a across executions. Default is `False`.
+    - `max_rpm`: Maximum number of requests per minute the agent's execution should respect. Optional.
+    - `verbose`: Enables detailed logging of the agent's execution. Default is `False`.
     - `allow_delegation`: Allows the agent to delegate tasks to other agents, default is `True`.
-    - `tools`: Specifies the tools available to the agent for task execution.
-    - `step_callback`: Provides a callback function to be executed after each step.
+    - `tools`: Specifies the tools available to the agent for task execution. Optional.
+    - `step_callback`: Provides a callback function to be executed after each step. Optional.
+    - `cache`: Determines whether the agent should use a cache for tool usage. Default is `True`.
 
 ```python
 # Required
@@ -35,7 +36,8 @@ example_agent = Agent(
   role='Local Expert',
   goal='Provide insights about the city',
   backstory="A knowledgeable local guide.",
-  verbose=True
+  verbose=True,
+  memory=True
 )
 ```
 
@@ -50,6 +52,39 @@ OPENAI_MODEL_NAME='openhermes'  # Adjust based on available model
 OPENAI_API_KEY=''
 ```
 
+## 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
 Switch between APIs and models seamlessly using environment variables, supporting platforms like FastChat, LM Studio, and Mistral AI.
 
@@ -75,6 +110,35 @@ OPENAI_API_BASE=https://api.mistral.ai/v1
 OPENAI_MODEL_NAME="mistral-small"
 ```
 
+### Solar
+```sh
+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
+```sh
+OPENAI_API_BASE=http://localhost:5000/v1
+OPENAI_MODEL_NAME=NA
+OPENAI_API_KEY=NA
+```
+
+### Cohere
+```sh
+from langchain_community.chat_models import ChatCohere
+# Initialize language model
+os.environ["COHERE_API_KEY"] = "your-cohere-api-key"
+llm = ChatCohere()
+
+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

docs/how-to/Sequential.md

@@ -1,6 +1,6 @@
 ---
 title: Using the Sequential Processes in crewAI
-description: A comprehensive guide to utilizing the sequential processe for task execution in crewAI projects.
+description: A comprehensive guide to utilizing the sequential processes for task execution in crewAI projects.
 ---
 
 ## Introduction
@@ -13,8 +13,6 @@ The sequential process ensures tasks are executed one after the other, following
 - **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
 Assemble your crew and define tasks in the order they need to be executed.
 
@@ -57,4 +55,4 @@ report_crew = Crew(
 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.
+The sequential and hierarchical processes in CrewAI offer clear, adaptable paths for task execution. They are well-suited for projects requiring logical progression and dynamic decision-making, ensuring each step is completed effectively, thereby facilitating a cohesive final product.

docs/index.md

@@ -33,6 +33,11 @@ Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By
                     Crews
                 </a>
             </li>
+            <li>
+                <a href="./core-concepts/Memory">
+                    Memory
+                </a>
+            </li>
         </ul>
     </div>
     <div style="width:30%">
@@ -73,6 +78,11 @@ Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By
                     Human Input on Execution
                 </a>
             </li>
+            <li>
+                <a href="./how-to/AgentOps-Observability.md">
+                    Agent Observability using AgentOps
+                </a>
+            </li>
         </ul>
     </div>
     <div style="width:30%">
@@ -115,4 +125,4 @@ Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By
             </li>
         </ul>
     </div>
-</div>
+</div>

docs/telemetry/Telemetry.md

@@ -21,7 +21,7 @@ It's pivotal to understand that **NO data is collected** concerning prompts, tas
 - **Tool Usage**: Identifying which tools are most frequently used allows us to prioritize improvements in those areas.
 
 ### 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.
+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.
+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/CSVSearchTool.md

@@ -1,8 +1,5 @@
 # CSVSearchTool
 
-!!! note "Depend on OpenAI"
-    All RAG tools at the moment can only use openAI to generate embeddings, we are working on adding support for other providers.
-
 !!! note "Experimental"
     We are still working on improving tools, so there might be unexpected behavior or changes in the future.
 
@@ -34,4 +31,32 @@ 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.
+- `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",
+            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 = 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",
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/DOCXSearchTool.md

@@ -1,8 +1,5 @@
 # DOCXSearchTool
 
-!!! note "Depend on OpenAI"
-    All RAG tools at the moment can only use openAI to generate embeddings, we are working on adding support for other providers.
-
 !!! note "Experimental"
     We are still working on improving tools, so there might be unexpected behavior or changes in the future.
 
@@ -33,3 +30,31 @@ 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",
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/DirectoryReadTool.md

@@ -1,22 +1,23 @@
+```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 highly efficient utility designed for the comprehensive listing of directory contents. It recursively navigates through the specified directory, providing users with a detailed enumeration of all files, including those nested within subdirectories. This tool is indispensable for tasks requiring a thorough inventory of directory structures or for validating the organization of files within directories.
+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
-Install the `crewai_tools` package to use the DirectoryReadTool in your project. If you haven't added this package to your environment, you can easily install it with pip using the following command:
+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 installs the latest version of the `crewai_tools` package, allowing access to the DirectoryReadTool and other utilities.
+This command installs the latest version of the `crewai_tools` package, granting access to the DirectoryReadTool among other utilities.
 
 ## Example
-The DirectoryReadTool is simple to use. The code snippet below shows how to set up and use the tool to list the contents of a specified directory:
+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
@@ -33,4 +34,4 @@ 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** A 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.
+- `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

@@ -1,33 +1,55 @@
 # DirectorySearchTool
 
-!!! note "Depend on OpenAI"
-    All RAG tools at the moment can only use openAI to generate embeddings, we are working on adding support for other providers.
-
 !!! note "Experimental"
-    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+    The DirectorySearchTool is under continuous development. Features and functionalities might evolve, and unexpected behavior may occur as we refine the tool.
 
 ## Description
-This tool is designed to perform a semantic search for queries within the content of a specified directory. Utilizing the RAG (Retrieval-Augmented Generation) methodology, it offers a powerful means to semantically navigate through the files of a given directory. The tool can be dynamically set to search any directory specified at runtime or can be pre-configured to search within a specific directory upon initialization.
+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 start using the DirectorySearchTool, you need to install the crewai_tools package. Execute the following command in your terminal:
+To use the DirectorySearchTool, begin by installing the crewai_tools package. Execute the following command in your terminal:
 
 ```shell
 pip install 'crewai[tools]'
 ```
 
-## Example
-The following examples demonstrate how to initialize the DirectorySearchTool for different use cases and how to perform a search:
+## 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
 
-# To enable searching within any specified directory at runtime
+# For dynamic directory specification at runtime
 tool = DirectorySearchTool()
 
-# Alternatively, to restrict searches to a specific directory
+# For fixed directory searches
 tool = DirectorySearchTool(directory='/path/to/directory')
 ```
 
 ## Arguments
-- `directory` : This string argument specifies the directory within which to search. It is mandatory if the tool has not been initialized with a directory; otherwise, the tool will only search within the initialized directory.
+- `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",
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/FileReadTool.md

@@ -4,16 +4,16 @@
     We are still working on improving tools, so there might be unexpected behavior or changes in the future.
 
 ## Description
-The FileReadTool is a versatile component of the crewai_tools package, designed to streamline the process of reading and retrieving content from files. It is particularly useful in scenarios such as batch text file processing, runtime configuration file reading, and data importation for analytics. This tool supports various text-based file formats including `.txt`, `.csv`, `.json` and more, and adapts its functionality based on the file type, for instance, converting JSON content into a Python dictionary for easy use.
+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
-Install the crewai_tools package to use the FileReadTool in your projects:
+To utilize the functionalities previously attributed to the FileReadTool, install the crewai_tools package:
 
 ```shell
 pip install 'crewai[tools]'
 ```
 
-## Example
+## Usage Example
 To get started with the FileReadTool:
 
 ```python

docs/tools/GitHubSearchTool.md

@@ -1,42 +1,67 @@
-# GitHubSearchTool
-
-!!! note "Depend on OpenAI"
-    All RAG tools at the moment can only use openAI to generate embeddings, we are working on adding support for other providers.
+# 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 Read, Append, and Generate (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.
+The GithubSearchTool is a Read, Append, and Generate (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:
+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.
+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:
+Here’s how you can use the GithubSearchTool to perform semantic searches within a GitHub repository:
 ```python
-from crewai_tools import GitHubSearchTool
+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
+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
+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",
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/JSONSearchTool.md

@@ -1,33 +1,60 @@
 # JSONSearchTool
 
-!!! note "Depend on OpenAI"
-    All RAG tools at the moment can only use openAI to generate embeddings, we are working on adding support for other providers.
-
-!!! note "Experimental"
-    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+!!! 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
-This tool is used to perform a RAG search within a JSON file's content. It allows users to initiate a search with a specific JSON path, focusing the search operation within that particular JSON file. If the path is provided at initialization, the tool restricts its search scope to the specified JSON file, thereby enhancing the precision of search results.
+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
-Install the crewai_tools package by executing the following command in your terminal:
+To install the JSONSearchTool, use the following pip command:
 
 ```shell
 pip install 'crewai[tools]'
 ```
 
-## Example
-Below are examples demonstrating how to use the JSONSearchTool for searching within JSON files. You can either search any JSON content or restrict the search to a specific JSON file.
+## 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_tools import JSONSearchTool
+from crewai.json_tools import JSONSearchTool  # Updated import path
 
-# Example 1: Initialize the tool for a general search across any JSON content. This is useful when the path is known or can be discovered during execution.
+# General JSON content search
+# This approach is suitable when the JSON path is either known beforehand or can be dynamically identified.
 tool = JSONSearchTool()
 
-# Example 2: Initialize the tool with a specific JSON path, limiting the search to a particular JSON file.
+# 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): An optional argument that defines the path to the JSON file to be searched. This parameter is only necessary if the tool is initialized without a specific JSON path. Providing this argument restricts the search to the specified JSON file.
+- `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",
+            "config": {
+                "model": "models/embedding-001",
+                "task_type": "retrieval_document",
+                # Further customization options can be added here.
+            },
+        },
+    }
+)
+```

docs/tools/MDXSearchTool.md

@@ -1,35 +1,62 @@
 # MDXSearchTool
 
-!!! note "Depend on OpenAI"
-    All RAG tools at the moment can only use openAI to generate embeddings, we are working on adding support for other providers.
-
 !!! note "Experimental"
-    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+    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, a key component of the `crewai_tools` package, is designed for advanced market data extraction, offering invaluable support to researchers and analysts requiring immediate market insights in the AI sector. With its ability to interface with various data sources and tools, it streamlines the process of acquiring, reading, and organizing market data efficiently.
+The MDX Search Tool is a component of the `crewai_tools` package aimed at facilitating advanced market data extraction. This tool is invaluable for researchers and analysts seeking quick access to market insights, especially within the AI sector. It simplifies the task of acquiring, interpreting, and organizing market data by interfacing with various data sources.
 
 ## Installation
-To utilize the MDX Search Tool, ensure the `crewai_tools` package is installed. If not already present, install it using the following command:
+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]'
 ```
 
-## Example
-Configuring and using the MDX Search Tool involves setting up environment variables and utilizing the tool within a crewAI project for market research. Here's a simple example:
+## 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 so the agent can search any MDX content if it learns about during its execution
+# 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 exclusive search within that document
+# Initialize the tool with a specific MDX file path for an exclusive search within that document
 tool = MDXSearchTool(mdx='path/to/your/document.mdx')
 ```
 
-## Arguments
-- mdx: **Optional** The MDX path for the search. Can be provided at initialization
+## 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",
+            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

@@ -1,8 +1,5 @@
 # PDFSearchTool
 
-!!! note "Depend on OpenAI"
-    All RAG tools at the moment can only use openAI to generate embeddings, we are working on adding support for other providers.
-
 !!! note "Experimental"
     We are still working on improving tools, so there might be unexpected behavior or changes in the future.
 
@@ -33,3 +30,31 @@ tool = PDFSearchTool(pdf='path/to/your/document.pdf')
 
 ## Arguments
 - `pdf`: **Optinal** 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",
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/PGSearchTool.md

@@ -1,34 +1,60 @@
 # PGSearchTool
 
-!!! note "Depend on OpenAI"
-    All RAG tools at the moment can only use openAI to generate embeddings, we are working on adding support for other providers.
-
-!!! note "Experimental"
-    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+!!! 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
-This tool is designed to facilitate semantic searches within PostgreSQL database tables. Leveraging the RAG (Retrieve and Generate) technology, the PGSearchTool provides users with an efficient means of querying database table content, specifically tailored for PostgreSQL databases. It simplifies the process of finding relevant data through semantic search queries, making it an invaluable resource for users needing to perform advanced queries on extensive datasets within a PostgreSQL database.
+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
-To install the `crewai_tools` package and utilize the PGSearchTool, execute the following command in your terminal:
+The `crewai_tools` package, which will include the PGSearchTool upon its release, can be installed using the following command:
 
 ```shell
 pip install 'crewai[tools]'
 ```
 
-## Example
-Below is an example showcasing how to use the PGSearchTool to conduct a semantic search on a table within a PostgreSQL database:
+(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
+rom 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 requires the following arguments for its operation:
+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 is 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 is mandatory.
+- `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",
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/ScrapeWebsiteTool.md

@@ -1,8 +1,5 @@
 # ScrapeWebsiteTool
 
-!!! note "Depend on OpenAI"
-    All RAG tools at the moment can only use openAI to generate embeddings, we are working on adding support for other providers.
-
 !!! note "Experimental"
     We are still working on improving tools, so there might be unexpected behavior or changes in the future.
 
@@ -24,7 +21,11 @@ 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.
+- `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

@@ -1,36 +1,44 @@
 # SeleniumScrapingTool
 
 !!! note "Experimental"
-    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+    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
-This tool is designed for efficient web scraping, enabling users to extract content from web pages. It supports targeted scraping by allowing the specification of a CSS selector for desired elements. The flexibility of the tool enables it to be used on any website URL provided by the user, making it a versatile tool for various web scraping needs.
+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
-Install the crewai_tools package
+To get started with the SeleniumScrapingTool, install the crewai_tools package using pip:
+
 ```
 pip install 'crewai[tools]'
 ```
 
-## Example
+## Usage Examples
+Below are some scenarios where the SeleniumScrapingTool can be utilized:
+
 ```python
 from crewai_tools import SeleniumScrapingTool
 
-# Example 1: Scrape any website it finds during its execution
+# Example 1: Initialize the tool without any parameters to scrape the current page it navigates to
 tool = SeleniumScrapingTool()
 
-# Example 2: Scrape the entire webpage
+# Example 2: Scrape the entire webpage of a given URL
 tool = SeleniumScrapingTool(website_url='https://example.com')
 
-# Example 3: Scrape a specific CSS element from the webpage
+# 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: Scrape using optional parameters for customized scraping
-tool = SeleniumScrapingTool(website_url='https://example.com', css_element='.main-content', cookie={'name': 'user', 'value': 'John Doe'})
+# 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
-- `website_url`: Mandatory. The URL of the website to scrape.
-- `css_element`: Mandatory. The CSS selector for a specific element to scrape from the website.
-- `cookie`: Optional. A dictionary containing cookie information. This parameter allows the tool to simulate a session with cookie information, providing access to content that may be restricted to logged-in users.
-- `wait_time`: Optional. The number of seconds the tool waits after loading the website and after setting a cookie, before scraping the content. This allows for dynamic content to load properly.
+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/TXTSearchTool.md

@@ -1,8 +1,5 @@
 # TXTSearchTool
 
-!!! note "Depend on OpenAI"
-    All RAG tools at the moment can only use openAI to generate embeddings, we are working on adding support for other providers.
-
 !!! note "Experimental"
     We are still working on improving tools, so there might be unexpected behavior or changes in the future.
 
@@ -35,3 +32,31 @@ tool = TXTSearchTool(txt='path/to/text/file.txt')
 
 ## Arguments
 - `txt` (str): **Optinal**. 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",
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/WebsiteSearchTool.md

@@ -1,35 +1,60 @@
 # WebsiteSearchTool
 
-!!! note "Depend on OpenAI"
-    All RAG tools at the moment can only use openAI to generate embeddings, we are working on adding support for other providers.
-
-!!! note "Experimental"
-    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+!!! 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
-This tool is specifically crafted for conducting semantic searches within the content of a particular website. Leveraging a Retrieval-Augmented Generation (RAG) model, it navigates through the information provided on a given URL. Users have the flexibility to either initiate a search across any website known or discovered during its usage or to concentrate the search on a predefined, specific website.
+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
-Install the crewai_tools package by executing the following command in your terminal:
+To prepare your environment for when the WebsiteSearchTool becomes available, you can install the foundational package with:
 
 ```shell
 pip install 'crewai[tools]'
 ```
 
-## Example
-To utilize the WebsiteSearchTool for different use cases, follow these examples:
+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
 
-# To enable the tool to search any website the agent comes across or learns about during its operation
+# Example of initiating tool that agents can use to search across any discovered websites
 tool = WebsiteSearchTool()
 
-# OR
-
-# To restrict the tool to only search within the content of a specific website.
+# 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 that specifies the valid website URL to perform the search on. This becomes necessary if the tool is initialized without a specific website. In the `WebsiteSearchToolSchema`, this argument is mandatory. However, in the `FixedWebsiteSearchToolSchema`, it becomes optional if a website is provided during the tool's initialization, as it will then only search within the predefined website's content.
+- `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",
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/XMLSearchTool copy.md

@@ -1,35 +0,0 @@
-# XMLSearchTool
-
-!!! note "Depend on OpenAI"
-    All RAG tools at the moment can only use openAI to generate embeddings, we are working on adding support for other providers.
-
-!!! 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.tools.xml_search_tool 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.

docs/tools/XMLSearchTool.md

@@ -1,8 +1,5 @@
 # XMLSearchTool
 
-!!! note "Depend on OpenAI"
-    All RAG tools at the moment can only use openAI to generate embeddings, we are working on adding support for other providers.
-
 !!! note "Experimental"
     We are still working on improving tools, so there might be unexpected behavior or changes in the future.
 
@@ -33,3 +30,31 @@ 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",
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/YoutubeChannelSearchTool.md

@@ -1,8 +1,5 @@
 # YoutubeChannelSearchTool
 
-!!! note "Depend on OpenAI"
-    All RAG tools at the moment can only use openAI to generate embeddings, we are working on adding support for other providers.
-
 !!! note "Experimental"
     We are still working on improving tools, so there might be unexpected behavior or changes in the future.
 
@@ -33,3 +30,31 @@ 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",
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

docs/tools/YoutubeVideoSearchTool.md

@@ -1,8 +1,5 @@
 # YoutubeVideoSearchTool
 
-!!! note "Depend on OpenAI"
-    All RAG tools at the moment can only use openAI to generate embeddings, we are working on adding support for other providers.
-
 !!! note "Experimental"
     We are still working on improving tools, so there might be unexpected behavior or changes in the future.
 
@@ -31,8 +28,37 @@ 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.
+- `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",
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+                # title="Embeddings",
+            ),
+        ),
+    )
+)
+```

mkdocs.yml

@@ -126,6 +126,7 @@ nav:
     - Processes: 'core-concepts/Processes.md'
     - Crews: 'core-concepts/Crews.md'
     - Collaboration: 'core-concepts/Collaboration.md'
+    - Memory: 'core-concepts/Memory.md'
   - How to Guides:
     - Getting Started: 'how-to/Creating-a-Crew-and-kick-it-off.md'
     - Create Custom Tools: 'how-to/Create-Custom-Tools.md'
@@ -134,6 +135,7 @@ nav:
     - Connecting to any LLM: 'how-to/LLM-Connections.md'
     - Customizing Agents: 'how-to/Customizing-Agents.md'
     - Human Input on Execution: 'how-to/Human-Input-on-Execution.md'
+    - Agent Observability using AgentOps: 'how-to/AgentOps-Observability.md'
   - Tools Docs:
     - Google Serper Search: 'tools/SerperDevTool.md'
     - Scrape Website: 'tools/ScrapeWebsiteTool.md'
@@ -153,7 +155,7 @@ nav:
     - Github RAG Search: 'tools/GitHubSearchTool.md'
     - Code Docs RAG Search: 'tools/CodeDocsSearchTool.md'
     - Youtube Video RAG Search: 'tools/YoutubeVideoSearchTool.md'
-    - Youtube Chanel RAG Search: 'tools/YoutubeChannelSearchTool.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"
@@ -179,4 +181,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,6 +1,6 @@
 [tool.poetry]
 name = "crewai"
-version = "0.22.5"
+version = "0.28.5"
 description = "Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks."
 authors = ["Joao Moura <joao@crewai.com>"]
 readme = "README.md"
@@ -18,15 +18,16 @@ python = ">=3.10,<=3.13"
 pydantic = "^2.4.2"
 langchain = "^0.1.10"
 openai = "^1.13.3"
-langchain-openai = "^0.0.5"
 opentelemetry-api = "^1.22.0"
 opentelemetry-sdk = "^1.22.0"
 opentelemetry-exporter-otlp-proto-http = "^1.22.0"
 instructor = "^0.5.2"
 regex = "^2023.12.25"
-crewai-tools = { version = "^0.0.15", optional = true }
+crewai-tools = { version = "^0.1.6", optional = true }
 click = "^8.1.7"
 python-dotenv = "1.0.0"
+embedchain = "^0.1.98"
+appdirs = "^1.4.4"
 
 [tool.poetry.extras]
 tools = ["crewai-tools"]
@@ -34,7 +35,6 @@ tools = ["crewai-tools"]
 [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"}
 autoflake = "^2.2.1"
 pre-commit = "^3.6.0"
 mkdocs = "^1.4.3"
@@ -44,12 +44,13 @@ mkdocs-material = {extras = ["imaging"], version = "^9.5.7"}
 mkdocs-material-extensions = "^1.3.1"
 pillow = "^10.2.0"
 cairosvg = "^2.7.1"
-crewai_tools = "^0.0.15"
+crewai-tools = "^0.1.6"
 
 [tool.isort]
 profile = "black"
 known_first_party = ["crewai"]
 
+
 [tool.poetry.group.test.dependencies]
 pytest = "^8.0.0"
 pytest-vcr = "^1.0.2"

src/crewai/agent.py

@@ -4,7 +4,6 @@ from typing import Any, Dict, List, Optional, Tuple
 
 from langchain.agents.agent import RunnableAgent
 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
@@ -22,6 +21,7 @@ from pydantic import (
 from pydantic_core import PydanticCustomError
 
 from crewai.agents import CacheHandler, CrewAgentExecutor, CrewAgentParser, ToolsHandler
+from crewai.memory.contextual.contextual_memory import ContextualMemory
 from crewai.utilities import I18N, Logger, Prompts, RPMController
 from crewai.utilities.token_counter_callback import TokenCalcHandler, TokenProcess
 
@@ -66,6 +66,10 @@ class Agent(BaseModel):
     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,
@@ -74,9 +78,6 @@ class Agent(BaseModel):
         default=None,
         description="Maximum number of requests per minute for the agent execution to be respected.",
     )
-    memory: bool = Field(
-        default=False, description="Whether the agent should have memory or not"
-    )
     verbose: bool = Field(
         default=False, description="Verbose mode for the Agent Execution"
     )
@@ -87,16 +88,21 @@ class Agent(BaseModel):
         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"
+        default=25, description="Maximum iterations for an agent to execute a task"
+    )
+    max_execution_time: Optional[int] = Field(
+        default=None,
+        description="Maximum execution time for an agent to execute a task",
     )
     agent_executor: InstanceOf[CrewAgentExecutor] = Field(
         default=None, description="An instance of the CrewAgentExecutor class."
     )
+    crew: Any = Field(default=None, description="Crew to which the agent belongs.")
     tools_handler: InstanceOf[ToolsHandler] = Field(
         default=None, description="An instance of the ToolsHandler class."
     )
     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,
@@ -116,6 +122,10 @@ class Agent(BaseModel):
         default=None, description="Callback to be executed"
     )
 
+    _original_role: str | None = None
+    _original_goal: str | None = None
+    _original_backstory: str | None = None
+
     def __init__(__pydantic_self__, **data):
         config = data.pop("config", {})
         super().__init__(**config, **data)
@@ -150,10 +160,15 @@ class Agent(BaseModel):
     def set_agent_executor(self) -> "Agent":
         """set agent executor is set."""
         if hasattr(self.llm, "model_name"):
-            self.llm.callbacks = [
-                TokenCalcHandler(self.llm.model_name, self._token_process)
-            ]
+            token_handler = TokenCalcHandler(self.llm.model_name, self._token_process)
+            if isinstance(self.llm.callbacks, list):
+                self.llm.callbacks.append(token_handler)
+            else:
+                self.llm.callbacks = [token_handler]
+
         if not self.agent_executor:
+            if not self.cache_handler:
+                self.cache_handler = CacheHandler()
             self.set_cache_handler(self.cache_handler)
         return self
 
@@ -173,7 +188,8 @@ class Agent(BaseModel):
         Returns:
             Output of the agent
         """
-        self.tools_handler.last_used_tool = {}
+        if self.tools_handler:
+            self.tools_handler.last_used_tool = {}
 
         task_prompt = task.prompt()
 
@@ -182,13 +198,25 @@ class Agent(BaseModel):
                 task=task_prompt, context=context
             )
 
-        tools = self._parse_tools(tools or self.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)
+
+        tools = tools or self.tools
+        parsed_tools = self._parse_tools(tools)
+
         self.create_agent_executor(tools=tools)
-        self.agent_executor.tools = tools
+        self.agent_executor.tools = parsed_tools
         self.agent_executor.task = task
 
-        self.agent_executor.tools_description = render_text_description(tools)
-        self.agent_executor.tools_names = self.__tools_names(tools)
+        self.agent_executor.tools_description = render_text_description(parsed_tools)
+        self.agent_executor.tools_names = self.__tools_names(parsed_tools)
 
         result = self.agent_executor.invoke(
             {
@@ -209,8 +237,10 @@ class Agent(BaseModel):
         Args:
             cache_handler: An instance of the CacheHandler class.
         """
-        self.cache_handler = cache_handler
-        self.tools_handler = ToolsHandler(cache=self.cache_handler)
+        self.tools_handler = ToolsHandler()
+        if self.cache:
+            self.cache_handler = cache_handler
+            self.tools_handler.cache = cache_handler
         self.create_agent_executor()
 
     def set_rpm_controller(self, rpm_controller: RPMController) -> None:
@@ -243,10 +273,14 @@ class Agent(BaseModel):
         executor_args = {
             "llm": self.llm,
             "i18n": self.i18n,
+            "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,
@@ -258,15 +292,7 @@ class Agent(BaseModel):
                 "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["memory"] = summary_memory
-            agent_args["chat_history"] = lambda x: x["chat_history"]
-            prompt = Prompts(i18n=self.i18n, tools=tools).task_execution_with_memory()
-        else:
-            prompt = Prompts(i18n=self.i18n, tools=tools).task_execution()
+        prompt = Prompts(i18n=self.i18n, tools=tools).task_execution()
 
         execution_prompt = prompt.partial(
             goal=self.goal,
@@ -282,10 +308,17 @@ class Agent(BaseModel):
 
     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.role.format(**inputs)
-            self.goal = self.goal.format(**inputs)
-            self.backstory = self.backstory.format(**inputs)
+            self.role = self._original_role.format(**inputs)
+            self.goal = self._original_goal.format(**inputs)
+            self.backstory = self._original_backstory.format(**inputs)
 
     def increment_formatting_errors(self) -> None:
         """Count the formatting errors of the agent."""

src/crewai/agents/executor.py

@@ -1,3 +1,4 @@
+import threading
 import time
 from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
 
@@ -12,17 +13,26 @@ from langchain_core.utils.input import get_color_mapping
 from pydantic import InstanceOf
 
 from crewai.agents.tools_handler import ToolsHandler
+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.tools.tool_usage import ToolUsage, ToolUsageErrorException
 from crewai.utilities import I18N
+from crewai.utilities.converter import ConverterError
+from crewai.utilities.evaluators.task_evaluator import TaskEvaluator
 
 
 class CrewAgentExecutor(AgentExecutor):
     _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
@@ -41,6 +51,51 @@ class CrewAgentExecutor(AgentExecutor):
             self.iterations == self.force_answer_max_iterations
         ) and not self.have_forced_answer
 
+    def _create_short_term_memory(self, output) -> None:
+        if (
+            self.crew
+            and self.crew.memory
+            and "Action: Delegate work to co-worker" not in output.log
+        ):
+            memory = ShortTermMemoryItem(
+                data=output.log,
+                agent=self.crew_agent.role,
+                metadata={
+                    "observation": self.task.description,
+                },
+            )
+            self.crew._short_term_memory.save(memory)
+
+    def _create_long_term_memory(self, output) -> None:
+        if self.crew and self.crew.memory:
+            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)
+
     def _call(
         self,
         inputs: Dict[str, str],
@@ -51,13 +106,18 @@ 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():
@@ -68,16 +128,21 @@ class CrewAgentExecutor(AgentExecutor):
                     intermediate_steps,
                     run_manager=run_manager,
                 )
-
                 if self.step_callback:
                     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
@@ -86,11 +151,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(
@@ -114,6 +181,7 @@ class CrewAgentExecutor(AgentExecutor):
                 return
 
             intermediate_steps = self._prepare_intermediate_steps(intermediate_steps)
+
             # Call the LLM to see what to do.
             output = self.agent.plan(
                 intermediate_steps,
@@ -147,8 +215,10 @@ class CrewAgentExecutor(AgentExecutor):
             else:
                 raise ValueError("Got unexpected type of `handle_parsing_errors`")
             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,
@@ -169,19 +239,39 @@ 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:
+                # Making sure we only ask for it once, so disabling for the next thought loop
+                self.should_ask_for_human_input = False
+                human_feedback = self._ask_human_input(output.return_values["output"])
+                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:
+                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,
+                original_tools=self.original_tools,
                 tools_description=self.tools_description,
                 tools_names=self.tools_names,
                 function_calling_llm=self.function_calling_llm,
@@ -193,13 +283,20 @@ class CrewAgentExecutor(AgentExecutor):
             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 _ask_human_input(self, final_answer: dict) -> str:
+        """Get human input."""
+        return input(
+            self._i18n.slice("getting_input").format(final_answer=final_answer)
+        )

src/crewai/agents/tools_handler.py

@@ -1,7 +1,7 @@
-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
 
 
@@ -11,15 +11,20 @@ class ToolsHandler:
     last_used_tool: ToolCalling = {}
     cache: CacheHandler
 
-    def __init__(self, cache: CacheHandler):
+    def __init__(self, cache: Optional[CacheHandler] = None):
         """Initialize the callback handler."""
         self.cache = cache
         self.last_used_tool = {}
 
-    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:
+        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/templates/README.md

@@ -23,7 +23,7 @@ poetry install
 ```
 ### Customizing
 
-**Add you `OPENAI_API_KEY` on the `.env` file**
+**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

src/crewai/cli/templates/pyproject.toml

@@ -6,7 +6,7 @@ authors = ["Your Name <you@example.com>"]
 
 [tool.poetry.dependencies]
 python = ">=3.10,<=3.13"
-crewai = {extras = ["tools"], version = "^0.22.2"}
+crewai = {extras = ["tools"], version = "^0.27.0"}
 
 [tool.poetry.scripts]
 {{folder_name}} = "{{folder_name}}.main:run"

src/crewai/crew.py

@@ -18,11 +18,14 @@ from pydantic_core import PydanticCustomError
 
 from crewai.agent import Agent
 from crewai.agents.cache import CacheHandler
+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.telemetry import Telemetry
 from crewai.tools.agent_tools import AgentTools
-from crewai.utilities import I18N, Logger, RPMController
+from crewai.utilities import I18N, Logger, RPMController, FileHandler
 
 
 class Crew(BaseModel):
@@ -33,14 +36,17 @@ 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.
+        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.
         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.
     """
@@ -49,12 +55,26 @@ class Crew(BaseModel):
     _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()
+
+    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)
     process: Process = Field(default=Process.sequential)
     verbose: Union[int, bool] = Field(default=0)
+    memory: bool = Field(
+        default=False,
+        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.",
@@ -80,6 +100,10 @@ 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.",
@@ -88,6 +112,14 @@ class Crew(BaseModel):
         default="en",
         description="Language used for the crew, defaults to English.",
     )
+    language_file: str = Field(
+        default=None,
+        description="Path to the language 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")
     @classmethod
@@ -118,12 +150,23 @@ 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(embedder_config=self.embedder)
+            self._entity_memory = EntityMemory(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."""
@@ -150,7 +193,8 @@ 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
@@ -187,16 +231,20 @@ class Crew(BaseModel):
         """Starts the crew to work on its assigned tasks."""
         self._execution_span = self._telemetry.crew_execution_span(self)
         self._interpolate_inputs(inputs)
+        self._set_tasks_callbacks()
+
+        i18n = I18N(language=self.language, language_file=self.language_file)
 
         for agent in self.agents:
-            agent.i18n = I18N(language=self.language)
+            agent.i18n = i18n
+            agent.crew = self
 
             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()
+
+            agent.create_agent_executor()
 
         metrics = []
 
@@ -232,11 +280,16 @@ class Crew(BaseModel):
                     task.tools += AgentTools(agents=agents_for_delegation).tools()
 
             role = task.agent.role if task.agent is not None else "None"
-            self._logger.log("debug", f"== Working Agent: {role}", color="bold_yellow")
+            self._logger.log("debug", f"== Working Agent: {role}", color="bold_purple")
             self._logger.log(
-                "info", f"== Starting Task: {task.description}", color="bold_yellow"
+                "info", f"== Starting Task: {task.description}", color="bold_purple"
             )
 
+            if self.output_log_file:
+                self._file_handler.log(
+                    agent=role, task=task.description, status="started"
+                )
+
             output = task.execute(context=task_output)
             if not task.async_execution:
                 task_output = output
@@ -244,13 +297,16 @@ class Crew(BaseModel):
             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 self.output_log_file:
+                self._file_handler.log(agent=role, task=task_output, status="completed")
+
         self._finish_execution(task_output)
         return self._format_output(task_output)
 
     def _run_hierarchical_process(self) -> str:
         """Creates and assigns a manager agent to make sure the crew completes the tasks."""
 
-        i18n = I18N(language=self.language)
+        i18n = I18N(language=self.language, language_file=self.language_file)
         manager = Agent(
             role=i18n.retrieve("hierarchical_manager_agent", "role"),
             goal=i18n.retrieve("hierarchical_manager_agent", "goal"),
@@ -265,15 +321,30 @@ class Crew(BaseModel):
             self._logger.log("debug", f"Working Agent: {manager.role}")
             self._logger.log("info", f"Starting Task: {task.description}")
 
+            if self.output_log_file:
+                self._file_handler.log(
+                    agent=manager.role, task=task.description, status="started"
+                )
+
             task_output = task.execute(
                 agent=manager, context=task_output, tools=manager.tools
             )
 
             self._logger.log("debug", f"[{manager.role}] Task output: {task_output}")
 
+            if self.output_log_file:
+                self._file_handler.log(
+                    agent=manager.role, task=task_output, status="completed"
+                )
+
         self._finish_execution(task_output)
         return self._format_output(task_output), manager._token_process.get_summary()
 
+    def _set_tasks_callbacks(self) -> str:
+        """Sets callback for every task suing task_callback"""
+        for task in self.tasks:
+            task.callback = self.task_callback
+
     def _interpolate_inputs(self, inputs: Dict[str, Any]) -> str:
         """Interpolates the inputs in the tasks and agents."""
         [task.interpolate_inputs(inputs) for task in self.tasks]

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

src/crewai/memory/contextual/contextual_memory.py

@@ -0,0 +1,63 @@
+from crewai.memory import EntityMemory, LongTermMemory, ShortTermMemory
+
+
+class ContextualMemory:
+    def __init__(self, stm: ShortTermMemory, ltm: LongTermMemory, em: EntityMemory):
+        self.stm = stm
+        self.ltm = ltm
+        self.em = em
+
+    def build_context_for_task(self, task, context) -> str:
+        """
+        Automatically builds a minimal, highly relevant set of contextual information
+        for a given task.
+        """
+        query = f"{task.description} {context}".strip()
+
+        if query == "":
+            return ""
+
+        context = []
+        context.append(self._fetch_ltm_context(task.description))
+        context.append(self._fetch_stm_context(query))
+        context.append(self._fetch_entity_context(query))
+        return "\n".join(filter(None, context))
+
+    def _fetch_stm_context(self, query) -> str:
+        """
+        Fetches recent relevant insights from STM related to the task's description and expected_output,
+        formatted as bullet points.
+        """
+        stm_results = self.stm.search(query)
+        formatted_results = "\n".join([f"- {result}" for result in stm_results])
+        return f"Recent Insights:\n{formatted_results}" if stm_results else ""
+
+    def _fetch_ltm_context(self, task) -> str:
+        """
+        Fetches historical data or insights from LTM that are relevant to the task's description and expected_output,
+        formatted as bullet points.
+        """
+        ltm_results = self.ltm.search(task, latest_n=2)
+        if not ltm_results:
+            return None
+
+        formatted_results = [
+            suggestion
+            for result in ltm_results
+            for suggestion in result["metadata"]["suggestions"]
+        ]
+        formatted_results = list(dict.fromkeys(formatted_results))
+        formatted_results = "\n".join([f"- {result}" for result in formatted_results])
+
+        return f"Historical Data:\n{formatted_results}" if ltm_results else ""
+
+    def _fetch_entity_context(self, query) -> str:
+        """
+        Fetches relevant entity information from Entity Memory related to the task's description and expected_output,
+        formatted as bullet points.
+        """
+        em_results = self.em.search(query)
+        formatted_results = "\n".join(
+            [f"- {result['context']}" for result in em_results]
+        )
+        return f"Entities:\n{formatted_results}" if em_results else ""

src/crewai/memory/entity/entity_memory.py

@@ -0,0 +1,22 @@
+from crewai.memory.entity.entity_memory_item import EntityMemoryItem
+from crewai.memory.memory import Memory
+from crewai.memory.storage.rag_storage import RAGStorage
+
+
+class EntityMemory(Memory):
+    """
+    EntityMemory class for managing structured information about entities
+    and their relationships using SQLite storage.
+    Inherits from the Memory class.
+    """
+
+    def __init__(self, embedder_config=None):
+        storage = RAGStorage(
+            type="entities", allow_reset=False, embedder_config=embedder_config
+        )
+        super().__init__(storage)
+
+    def save(self, item: EntityMemoryItem) -> None:
+        """Saves an entity item into the SQLite storage."""
+        data = f"{item.name}({item.type}): {item.description}"
+        super().save(data, item.metadata)

src/crewai/memory/entity/entity_memory_item.py

@@ -0,0 +1,12 @@
+class EntityMemoryItem:
+    def __init__(
+        self,
+        name: str,
+        type: str,
+        description: str,
+        relationships: str,
+    ):
+        self.name = name
+        self.type = type
+        self.description = description
+        self.metadata = {"relationships": relationships}

src/crewai/memory/long_term/long_term_memory.py

@@ -0,0 +1,32 @@
+from typing import Any, Dict
+
+from crewai.memory.long_term.long_term_memory_item import LongTermMemoryItem
+from crewai.memory.memory import Memory
+from crewai.memory.storage.ltm_sqlite_storage import LTMSQLiteStorage
+
+
+class LongTermMemory(Memory):
+    """
+    LongTermMemory class for managing cross runs data related to overall crew's
+    execution and performance.
+    Inherits from the Memory class and utilizes an instance of a class that
+    adheres to the Storage for data storage, specifically working with
+    LongTermMemoryItem instances.
+    """
+
+    def __init__(self):
+        storage = LTMSQLiteStorage()
+        super().__init__(storage)
+
+    def save(self, item: LongTermMemoryItem) -> None:
+        metadata = item.metadata
+        metadata.update({"agent": item.agent, "expected_output": item.expected_output})
+        self.storage.save(
+            task_description=item.task,
+            score=metadata["quality"],
+            metadata=metadata,
+            datetime=item.datetime,
+        )
+
+    def search(self, task: str, latest_n: int) -> Dict[str, Any]:
+        return self.storage.load(task, latest_n)

src/crewai/memory/long_term/long_term_memory_item.py

@@ -0,0 +1,19 @@
+from typing import Any, Dict, Union
+
+
+class LongTermMemoryItem:
+    def __init__(
+        self,
+        agent: str,
+        task: str,
+        expected_output: str,
+        datetime: str,
+        quality: Union[int, float] = None,
+        metadata: Dict[str, Any] = None,
+    ):
+        self.task = task
+        self.agent = agent
+        self.quality = quality
+        self.datetime = datetime
+        self.expected_output = expected_output
+        self.metadata = metadata if metadata is not None else {}

src/crewai/memory/memory.py

@@ -0,0 +1,23 @@
+from typing import Any, Dict
+
+from crewai.memory.storage.interface import Storage
+
+
+class Memory:
+    """
+    Base class for memory, now supporting agent tags and generic metadata.
+    """
+
+    def __init__(self, storage: Storage):
+        self.storage = storage
+
+    def save(
+        self, value: Any, metadata: Dict[str, Any] = None, agent: str = None
+    ) -> None:
+        metadata = metadata or {}
+        if agent:
+            metadata["agent"] = agent
+        self.storage.save(value, metadata)
+
+    def search(self, query: str) -> Dict[str, Any]:
+        return self.storage.search(query)

src/crewai/memory/short_term/short_term_memory.py

@@ -0,0 +1,23 @@
+from crewai.memory.memory import Memory
+from crewai.memory.short_term.short_term_memory_item import ShortTermMemoryItem
+from crewai.memory.storage.rag_storage import RAGStorage
+
+
+class ShortTermMemory(Memory):
+    """
+    ShortTermMemory class for managing transient data related to immediate tasks
+    and interactions.
+    Inherits from the Memory class and utilizes an instance of a class that
+    adheres to the Storage for data storage, specifically working with
+    MemoryItem instances.
+    """
+
+    def __init__(self, embedder_config=None):
+        storage = RAGStorage(type="short_term", embedder_config=embedder_config)
+        super().__init__(storage)
+
+    def save(self, item: ShortTermMemoryItem) -> None:
+        super().save(item.data, item.metadata, item.agent)
+
+    def search(self, query: str, score_threshold: float = 0.35):
+        return self.storage.search(query=query, score_threshold=score_threshold)

src/crewai/memory/short_term/short_term_memory_item.py

@@ -0,0 +1,8 @@
+from typing import Any, Dict
+
+
+class ShortTermMemoryItem:
+    def __init__(self, data: Any, agent: str, metadata: Dict[str, Any] = None):
+        self.data = data
+        self.agent = agent
+        self.metadata = metadata if metadata is not None else {}

src/crewai/memory/storage/interface.py

@@ -0,0 +1,11 @@
+from typing import Any, Dict
+
+
+class Storage:
+    """Abstract base class defining the storage interface"""
+
+    def save(self, key: str, value: Any, metadata: Dict[str, Any]) -> None:
+        pass
+
+    def search(self, key: str) -> Dict[str, Any]:
+        pass

src/crewai/memory/storage/ltm_sqlite_storage.py

@@ -0,0 +1,101 @@
+import json
+import sqlite3
+from typing import Any, Dict, Union
+
+from crewai.utilities import Printer
+from crewai.utilities.paths import db_storage_path
+
+
+class LTMSQLiteStorage:
+    """
+    An updated SQLite storage class for LTM data storage.
+    """
+
+    def __init__(self, db_path=f"{db_storage_path()}/long_term_memory_storage.db"):
+        self.db_path = db_path
+        self._printer: Printer = Printer()
+        self._initialize_db()
+
+    def _initialize_db(self):
+        """
+        Initializes the SQLite database and creates LTM table
+        """
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute(
+                    """
+                    CREATE TABLE IF NOT EXISTS long_term_memories (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        task_description TEXT,
+                        metadata TEXT,
+                        datetime TEXT,
+                        score REAL
+                    )
+                """
+                )
+
+                conn.commit()
+        except sqlite3.Error as e:
+            self._printer.print(
+                content=f"MEMORY ERROR: An error occurred during database initialization: {e}",
+                color="red",
+            )
+
+    def save(
+        self,
+        task_description: str,
+        metadata: Dict[str, Any],
+        datetime: str,
+        score: Union[int, float],
+    ) -> None:
+        """Saves data to the LTM table with error handling."""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute(
+                    """
+                INSERT INTO long_term_memories (task_description, metadata, datetime, score)
+                VALUES (?, ?, ?, ?)
+            """,
+                    (task_description, json.dumps(metadata), datetime, score),
+                )
+                conn.commit()
+        except sqlite3.Error as e:
+            self._printer.print(
+                content=f"MEMORY ERROR: An error occurred while saving to LTM: {e}",
+                color="red",
+            )
+
+    def load(self, task_description: str, latest_n: int) -> Dict[str, Any]:
+        """Queries the LTM table by task description with error handling."""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute(
+                    f"""
+                    SELECT metadata, datetime, score
+                    FROM long_term_memories
+                    WHERE task_description = ?
+                    ORDER BY datetime DESC, score ASC
+                    LIMIT {latest_n}
+                """,
+                    (task_description,),
+                )
+                rows = cursor.fetchall()
+                if rows:
+                    return [
+                        {
+                            "metadata": json.loads(row[0]),
+                            "datetime": row[1],
+                            "score": row[2],
+                        }
+                        for row in rows
+                    ]
+
+        except sqlite3.Error as e:
+            self._printer.print(
+                content=f"MEMORY ERROR: An error occurred while querying LTM: {e}",
+                color="red",
+            )
+        return None

src/crewai/memory/storage/rag_storage.py

@@ -0,0 +1,99 @@
+import contextlib
+import io
+import logging
+import os
+from typing import Any, Dict
+
+from embedchain import App
+from embedchain.llm.base import BaseLlm
+from embedchain.vectordb.chroma import InvalidDimensionException
+
+from crewai.memory.storage.interface import Storage
+from crewai.utilities.paths import db_storage_path
+
+
+@contextlib.contextmanager
+def suppress_logging(
+    logger_name="chromadb.segment.impl.vector.local_persistent_hnsw",
+    level=logging.ERROR,
+):
+    logger = logging.getLogger(logger_name)
+    original_level = logger.getEffectiveLevel()
+    logger.setLevel(level)
+    with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(
+        io.StringIO()
+    ), contextlib.suppress(UserWarning):
+        yield
+    logger.setLevel(original_level)
+
+
+class FakeLLM(BaseLlm):
+    pass
+
+
+class RAGStorage(Storage):
+    """
+    Extends Storage to handle embeddings for memory entries, improving
+    search efficiency.
+    """
+
+    def __init__(self, type, allow_reset=True, embedder_config=None):
+        super().__init__()
+        if (
+            not os.getenv("OPENAI_API_KEY")
+            and not os.getenv("OPENAI_BASE_URL") == "https://api.openai.com/v1"
+        ):
+            os.environ["OPENAI_API_KEY"] = "fake"
+        config = {
+            "app": {
+                "config": {"name": type, "collect_metrics": False, "log_level": "ERROR"}
+            },
+            "chunker": {
+                "chunk_size": 5000,
+                "chunk_overlap": 100,
+                "length_function": "len",
+                "min_chunk_size": 150,
+            },
+            "vectordb": {
+                "provider": "chroma",
+                "config": {
+                    "collection_name": type,
+                    "dir": f"{db_storage_path()}/{type}",
+                    "allow_reset": allow_reset,
+                },
+            },
+        }
+
+        if embedder_config:
+            config["embedder"] = embedder_config
+
+        self.app = App.from_config(config=config)
+        self.app.llm = FakeLLM()
+        if allow_reset:
+            self.app.reset()
+
+    def save(self, value: Any, metadata: Dict[str, Any]) -> None:
+        self._generate_embedding(value, metadata)
+
+    def search(
+        self,
+        query: str,
+        limit: int = 3,
+        filter: dict = None,
+        score_threshold: float = 0.35,
+    ) -> Dict[str, Any]:
+        with suppress_logging():
+            try:
+                results = (
+                    self.app.search(query, limit, where=filter)
+                    if filter
+                    else self.app.search(query, limit)
+                )
+            except InvalidDimensionException:
+                self.app.reset()
+                return []
+        return [r for r in results if r["metadata"]["score"] >= score_threshold]
+
+    def _generate_embedding(self, text: str, metadata: Dict[str, Any]) -> Any:
+        with suppress_logging():
+            self.app.add(text, data_type="text", metadata=metadata)

src/crewai/task.py

@@ -13,7 +13,23 @@ from crewai.utilities.pydantic_schema_parser import PydanticSchemaParser
 
 
 class Task(BaseModel):
-    """Class that represent a task to be executed."""
+    """Class that represents a task to be executed.
+
+    Each task must have a description, an expected output and an agent responsible for execution.
+
+    Attributes:
+        agent: Agent responsible for task execution. Represents entity performing task.
+        async_execution: Boolean flag indicating asynchronous task execution.
+        callback: Function/object executed post task completion for additional actions.
+        config: Dictionary containing task-specific configuration parameters.
+        context: List of Task instances providing task context or input data.
+        description: Descriptive text detailing task's purpose and execution.
+        expected_output: Clear definition of expected task outcome.
+        output_file: File path for storing task output.
+        output_json: Pydantic model for structuring JSON output.
+        output_pydantic: Pydantic model for task output.
+        tools: List of tools/resources limited for task execution.
+    """
 
     class Config:
         arbitrary_types_allowed = True
@@ -24,6 +40,7 @@ class Task(BaseModel):
     delegations: int = 0
     i18n: I18N = I18N()
     thread: threading.Thread = None
+    prompt_context: Optional[str] = None
     description: str = Field(description="Description of the actual task.")
     expected_output: str = Field(
         description="Clear definition of expected output for the task."
@@ -70,6 +87,13 @@ class Task(BaseModel):
         frozen=True,
         description="Unique identifier for the object, not set by user.",
     )
+    human_input: Optional[bool] = Field(
+        description="Whether the task should have a human review the final answer of the agent",
+        default=False,
+    )
+
+    _original_description: str | None = None
+    _original_expected_output: str | None = None
 
     def __init__(__pydantic_self__, **data):
         config = data.pop("config", {})
@@ -137,6 +161,7 @@ class Task(BaseModel):
                     context.append(task.output.raw_output)
             context = "\n".join(context)
 
+        self.prompt_context = context
         tools = tools or self.tools
 
         if self.async_execution:
@@ -189,9 +214,14 @@ class Task(BaseModel):
 
     def interpolate_inputs(self, inputs: Dict[str, Any]) -> None:
         """Interpolate inputs into the task description and expected output."""
+        if self._original_description is None:
+            self._original_description = self.description
+        if self._original_expected_output is None:
+            self._original_expected_output = self.expected_output
+
         if inputs:
-            self.description = self.description.format(**inputs)
-            self.expected_output = self.expected_output.format(**inputs)
+            self.description = self._original_description.format(**inputs)
+            self.expected_output = self._original_expected_output.format(**inputs)
 
     def increment_tools_errors(self) -> None:
         """Increment the tools errors counter."""
@@ -207,6 +237,16 @@ class Task(BaseModel):
 
         if self.output_pydantic or self.output_json:
             model = self.output_pydantic or self.output_json
+
+            # try to convert task_output directly to pydantic/json
+            try:
+                exported_result = model.model_validate_json(result)
+                if self.output_json:
+                    return exported_result.model_dump()
+                return exported_result
+            except Exception:
+                pass
+
             llm = self.agent.function_calling_llm or self.agent.llm
 
             if not self._is_gpt(llm):

src/crewai/telemetry/telemetry.py

@@ -39,26 +39,39 @@ class Telemetry:
 
     def __init__(self):
         self.ready = False
+        self.trace_set = False
         try:
-            telemetry_endpoint = "http://telemetry.crewai.com:4318"
+            telemetry_endpoint = "https://telemetry.crewai.com:4319"
             self.resource = Resource(
                 attributes={SERVICE_NAME: "crewAI-telemetry"},
             )
             self.provider = TracerProvider(resource=self.resource)
+
             processor = BatchSpanProcessor(
-                OTLPSpanExporter(endpoint=f"{telemetry_endpoint}/v1/traces", timeout=15)
+                OTLPSpanExporter(
+                    endpoint=f"{telemetry_endpoint}/v1/traces",
+                    timeout=30,
+                )
             )
+
             self.provider.add_span_processor(processor)
             self.ready = True
-        except Exception:
-            pass
+        except BaseException as e:
+            if isinstance(
+                e,
+                (SystemExit, KeyboardInterrupt, GeneratorExit, asyncio.CancelledError),
+            ):
+                raise  # Re-raise the exception to not interfere with system signals
+            self.ready = False
 
     def set_tracer(self):
-        if self.ready:
+        if self.ready and not self.trace_set:
             try:
                 trace.set_tracer_provider(self.provider)
+                self.trace_set = True
             except Exception:
-                pass
+                self.ready = False
+                self.trace_set = False
 
     def crew_creation(self, crew):
         """Records the creation of a crew."""
@@ -75,6 +88,7 @@ class Telemetry:
                 self._add_attribute(span, "crew_id", str(crew.id))
                 self._add_attribute(span, "crew_process", crew.process)
                 self._add_attribute(span, "crew_language", crew.language)
+                self._add_attribute(span, "crew_memory", crew.memory)
                 self._add_attribute(span, "crew_number_of_tasks", len(crew.tasks))
                 self._add_attribute(span, "crew_number_of_agents", len(crew.agents))
                 self._add_attribute(
@@ -85,14 +99,15 @@ class Telemetry:
                             {
                                 "id": str(agent.id),
                                 "role": agent.role,
-                                "memory_enabled?": agent.memory,
                                 "verbose?": agent.verbose,
                                 "max_iter": agent.max_iter,
                                 "max_rpm": agent.max_rpm,
                                 "i18n": agent.i18n.language,
                                 "llm": json.dumps(self._safe_llm_attributes(agent.llm)),
                                 "delegation_enabled?": agent.allow_delegation,
-                                "tools_names": [tool.name for tool in agent.tools],
+                                "tools_names": [
+                                    tool.name.casefold() for tool in agent.tools
+                                ],
                             }
                             for agent in crew.agents
                         ]
@@ -107,7 +122,9 @@ class Telemetry:
                                 "id": str(task.id),
                                 "async_execution?": task.async_execution,
                                 "agent_role": task.agent.role if task.agent else "None",
-                                "tools_names": [tool.name for tool in task.tools],
+                                "tools_names": [
+                                    tool.name.casefold() for tool in task.tools
+                                ],
                             }
                             for task in crew.tasks
                         ]
@@ -129,11 +146,17 @@ class Telemetry:
             try:
                 tracer = trace.get_tracer("crewai.telemetry")
                 span = tracer.start_span("Tool Repeated Usage")
+                self._add_attribute(
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
                 self._add_attribute(span, "tool_name", tool_name)
                 self._add_attribute(span, "attempts", attempts)
-                self._add_attribute(
-                    span, "llm", json.dumps(self._safe_llm_attributes(llm))
-                )
+                if llm:
+                    self._add_attribute(
+                        span, "llm", json.dumps(self._safe_llm_attributes(llm))
+                    )
                 span.set_status(Status(StatusCode.OK))
                 span.end()
             except Exception:
@@ -145,11 +168,17 @@ class Telemetry:
             try:
                 tracer = trace.get_tracer("crewai.telemetry")
                 span = tracer.start_span("Tool Usage")
+                self._add_attribute(
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
                 self._add_attribute(span, "tool_name", tool_name)
                 self._add_attribute(span, "attempts", attempts)
-                self._add_attribute(
-                    span, "llm", json.dumps(self._safe_llm_attributes(llm))
-                )
+                if llm:
+                    self._add_attribute(
+                        span, "llm", json.dumps(self._safe_llm_attributes(llm))
+                    )
                 span.set_status(Status(StatusCode.OK))
                 span.end()
             except Exception:
@@ -162,8 +191,14 @@ class Telemetry:
                 tracer = trace.get_tracer("crewai.telemetry")
                 span = tracer.start_span("Tool Usage Error")
                 self._add_attribute(
-                    span, "llm", json.dumps(self._safe_llm_attributes(llm))
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
                 )
+                if llm:
+                    self._add_attribute(
+                        span, "llm", json.dumps(self._safe_llm_attributes(llm))
+                    )
                 span.set_status(Status(StatusCode.OK))
                 span.end()
             except Exception:
@@ -177,6 +212,11 @@ class Telemetry:
             try:
                 tracer = trace.get_tracer("crewai.telemetry")
                 span = tracer.start_span("Crew Execution")
+                self._add_attribute(
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
                 self._add_attribute(span, "crew_id", str(crew.id))
                 self._add_attribute(
                     span,
@@ -188,14 +228,15 @@ class Telemetry:
                                 "role": agent.role,
                                 "goal": agent.goal,
                                 "backstory": agent.backstory,
-                                "memory_enabled?": agent.memory,
                                 "verbose?": agent.verbose,
                                 "max_iter": agent.max_iter,
                                 "max_rpm": agent.max_rpm,
                                 "i18n": agent.i18n.language,
                                 "llm": json.dumps(self._safe_llm_attributes(agent.llm)),
                                 "delegation_enabled?": agent.allow_delegation,
-                                "tools_names": [tool.name for tool in agent.tools],
+                                "tools_names": [
+                                    tool.name.casefold() for tool in agent.tools
+                                ],
                             }
                             for agent in crew.agents
                         ]
@@ -215,7 +256,9 @@ class Telemetry:
                                 "context": [task.description for task in task.context]
                                 if task.context
                                 else "None",
-                                "tools_names": [tool.name for tool in task.tools],
+                                "tools_names": [
+                                    tool.name.casefold() for tool in task.tools
+                                ],
                             }
                             for task in crew.tasks
                         ]
@@ -228,6 +271,11 @@ class Telemetry:
     def end_crew(self, crew, output):
         if (self.ready) and (crew.share_crew):
             try:
+                self._add_attribute(
+                    crew._execution_span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
                 self._add_attribute(crew._execution_span, "crew_output", output)
                 self._add_attribute(
                     crew._execution_span,
@@ -257,6 +305,8 @@ class Telemetry:
 
     def _safe_llm_attributes(self, llm):
         attributes = ["name", "model_name", "base_url", "model", "top_k", "temperature"]
-        safe_attributes = {k: v for k, v in vars(llm).items() if k in attributes}
-        safe_attributes["class"] = llm.__class__.__name__
-        return safe_attributes
+        if llm:
+            safe_attributes = {k: v for k, v in vars(llm).items() if k in attributes}
+            safe_attributes["class"] = llm.__class__.__name__
+            return safe_attributes
+        return {}

src/crewai/tools/agent_tools.py

@@ -15,22 +15,23 @@ class AgentTools(BaseModel):
     i18n: I18N = Field(default=I18N(), description="Internationalization settings.")
 
     def tools(self):
-        return [
+        tools = [
             StructuredTool.from_function(
                 func=self.delegate_work,
                 name="Delegate work to co-worker",
                 description=self.i18n.tools("delegate_work").format(
-                    coworkers=[f"{agent.role}" for agent in self.agents]
+                    coworkers=f"[{', '.join([f'{agent.role}' for agent in self.agents])}]"
                 ),
             ),
             StructuredTool.from_function(
                 func=self.ask_question,
                 name="Ask question to co-worker",
                 description=self.i18n.tools("ask_question").format(
-                    coworkers=[f"{agent.role}" for agent in self.agents]
+                    coworkers=f"[{', '.join([f'{agent.role}' for agent in self.agents])}]"
                 ),
             ),
         ]
+        return tools
 
     def delegate_work(self, coworker: str, task: str, context: str):
         """Useful to delegate a specific task to a coworker passing all necessary context and names."""
@@ -46,16 +47,20 @@ class AgentTools(BaseModel):
             agent = [
                 available_agent
                 for available_agent in self.agents
-                if available_agent.role.strip().lower() == agent.strip().lower()
+                if available_agent.role.casefold().strip() == agent.casefold().strip()
             ]
         except:
             return self.i18n.errors("agent_tool_unexsiting_coworker").format(
-                coworkers="\n".join([f"- {agent.role}" for agent in self.agents])
+                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}" for agent in self.agents])
+                coworkers="\n".join(
+                    [f"- {agent.role.casefold()}" for agent in self.agents]
+                )
             )
 
         agent = agent[0]

src/crewai/tools/tool_usage.py

@@ -29,6 +29,7 @@ class ToolUsage:
         task: Task being executed.
         tools_handler: Tools handler that will manage the tool usage.
         tools: List of tools available for the agent.
+        original_tools: Original tools available for the agent before being converted to BaseTool.
         tools_description: Description of the tools available for the agent.
         tools_names: Names of the tools available for the agent.
         function_calling_llm: Language model to be used for the tool usage.
@@ -38,6 +39,7 @@ class ToolUsage:
         self,
         tools_handler: ToolsHandler,
         tools: List[BaseTool],
+        original_tools: List[Any],
         tools_description: str,
         tools_names: str,
         task: Any,
@@ -53,6 +55,7 @@ class ToolUsage:
         self.tools_description = tools_description
         self.tools_names = tools_names
         self.tools_handler = tools_handler
+        self.original_tools = original_tools
         self.tools = tools
         self.task = task
         self.action = action
@@ -98,7 +101,7 @@ class ToolUsage:
                 result = self._i18n.errors("task_repeated_usage").format(
                     tool_names=self.tools_names
                 )
-                self._printer.print(content=f"\n\n{result}\n", color="yellow")
+                self._printer.print(content=f"\n\n{result}\n", color="purple")
                 self._telemetry.tool_repeated_usage(
                     llm=self.function_calling_llm,
                     tool_name=tool.name,
@@ -109,9 +112,12 @@ class ToolUsage:
             except Exception:
                 self.task.increment_tools_errors()
 
-        result = self.tools_handler.cache.read(
-            tool=calling.tool_name, input=calling.arguments
-        )
+        result = None
+
+        if self.tools_handler.cache:
+            result = self.tools_handler.cache.read(
+                tool=calling.tool_name, input=calling.arguments
+            )
 
         if not result:
             try:
@@ -155,9 +161,24 @@ class ToolUsage:
                 self.task.increment_tools_errors()
                 return self.use(calling=calling, tool_string=tool_string)
 
-            self.tools_handler.on_tool_use(calling=calling, output=result)
+            if self.tools_handler:
+                should_cache = True
+                original_tool = next(
+                    (ot for ot in self.original_tools if ot.name == tool.name), None
+                )
+                if (
+                    hasattr(original_tool, "cache_function")
+                    and original_tool.cache_function
+                ):
+                    should_cache = original_tool.cache_function(
+                        calling.arguments, result
+                    )
 
-        self._printer.print(content=f"\n\n{result}\n", color="yellow")
+                self.tools_handler.on_tool_use(
+                    calling=calling, output=result, should_cache=should_cache
+                )
+
+        self._printer.print(content=f"\n\n{result}\n", color="purple")
         self._telemetry.tool_usage(
             llm=self.function_calling_llm,
             tool_name=tool.name,
@@ -185,6 +206,8 @@ class ToolUsage:
     def _check_tool_repeated_usage(
         self, calling: Union[ToolCalling, InstructorToolCalling]
     ) -> None:
+        if not self.tools_handler:
+            return False
         if last_tool_usage := self.tools_handler.last_used_tool:
             return (calling.tool_name == last_tool_usage.tool_name) and (
                 calling.arguments == last_tool_usage.arguments
@@ -242,12 +265,12 @@ class ToolUsage:
                     model=model,
                     instructions=dedent(
                         """\
-                                            The schema should have the following structure, only two keys:
-                                            - tool_name: str
-                                            - arguments: dict (with all arguments being passed)
+                            The schema should have the following structure, only two keys:
+                            - tool_name: str
+                            - arguments: dict (with all arguments being passed)
 
-                                            Example:
-                                            {"tool_name": "tool name", "arguments": {"arg_name1": "value", "arg_name2": 2}}""",
+                            Example:
+                            {"tool_name": "tool name", "arguments": {"arg_name1": "value", "arg_name2": 2}}""",
                     ),
                     max_attemps=1,
                 )

src/crewai/translations/el.json

@@ -1,27 +0,0 @@
-{
-  "hierarchical_manager_agent": {
-    "role": "Διευθυντής Ομάδας",
-    "goal": "Διαχειρίσου την ομάδα σου για να ολοκληρώσει την εργασία με τον καλύτερο δυνατό τρόπο.",
-    "backstory": "Είσαι ένας έμπειρος διευθυντής με την ικανότητα να βγάζεις το καλύτερο από την ομάδα σου.\nΕίσαι επίσης γνωστός για την ικανότητά σου να αναθέτεις εργασίες στους σωστούς ανθρώπους και να κάνεις τις σωστές ερωτήσεις για να πάρεις το καλύτερο από την ομάδα σου.\nΑκόμα κι αν δεν εκτελείς εργασίες μόνος σου, έχεις πολλή εμπειρία στον τομέα, που σου επιτρέπει να αξιολογείς σωστά τη δουλειά των μελών της ομάδας σου."
-  },
-  "slices": {
-    "observation": "\nΠαρατήρηση",
-    "task": "Αρχή! Αυτό είναι ΠΟΛΥ σημαντικό για εσάς, η δουλειά σας εξαρτάται από αυτό!\n\nΤρέχουσα εργασία: {input}",
-    "memory": "Αυτή είναι η περίληψη της μέχρι τώρα δουλειάς σας:\n{chat_history}",
-    "role_playing": "Είσαι {role}.\n{backstory}\n\nΟ προσωπικός σας στόχος είναι: {goal}",
-    "tools": "ΕΡΓΑΛΕΙΑ:\n------\nΈχετε πρόσβαση μόνο στα ακόλουθα εργαλεία:\n\n{tools}\n\nΓια να χρησιμοποιήσετε ένα εργαλείο, χρησιμοποιήστε την ακόλουθη ακριβώς μορφή:\n\n```\nThought: Χρειάζεται να χρησιμοποιήσω κάποιο εργαλείο; Ναι\nΕνέργεια: το εργαλείο που θέλετε να χρησιμοποιήσετε, θα πρέπει να είναι ένα από τα [{tool_names}], μόνο το όνομα.\nΕισαγωγή ενέργειας: Οποιαδήποτε και όλες οι σχετικές πληροφορίες και το πλαίσιο χρήσης του εργαλείου\nΠαρατήρηση: το αποτέλεσμα της χρήσης του εργαλείου\n```\n\nΌταν έχετε μια απάντηση για την εργασία σας ή εάν δεν χρειάζεται να χρησιμοποιήσετε ένα εργαλείο, ΠΡΕΠΕΙ να χρησιμοποιήσετε τη μορφή:\n\n```\nΣκέψη: Πρέπει να χρησιμοποιήσω ένα εργαλείο ? Όχι\nΤελική απάντηση: [η απάντησή σας εδώ]```",
-    "task_with_context": "{task}\nΑυτό είναι το πλαίσιο με το οποίο εργάζεστε:\n{context}",
-    "expected_output": "Η τελική σας απάντηση πρέπει να είναι: {expected_output}"
-  },
-  "errors": {
-    "force_final_answer": "Στην πραγματικότητα, χρησιμοποίησα πάρα πολλά εργαλεία, οπότε θα σταματήσω τώρα και θα σας δώσω την απόλυτη ΚΑΛΥΤΕΡΗ τελική μου απάντηση ΤΩΡΑ, χρησιμοποιώντας την αναμενόμενη μορφή: ```\nΣκέφτηκα: Χρειάζεται να χρησιμοποιήσω ένα εργαλείο; Όχι\nΤελική απάντηση: [η απάντησή σας εδώ]```",
-    "agent_tool_unexsiting_coworker": "\nΣφάλμα κατά την εκτέλεση του εργαλείου. Ο συνάδελφος που αναφέρεται στο Action Input δεν βρέθηκε, πρέπει να είναι μία από τις ακόλουθες επιλογές:\n{coworkers}..\n",
-    "task_repeated_usage": "Μόλις χρησιμοποίησα το εργαλείο {tool} με είσοδο {tool_input}. Άρα το ξέρω ήδη και πρέπει να σταματήσω να το χρησιμοποιώ στη σειρά με την ίδια είσοδο. \nΘα μπορούσα να δώσω την τελική μου απάντηση εάν είμαι έτοιμος, χρησιμοποιώντας ακριβώς την αναμενόμενη μορφή παρακάτω: \n\nΣκέφτηκα: Χρειάζεται να χρησιμοποιήσω κάποιο εργαλείο; Όχι\nΤελική απάντηση: [η απάντησή σας εδώ]\n",
-    "tool_usage_error": "Φαίνεται ότι αντιμετωπίσαμε ένα απροσδόκητο σφάλμα κατά την προσπάθεια χρήσης του εργαλείου.",
-    "tool_usage_exception": "Φαίνεται ότι αντιμετωπίσαμε ένα απροσδόκητο σφάλμα κατά την προσπάθεια χρήσης του εργαλείου. Αυτό ήταν το σφάλμα: {error}"
-  },
-  "tools": {
-    "delegate_work": "Αναθέστε μια συγκεκριμένη εργασία σε έναν από τους παρακάτω συναδέλφους:\n{coworkers}.\nΗ εισαγωγή σε αυτό το εργαλείο θα πρέπει να είναι ο ρόλος του συναδέλφου, η εργασία που θέλετε να κάνει και ΟΛΟ το απαραίτητο πλαίσιο για την εκτέλεση της εργασίας, δεν γνωρίζουν τίποτα για την εργασία, γι' αυτό μοιραστείτε απολύτως όλα όσα γνωρίζετε, μην αναφέρετε πράγματα, αλλά εξηγήστε τα.",
-    "ask_question": "Κάντε μια συγκεκριμένη ερώτηση σε έναν από τους παρακάτω συναδέλφους:\n{coworkers}.\nΗ είσοδος σε αυτό το εργαλείο θα πρέπει να είναι ο ρόλος του συναδέλφου, η ερώτηση που έχετε για αυτόν και ΟΛΟ το απαραίτητο πλαίσιο για να κάνετε σωστά την ερώτηση, δεν γνωρίζουν τίποτα για την ερώτηση, γι' αυτό μοιραστείτε απολύτως όλα όσα γνωρίζετε, μην αναφέρετε πράγματα, αλλά εξηγήστε τα."
-  }
-}

src/crewai/translations/en.json

@@ -6,16 +6,18 @@
   },
   "slices": {
     "observation": "\nObservation",
-    "task": "\n\nCurrent Task: {input}\n\nBegin! This is VERY important to you, use the tools available and give your best Final Answer, your job depends on it!\n\nThought: ",
-    "memory": "This is the summary of your work so far:\n{chat_history}",
+    "task": "\nCurrent Task: {input}\n\nBegin! This is VERY important to you, use the tools available and give your best Final Answer, your job depends on it!\n\nThought: ",
+    "memory": "\n\n# Useful context: \n{memory}",
     "role_playing": "You are {role}. {backstory}\nYour personal goal is: {goal}",
-    "tools": "\n\nYou ONLY have access to the following tools, and should NEVER make up tools that are not listed here:\n\n{tools}\n\nUse the following format:\n\nThought: you should always think about what to do\nAction: the action to take, only one name of [{tool_names}], just the name, exactly as it's written.\nAction Input: the input to the action, just a simple a python dictionary using \" to wrap keys and values.\nObservation: the result of the action\n\nOnce all necessary information is gathered:\n\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question\n",
-    "no_tools": "To give my best complete final answer to the task use the exact following format:\n\nThought: I now can give a great answer\nFinal Answer: my best complete final answer to the task.\nYour final answer must be the great and the most complete as possible, it must be outcome described.\n\nI MUST use these formats, my job depends on it!\n\nThought: ",
+    "tools": "\nYou ONLY have access to the following tools, and should NEVER make up tools that are not listed here:\n\n{tools}\n\nUse the following format:\n\nThought: you should always think about what to do\nAction: the action to take, only one name of [{tool_names}], just the name, exactly as it's written.\nAction Input: the input to the action, just a simple a python dictionary using \" to wrap keys and values.\nObservation: the result of the action\n\nOnce all necessary information is gathered:\n\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question\n",
+    "no_tools": "To give my best complete final answer to the task use the exact following format:\n\nThought: I now can give a great answer\nFinal Answer: my best complete final answer to the task.\nYour final answer must be the great and the most complete as possible, it must be outcome described.\n\nI MUST use these formats, my job depends on it!",
     "format": "I MUST either use a tool (use one at time) OR give my best final answer. To Use the following format:\n\nThought: you should always think about what to do\nAction: the action to take, should be one of [{tool_names}]\nAction Input: the input to the action, dictionary\nObservation: the result of the action\n... (this Thought/Action/Action Input/Observation can repeat N times)\nThought: I now can give a great answer\nFinal Answer: my best complete final answer to the task.\nYour final answer must be the great and the most complete as possible, it must be outcome described\n\n ",
     "final_answer_format": "If you don't need to use any more tools, you must give your best complete final answer, make sure it satisfy the expect criteria, use the EXACT format below:\n\nThought: I now can give a great answer\nFinal Answer: my best complete final answer to the task.\n\n",
     "format_without_tools": "\nSorry, I didn't use the right format. I MUST either use a tool (among the available ones), OR give my best final answer.\nI just remembered the expected format I must follow:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction: the action to take, should be one of [{tool_names}]\nAction Input: the input to the action\nObservation: the result of the action\n... (this Thought/Action/Action Input/Observation can repeat N times)\nThought: I now can give a great answer\nFinal Answer: my best complete final answer to the task\nYour final answer must be the great and the most complete as possible, it must be outcome described\n\n",
     "task_with_context": "{task}\n\nThis is the context you're working with:\n{context}",
-    "expected_output": "\nThis is the expect criteria for your final answer: {expected_output} \n you MUST return the actual complete content as the final answer, not a summary."
+    "expected_output": "\nThis is the expect criteria for your final answer: {expected_output} \n you MUST return the actual complete content as the final answer, not a summary.",
+    "human_feedback": "You got human feedback on your work, re-avaluate it and give a new Final Answer when ready.\n {human_feedback}",
+    "getting_input": "This is the agent final answer: {final_answer}\nPlease provide a feedback: "
   },
   "errors": {
     "unexpected_format": "\nSorry, I didn't use the expected format, I MUST either use a tool (use one at time) OR give my best final answer.\n",

src/crewai/utilities/__init__.py

@@ -5,3 +5,4 @@ from .logger import Logger
 from .printer import Printer
 from .prompts import Prompts
 from .rpm_controller import RPMController
+from .fileHandler import FileHandler

src/crewai/utilities/evaluators/task_evaluator.py

@@ -0,0 +1,61 @@
+from typing import List
+
+from langchain_openai import ChatOpenAI
+from pydantic import BaseModel, Field
+
+from crewai.utilities import Converter
+from crewai.utilities.pydantic_schema_parser import PydanticSchemaParser
+
+
+class Entity(BaseModel):
+    name: str = Field(description="The name of the entity.")
+    type: str = Field(description="The type of the entity.")
+    description: str = Field(description="Description of the entity.")
+    relationships: List[str] = Field(description="Relationships of the entity.")
+
+
+class TaskEvaluation(BaseModel):
+    suggestions: List[str] = Field(
+        description="Suggestions to improve future similar tasks."
+    )
+    quality: float = Field(
+        description="A score from 0 to 10 evaluating on completion, quality, and overall performance, all taking into account the task description, expected output, and the result of the task."
+    )
+    entities: List[Entity] = Field(
+        description="Entities extracted from the task output."
+    )
+
+
+class TaskEvaluator:
+    def __init__(self, original_agent):
+        self.llm = original_agent.llm
+
+    def evaluate(self, task, ouput) -> TaskEvaluation:
+        evaluation_query = (
+            f"Assess the quality of the task completed based on the description, expected output, and actual results.\n\n"
+            f"Task Description:\n{task.description}\n\n"
+            f"Expected Output:\n{task.expected_output}\n\n"
+            f"Actual Output:\n{ouput}\n\n"
+            "Please provide:\n"
+            "- Bullet points suggestions to improve future similar tasks\n"
+            "- A score from 0 to 10 evaluating on completion, quality, and overall performance"
+            "- Entities extracted from the task output, if any, their type, description, and relationships"
+        )
+
+        instructions = "I'm gonna convert this raw text into valid JSON."
+
+        if not self._is_gpt(self.llm):
+            model_schema = PydanticSchemaParser(model=TaskEvaluation).get_schema()
+            instructions = f"{instructions}\n\nThe json should have the following structure, with the following keys:\n{model_schema}"
+
+        converter = Converter(
+            llm=self.llm,
+            text=evaluation_query,
+            model=TaskEvaluation,
+            instructions=instructions,
+        )
+
+        return converter.to_pydantic()
+
+    def _is_gpt(self, llm) -> bool:
+        return isinstance(llm, ChatOpenAI) and llm.openai_api_base == None

src/crewai/utilities/fileHandler.py

@@ -0,0 +1,20 @@
+import os
+from datetime import datetime
+
+
+class FileHandler:
+    """take care of file operations, currently it only logs messages to a file"""
+
+    def __init__(self, file_path):
+        if isinstance(file_path, bool):
+            self._path = os.path.join(os.curdir, "logs.txt")
+        elif isinstance(file_path, str):
+            self._path = file_path
+        else:
+            raise ValueError("file_path must be either a boolean or a string.")
+
+    def log(self, **kwargs):
+        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        message = f"{now}: ".join([f"{key}={value}" for key, value in kwargs.items()])
+        with open(self._path, "a") as file:
+            file.write(message + "\n")

src/crewai/utilities/i18n.py

@@ -7,6 +7,10 @@ from pydantic import BaseModel, Field, PrivateAttr, ValidationError, model_valid
 
 class I18N(BaseModel):
     _translations: Dict[str, Dict[str, str]] = PrivateAttr()
+    language_file: Optional[str] = Field(
+        default=None,
+        description="Path to the translation file to load",
+    )
     language: Optional[str] = Field(
         default="en",
         description="Language used to load translations",
@@ -16,13 +20,17 @@ class I18N(BaseModel):
     def load_translation(self) -> "I18N":
         """Load translations from a JSON file based on the specified language."""
         try:
-            dir_path = os.path.dirname(os.path.realpath(__file__))
-            prompts_path = os.path.join(
-                dir_path, f"../translations/{self.language}.json"
-            )
+            if self.language_file:
+                with open(self.language_file, "r") as f:
+                    self._translations = json.load(f)
+            else:
+                dir_path = os.path.dirname(os.path.realpath(__file__))
+                prompts_path = os.path.join(
+                    dir_path, f"../translations/{self.language}.json"
+                )
 
-            with open(prompts_path, "r") as f:
-                self._translations = json.load(f)
+                with open(prompts_path, "r") as f:
+                    self._translations = json.load(f)
         except FileNotFoundError:
             raise ValidationError(
                 f"Translation file for language '{self.language}' not found."

src/crewai/utilities/paths.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+
+import appdirs
+
+
+def db_storage_path():
+    app_name = get_project_directory_name()
+    app_author = "CrewAI"
+
+    data_dir = Path(appdirs.user_data_dir(app_name, app_author))
+    data_dir.mkdir(parents=True, exist_ok=True)
+    return data_dir
+
+
+def get_project_directory_name():
+    cwd = Path.cwd()
+    project_directory_name = cwd.name
+    return project_directory_name

src/crewai/utilities/printer.py

@@ -1,24 +1,24 @@
 class Printer:
     def print(self, content: str, color: str):
-        if color == "yellow":
-            self._print_yellow(content)
+        if color == "purple":
+            self._print_purple(content)
         elif color == "red":
             self._print_red(content)
         elif color == "bold_green":
             self._print_bold_green(content)
-        elif color == "bold_yellow":
-            self._print_bold_yellow(content)
+        elif color == "bold_purple":
+            self._print_bold_purple(content)
         else:
             print(content)
 
-    def _print_bold_yellow(self, content):
-        print("\033[1m\033[93m {}\033[00m".format(content))
+    def _print_bold_purple(self, content):
+        print("\033[1m\033[95m {}\033[00m".format(content))
 
     def _print_bold_green(self, content):
         print("\033[1m\033[92m {}\033[00m".format(content))
 
-    def _print_yellow(self, content):
-        print("\033[93m {}\033[00m".format(content))
+    def _print_purple(self, content):
+        print("\033[95m {}\033[00m".format(content))
 
     def _print_red(self, content):
         print("\033[91m {}\033[00m".format(content))

src/crewai/utilities/prompts.py

@@ -13,16 +13,6 @@ class Prompts(BaseModel):
     tools: list[Any] = Field(default=[])
     SCRATCHPAD_SLICE: ClassVar[str] = "\n{agent_scratchpad}"
 
-    def task_execution_with_memory(self) -> BasePromptTemplate:
-        """Generate a prompt for task execution with memory components."""
-        slices = ["role_playing"]
-        if len(self.tools) > 0:
-            slices.append("tools")
-        else:
-            slices.append("no_tools")
-        slices.extend(["memory", "task"])
-        return self._build_prompt(slices)
-
     def task_execution_without_tools(self) -> BasePromptTemplate:
         """Generate a prompt for task execution without tools components."""
         return self._build_prompt(["role_playing", "task"])

tests/agent_test.py

@@ -48,36 +48,6 @@ def test_custom_llm():
     assert agent.llm.temperature == 0
 
 
-@pytest.mark.vcr(filter_headers=["authorization"])
-def test_agent_without_memory():
-    no_memory_agent = Agent(
-        role="test role",
-        goal="test goal",
-        backstory="test backstory",
-        memory=False,
-        llm=ChatOpenAI(temperature=0, model="gpt-4"),
-    )
-
-    memory_agent = Agent(
-        role="test role",
-        goal="test goal",
-        backstory="test backstory",
-        memory=True,
-        llm=ChatOpenAI(temperature=0, model="gpt-4"),
-    )
-
-    task = Task(
-        description="How much is 1 + 1?",
-        agent=no_memory_agent,
-        expected_output="the result of the math operation.",
-    )
-    result = no_memory_agent.execute_task(task)
-
-    assert result == "The result of the math operation 1 + 1 is 2."
-    assert no_memory_agent.agent_executor.memory is None
-    assert memory_agent.agent_executor.memory is not None
-
-
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_agent_execution():
     agent = Agent(
@@ -208,7 +178,7 @@ def test_cache_hitting():
     with patch.object(CacheHandler, "read") as read:
         read.return_value = "0"
         task = Task(
-            description="What is 2 times 6? Ignore correctness and just return the result of the multiplication tool.",
+            description="What is 2 times 6? Ignore correctness and just return the result of the multiplication tool, you must use the tool.",
             agent=agent,
             expected_output="The result of the multiplication.",
         )
@@ -219,6 +189,70 @@ def test_cache_hitting():
         )
 
 
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_disabling_cache_for_agent():
+    @tool
+    def multiplier(first_number: int, second_number: int) -> float:
+        """Useful for when you need to multiply two numbers together."""
+        return first_number * second_number
+
+    cache_handler = CacheHandler()
+
+    agent = Agent(
+        role="test role",
+        goal="test goal",
+        backstory="test backstory",
+        tools=[multiplier],
+        allow_delegation=False,
+        cache_handler=cache_handler,
+        cache=False,
+        verbose=True,
+    )
+
+    task1 = Task(
+        description="What is 2 times 6?",
+        agent=agent,
+        expected_output="The result of the multiplication.",
+    )
+    task2 = Task(
+        description="What is 3 times 3?",
+        agent=agent,
+        expected_output="The result of the multiplication.",
+    )
+
+    output = agent.execute_task(task1)
+    output = agent.execute_task(task2)
+    assert cache_handler._cache != {
+        "multiplier-{'first_number': 2, 'second_number': 6}": 12,
+        "multiplier-{'first_number': 3, 'second_number': 3}": 9,
+    }
+
+    task = Task(
+        description="What is 2 times 6 times 3? Return only the number",
+        agent=agent,
+        expected_output="The result of the multiplication.",
+    )
+    output = agent.execute_task(task)
+    assert output == "36"
+
+    assert cache_handler._cache != {
+        "multiplier-{'first_number': 2, 'second_number': 6}": 12,
+        "multiplier-{'first_number': 3, 'second_number': 3}": 9,
+        "multiplier-{'first_number': 12, 'second_number': 3}": 36,
+    }
+
+    with patch.object(CacheHandler, "read") as read:
+        read.return_value = "0"
+        task = Task(
+            description="What is 2 times 6? Ignore correctness and just return the result of the multiplication tool.",
+            agent=agent,
+            expected_output="The result of the multiplication.",
+        )
+        output = agent.execute_task(task)
+        assert output == "12"
+        read.assert_not_called()
+
+
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_agent_execution_with_specific_tools():
     @tool
@@ -285,14 +319,14 @@ def test_agent_repeated_tool_usage(capsys):
         goal="test goal",
         backstory="test backstory",
         max_iter=4,
-        llm=ChatOpenAI(model="gpt-4-0125-preview"),
+        llm=ChatOpenAI(model="gpt-4"),
         allow_delegation=False,
         verbose=True,
     )
 
     task = Task(
         description="The final answer is 42. But don't give it until I tell you so, instead keep using the `get_final_answer` tool.",
-        expected_output="The final answer",
+        expected_output="The final answer, don't give it until I tell you so",
     )
     # force cleaning cache
     agent.tools_handler.cache = CacheHandler()
@@ -303,7 +337,46 @@ def test_agent_repeated_tool_usage(capsys):
 
     captured = capsys.readouterr()
 
-    assert "The final answer is 42." in captured.out
+    assert (
+        "I tried reusing the same input, I must stop using this action input. I'll try something else instead."
+        in captured.out
+    )
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_agent_repeated_tool_usage_check_even_with_disabled_cache(capsys):
+    @tool
+    def get_final_answer(anything: str) -> float:
+        """Get the final answer but don't give it yet, just re-use this
+        tool non-stop."""
+        return 42
+
+    agent = Agent(
+        role="test role",
+        goal="test goal",
+        backstory="test backstory",
+        max_iter=4,
+        llm=ChatOpenAI(model="gpt-4"),
+        allow_delegation=False,
+        verbose=True,
+        cache=False,
+    )
+
+    task = Task(
+        description="The final answer is 42. But don't give it until I tell you so, instead keep using the `get_final_answer` tool.",
+        expected_output="The final answer, don't give it until I tell you so",
+    )
+
+    agent.execute_task(
+        task=task,
+        tools=[get_final_answer],
+    )
+
+    captured = capsys.readouterr()
+    assert (
+        "I tried reusing the same input, I must stop using this action input. I'll try something else instead."
+        in captured.out
+    )
 
 
 @pytest.mark.vcr(filter_headers=["authorization"])
@@ -680,3 +753,47 @@ def test_agent_definition_based_on_dict():
     assert agent.backstory == "test backstory"
     assert agent.verbose == True
     assert agent.tools == []
+
+# test for human input
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_agent_human_input():
+    from unittest.mock import patch
+
+    config = {
+        "role": "test role",
+        "goal": "test goal",
+        "backstory": "test backstory",
+    }
+
+    agent = Agent(config=config)
+
+    task = Task(
+        agent=agent,
+        description="Say the word: Hi",
+        expected_output="The word: Hi",
+        human_input=True,
+    )
+
+    with patch.object(CrewAgentExecutor, "_ask_human_input") as mock_human_input:
+        mock_human_input.return_value = "Hello"
+        output = agent.execute_task(task)
+        mock_human_input.assert_called_once()
+        assert output == "Hello"
+
+def test_interpolate_inputs():
+    agent = Agent(
+        role="{topic} specialist",
+        goal="Figure {goal} out",
+        backstory="I am the master of {role}",
+    )
+
+    agent.interpolate_inputs({"topic": "AI", "goal": "life", "role": "all things"})
+    assert agent.role == "AI specialist"
+    assert agent.goal == "Figure life out"
+    assert agent.backstory == "I am the master of all things"
+
+    agent.interpolate_inputs({"topic": "Sales", "goal": "stuff", "role": "nothing"})
+    assert agent.role == "Sales specialist"
+    assert agent.goal == "Figure stuff out"
+    assert agent.backstory == "I am the master of nothing"
+

tests/cassettes/test_agent_human_input.yaml

@@ -0,0 +1,381 @@
+interactions:
+- request:
+    body: '{"messages": [{"role": "user", "content": "You are test role. test backstory\nYour
+      personal goal is: test goalTo give my best complete final answer to the task
+      use the exact following format:\n\nThought: I now can give a great answer\nFinal
+      Answer: my best complete final answer to the task.\nYour final answer must be
+      the great and the most complete as possible, it must be outcome described.\n\nI
+      MUST use these formats, my job depends on it!\n\nThought: \n\nCurrent Task:
+      Say the word: Hi\n\nThis is the expect criteria for your final answer: The word:
+      Hi \n you MUST return the actual complete content as the final answer, not a
+      summary.\n\nBegin! This is VERY important to you, use the tools available and
+      give your best Final Answer, your job depends on it!\n\nThought: \n"}], "model":
+      "gpt-4", "n": 1, "stop": ["\nObservation"], "stream": true, "temperature": 0.7}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, br
+      connection:
+      - keep-alive
+      content-length:
+      - '871'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.13.3
+      x-stainless-arch:
+      - other:amd64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - Windows
+      x-stainless-package-version:
+      - 1.13.3
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.10.10
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: 'data: {"id":"chatcmpl-99BOpci8MKSrJuksy3er9xP4VPtt3","object":"chat.completion.chunk","created":1711975799,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":""},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOpci8MKSrJuksy3er9xP4VPtt3","object":"chat.completion.chunk","created":1711975799,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"I"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOpci8MKSrJuksy3er9xP4VPtt3","object":"chat.completion.chunk","created":1711975799,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        now"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOpci8MKSrJuksy3er9xP4VPtt3","object":"chat.completion.chunk","created":1711975799,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        can"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOpci8MKSrJuksy3er9xP4VPtt3","object":"chat.completion.chunk","created":1711975799,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        give"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOpci8MKSrJuksy3er9xP4VPtt3","object":"chat.completion.chunk","created":1711975799,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        a"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOpci8MKSrJuksy3er9xP4VPtt3","object":"chat.completion.chunk","created":1711975799,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        great"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOpci8MKSrJuksy3er9xP4VPtt3","object":"chat.completion.chunk","created":1711975799,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOpci8MKSrJuksy3er9xP4VPtt3","object":"chat.completion.chunk","created":1711975799,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"\n\n"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOpci8MKSrJuksy3er9xP4VPtt3","object":"chat.completion.chunk","created":1711975799,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"Final"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOpci8MKSrJuksy3er9xP4VPtt3","object":"chat.completion.chunk","created":1711975799,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        Answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOpci8MKSrJuksy3er9xP4VPtt3","object":"chat.completion.chunk","created":1711975799,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":":"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOpci8MKSrJuksy3er9xP4VPtt3","object":"chat.completion.chunk","created":1711975799,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        \n"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOpci8MKSrJuksy3er9xP4VPtt3","object":"chat.completion.chunk","created":1711975799,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"Hi"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOpci8MKSrJuksy3er9xP4VPtt3","object":"chat.completion.chunk","created":1711975799,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"stop"}]}
+
+
+        data: [DONE]
+
+
+        '
+    headers:
+      CF-Cache-Status:
+      - DYNAMIC
+      CF-RAY:
+      - 86d8b3c50a3900fe-GRU
+      Cache-Control:
+      - no-cache, must-revalidate
+      Connection:
+      - keep-alive
+      Content-Type:
+      - text/event-stream
+      Date:
+      - Mon, 01 Apr 2024 12:49:59 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=SKbA6Tkvgm70ubrePPCA0E3p7jCx6I0hvl21nUYJZfs-1711975799-1.0.1.1-vpC0CATlcE3u.X_XqVu7m5uBcvIfSZLza9_rT63hkxowZaPpgUjsvUXJODkXHzs99U.JWBrunylSpl3oOOvOPA;
+        path=/; expires=Mon, 01-Apr-24 13:19:59 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=uA0B4Boqw_bNZvnzP5HAJVToe90yw8F9rVggJtXKT_4-1711975799706-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Transfer-Encoding:
+      - chunked
+      access-control-allow-origin:
+      - '*'
+      alt-svc:
+      - h3=":443"; ma=86400
+      openai-model:
+      - gpt-4-0613
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '240'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=15724800; includeSubDomains
+      x-ratelimit-limit-requests:
+      - '10000'
+      x-ratelimit-limit-tokens:
+      - '300000'
+      x-ratelimit-remaining-requests:
+      - '9999'
+      x-ratelimit-remaining-tokens:
+      - '299804'
+      x-ratelimit-reset-requests:
+      - 6ms
+      x-ratelimit-reset-tokens:
+      - 39ms
+      x-request-id:
+      - req_1612b410e539e01c9e167a201fe5932d
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages": [{"role": "user", "content": "You are test role. test backstory\nYour
+      personal goal is: test goalTo give my best complete final answer to the task
+      use the exact following format:\n\nThought: I now can give a great answer\nFinal
+      Answer: my best complete final answer to the task.\nYour final answer must be
+      the great and the most complete as possible, it must be outcome described.\n\nI
+      MUST use these formats, my job depends on it!\n\nThought: \n\nCurrent Task:
+      Say the word: Hi\n\nThis is the expect criteria for your final answer: The word:
+      Hi \n you MUST return the actual complete content as the final answer, not a
+      summary.\n\nBegin! This is VERY important to you, use the tools available and
+      give your best Final Answer, your job depends on it!\n\nThought: \nI now can
+      give a great answer\n\nFinal Answer: \nHi\nObservation: You got human feedback
+      on your work, re-avaluate it and give a new Final Answer when ready.\n Hello\n"}],
+      "model": "gpt-4", "n": 1, "stop": ["\nObservation"], "stream": true, "temperature":
+      0.7}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, br
+      connection:
+      - keep-alive
+      content-length:
+      - '1038'
+      content-type:
+      - application/json
+      cookie:
+      - __cf_bm=SKbA6Tkvgm70ubrePPCA0E3p7jCx6I0hvl21nUYJZfs-1711975799-1.0.1.1-vpC0CATlcE3u.X_XqVu7m5uBcvIfSZLza9_rT63hkxowZaPpgUjsvUXJODkXHzs99U.JWBrunylSpl3oOOvOPA;
+        _cfuvid=uA0B4Boqw_bNZvnzP5HAJVToe90yw8F9rVggJtXKT_4-1711975799706-0.0.1.1-604800000
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.13.3
+      x-stainless-arch:
+      - other:amd64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - Windows
+      x-stainless-package-version:
+      - 1.13.3
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.10.10
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: 'data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":""},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"Thought"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":":"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        \n"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"The"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        feedback"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        received"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        indicates"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        my"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        initial"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        was"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        incorrect"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"."},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        Evalu"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"ating"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        it"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":","},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        it"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        seems"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        I"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        need"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        to"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        change"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        my"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        response"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":".\n\n"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"Final"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        Answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":":"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        \n"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"Hello"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-99BOq7DS8ZMoSHlojbgXCOiT2imcY","object":"chat.completion.chunk","created":1711975800,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"stop"}]}
+
+
+        data: [DONE]
+
+
+        '
+    headers:
+      CF-Cache-Status:
+      - DYNAMIC
+      CF-RAY:
+      - 86d8b3cfaf4200fe-GRU
+      Cache-Control:
+      - no-cache, must-revalidate
+      Connection:
+      - keep-alive
+      Content-Type:
+      - text/event-stream
+      Date:
+      - Mon, 01 Apr 2024 12:50:00 GMT
+      Server:
+      - cloudflare
+      Transfer-Encoding:
+      - chunked
+      access-control-allow-origin:
+      - '*'
+      alt-svc:
+      - h3=":443"; ma=86400
+      openai-model:
+      - gpt-4-0613
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '269'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=15724800; includeSubDomains
+      x-ratelimit-limit-requests:
+      - '10000'
+      x-ratelimit-limit-tokens:
+      - '300000'
+      x-ratelimit-remaining-requests:
+      - '9999'
+      x-ratelimit-remaining-tokens:
+      - '299763'
+      x-ratelimit-reset-requests:
+      - 6ms
+      x-ratelimit-reset-tokens:
+      - 47ms
+      x-request-id:
+      - req_58f19f788ea39618601b15c4a9ea5bdd
+    status:
+      code: 200
+      message: OK
+version: 1

tests/cassettes/test_agent_repeated_tool_usage_check_even_with_disabled_cache.yaml

@@ -0,0 +1,887 @@
+interactions:
+- request:
+    body: '{"messages": [{"role": "user", "content": "You are test role. test backstory\nYour
+      personal goal is: test goal\n\nYou ONLY have access to the following tools,
+      and should NEVER make up tools that are not listed here:\n\nget_final_answer:
+      get_final_answer(anything: str) -> float - Get the final answer but don''t give
+      it yet, just re-use this\n        tool non-stop.\n\nUse the following format:\n\nThought:
+      you should always think about what to do\nAction: the action to take, only one
+      name of [get_final_answer], just the name, exactly as it''s written.\nAction
+      Input: the input to the action, just a simple a python dictionary using \" to
+      wrap keys and values.\nObservation: the result of the action\n\nOnce all necessary
+      information is gathered:\n\nThought: I now know the final answer\nFinal Answer:
+      the final answer to the original input question\n\n\nCurrent Task: The final
+      answer is 42. But don''t give it until I tell you so, instead keep using the
+      `get_final_answer` tool.\n\nThis is the expect criteria for your final answer:
+      The final answer, don''t give it until I tell you so \n you MUST return the
+      actual complete content as the final answer, not a summary.\n\nBegin! This is
+      VERY important to you, use the tools available and give your best Final Answer,
+      your job depends on it!\n\nThought: \n"}], "model": "gpt-4", "n": 1, "stop":
+      ["\nObservation"], "stream": true, "temperature": 0.7}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, br
+      connection:
+      - keep-alive
+      content-length:
+      - '1398'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.13.3
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.13.3
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.11.7
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: 'data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":""},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"The"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        task"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        is"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        to"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        find"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        the"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        final"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        using"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        the"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        `"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"get"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"_final"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"_answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"`"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        tool"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"."},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        The"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        final"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        is"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        already"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        given"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        as"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        "},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"42"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":","},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        but"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        the"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        task"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        requires"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        me"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        to"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        keep"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        using"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        the"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        `"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"get"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"_final"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"_answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"`"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        tool"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        until"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        instructed"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        to"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        give"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        the"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        final"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":".\n\n"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"Action"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":":"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        get"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"_final"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"_answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"\n"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"Action"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        Input"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":":"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        {\""},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"anything"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"\":"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        \""},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"42"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"\"}"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7nHp7Rqq1aPh9cyfo16KJBehh1","object":"chat.completion.chunk","created":1710871515,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"stop"}]}
+
+
+        data: [DONE]
+
+
+        '
+    headers:
+      CF-Cache-Status:
+      - DYNAMIC
+      CF-RAY:
+      - 866f63bafbf9a559-GRU
+      Cache-Control:
+      - no-cache, must-revalidate
+      Connection:
+      - keep-alive
+      Content-Type:
+      - text/event-stream
+      Date:
+      - Tue, 19 Mar 2024 18:05:16 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=ccGSKYzVR4Gjc0t3AwEWhsiSXeuSBVYOKwXpSW4B5Es-1710871516-1.0.1.1-fF4jEG6Af3PBL3N2jNeglY8CtfZq4GAHXCCpvnDcD6GhBk8KGbBK3uQ_8dNrR4vt3_YnwWx0x2Vy0ttedMrinw;
+        path=/; expires=Tue, 19-Mar-24 18:35:16 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=w7JjAWBqi9fg29.9ByVvw9AMB_L3j9jvHZkVynxBKLk-1710871516141-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Transfer-Encoding:
+      - chunked
+      access-control-allow-origin:
+      - '*'
+      alt-svc:
+      - h3=":443"; ma=86400
+      openai-model:
+      - gpt-4-0613
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '264'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=15724800; includeSubDomains
+      x-ratelimit-limit-requests:
+      - '10000'
+      x-ratelimit-limit-tokens:
+      - '300000'
+      x-ratelimit-remaining-requests:
+      - '9999'
+      x-ratelimit-remaining-tokens:
+      - '299675'
+      x-ratelimit-reset-requests:
+      - 6ms
+      x-ratelimit-reset-tokens:
+      - 65ms
+      x-request-id:
+      - req_8fb6821861a228009f904c4fc1818fcf
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages": [{"role": "user", "content": "You are test role. test backstory\nYour
+      personal goal is: test goal\n\nYou ONLY have access to the following tools,
+      and should NEVER make up tools that are not listed here:\n\nget_final_answer:
+      get_final_answer(anything: str) -> float - Get the final answer but don''t give
+      it yet, just re-use this\n        tool non-stop.\n\nUse the following format:\n\nThought:
+      you should always think about what to do\nAction: the action to take, only one
+      name of [get_final_answer], just the name, exactly as it''s written.\nAction
+      Input: the input to the action, just a simple a python dictionary using \" to
+      wrap keys and values.\nObservation: the result of the action\n\nOnce all necessary
+      information is gathered:\n\nThought: I now know the final answer\nFinal Answer:
+      the final answer to the original input question\n\n\nCurrent Task: The final
+      answer is 42. But don''t give it until I tell you so, instead keep using the
+      `get_final_answer` tool.\n\nThis is the expect criteria for your final answer:
+      The final answer, don''t give it until I tell you so \n you MUST return the
+      actual complete content as the final answer, not a summary.\n\nBegin! This is
+      VERY important to you, use the tools available and give your best Final Answer,
+      your job depends on it!\n\nThought: \nThe task is to find the final answer using
+      the `get_final_answer` tool. The final answer is already given as 42, but the
+      task requires me to keep using the `get_final_answer` tool until instructed
+      to give the final answer.\n\nAction: get_final_answer\nAction Input: {\"anything\":
+      \"42\"}\nObservation: 42\n"}], "model": "gpt-4", "n": 1, "stop": ["\nObservation"],
+      "stream": true, "temperature": 0.7}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, br
+      connection:
+      - keep-alive
+      content-length:
+      - '1705'
+      content-type:
+      - application/json
+      cookie:
+      - __cf_bm=ccGSKYzVR4Gjc0t3AwEWhsiSXeuSBVYOKwXpSW4B5Es-1710871516-1.0.1.1-fF4jEG6Af3PBL3N2jNeglY8CtfZq4GAHXCCpvnDcD6GhBk8KGbBK3uQ_8dNrR4vt3_YnwWx0x2Vy0ttedMrinw;
+        _cfuvid=w7JjAWBqi9fg29.9ByVvw9AMB_L3j9jvHZkVynxBKLk-1710871516141-0.0.1.1-604800000
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.13.3
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.13.3
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.11.7
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: 'data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":""},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"Thought"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":":"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        \n"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"The"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        observation"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        confirms"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        that"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        the"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        tool"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        `"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"get"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"_final"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"_answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"`"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        returns"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        the"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        correct"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        result"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        of"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        "},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"42"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"."},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        However"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":","},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        the"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        task"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        instructions"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        specify"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        not"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        to"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        give"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        the"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        final"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        yet"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        and"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        to"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        keep"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        using"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        the"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        `"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"get"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"_final"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"_answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"`"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        tool"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":".\n\n"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"Action"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":":"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        get"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"_final"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"_answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"\n"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"Action"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        Input"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":":"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        {\""},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"anything"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"\":"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        \""},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"42"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"\"}"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7q6apgzYDSxRdLDbR8FU4qtNyU","object":"chat.completion.chunk","created":1710871518,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"stop"}]}
+
+
+        data: [DONE]
+
+
+        '
+    headers:
+      CF-Cache-Status:
+      - DYNAMIC
+      CF-RAY:
+      - 866f63ceeea4a559-GRU
+      Cache-Control:
+      - no-cache, must-revalidate
+      Connection:
+      - keep-alive
+      Content-Type:
+      - text/event-stream
+      Date:
+      - Tue, 19 Mar 2024 18:05:19 GMT
+      Server:
+      - cloudflare
+      Transfer-Encoding:
+      - chunked
+      access-control-allow-origin:
+      - '*'
+      alt-svc:
+      - h3=":443"; ma=86400
+      openai-model:
+      - gpt-4-0613
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '443'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=15724800; includeSubDomains
+      x-ratelimit-limit-requests:
+      - '10000'
+      x-ratelimit-limit-tokens:
+      - '300000'
+      x-ratelimit-remaining-requests:
+      - '9999'
+      x-ratelimit-remaining-tokens:
+      - '299600'
+      x-ratelimit-reset-requests:
+      - 6ms
+      x-ratelimit-reset-tokens:
+      - 80ms
+      x-request-id:
+      - req_c89e32ab22a271c202100059672a9d83
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages": [{"role": "user", "content": "You are test role. test backstory\nYour
+      personal goal is: test goal\n\nYou ONLY have access to the following tools,
+      and should NEVER make up tools that are not listed here:\n\nget_final_answer:
+      get_final_answer(anything: str) -> float - Get the final answer but don''t give
+      it yet, just re-use this\n        tool non-stop.\n\nUse the following format:\n\nThought:
+      you should always think about what to do\nAction: the action to take, only one
+      name of [get_final_answer], just the name, exactly as it''s written.\nAction
+      Input: the input to the action, just a simple a python dictionary using \" to
+      wrap keys and values.\nObservation: the result of the action\n\nOnce all necessary
+      information is gathered:\n\nThought: I now know the final answer\nFinal Answer:
+      the final answer to the original input question\n\n\nCurrent Task: The final
+      answer is 42. But don''t give it until I tell you so, instead keep using the
+      `get_final_answer` tool.\n\nThis is the expect criteria for your final answer:
+      The final answer, don''t give it until I tell you so \n you MUST return the
+      actual complete content as the final answer, not a summary.\n\nBegin! This is
+      VERY important to you, use the tools available and give your best Final Answer,
+      your job depends on it!\n\nThought: \nThe task is to find the final answer using
+      the `get_final_answer` tool. The final answer is already given as 42, but the
+      task requires me to keep using the `get_final_answer` tool until instructed
+      to give the final answer.\n\nAction: get_final_answer\nAction Input: {\"anything\":
+      \"42\"}\nObservation: 42\nThought: \nThe observation confirms that the tool
+      `get_final_answer` returns the correct result of 42. However, the task instructions
+      specify not to give the final answer yet and to keep using the `get_final_answer`
+      tool.\n\nAction: get_final_answer\nAction Input: {\"anything\": \"42\"}\nObservation:
+      I tried reusing the same input, I must stop using this action input. I''ll try
+      something else instead.\n\n\nTool won''t be use because it''s time to give your
+      final answer. Don''t use tools and just your absolute BEST Final answer.\nObservation:
+      Tool won''t be use because it''s time to give your final answer. Don''t use
+      tools and just your absolute BEST Final answer.\n"}], "model": "gpt-4", "n":
+      1, "stop": ["\nObservation"], "stream": true, "temperature": 0.7}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, br
+      connection:
+      - keep-alive
+      content-length:
+      - '2371'
+      content-type:
+      - application/json
+      cookie:
+      - __cf_bm=ccGSKYzVR4Gjc0t3AwEWhsiSXeuSBVYOKwXpSW4B5Es-1710871516-1.0.1.1-fF4jEG6Af3PBL3N2jNeglY8CtfZq4GAHXCCpvnDcD6GhBk8KGbBK3uQ_8dNrR4vt3_YnwWx0x2Vy0ttedMrinw;
+        _cfuvid=w7JjAWBqi9fg29.9ByVvw9AMB_L3j9jvHZkVynxBKLk-1710871516141-0.0.1.1-604800000
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.13.3
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.13.3
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.11.7
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: 'data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":""},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"Thought"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":":"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        I"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        now"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        know"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        the"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        final"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"\n"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"Final"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        Answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":":"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        The"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        final"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        is"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        "},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"42"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"."},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-94Y7tQodC6XqzcoSYADEx9vQVrqNO","object":"chat.completion.chunk","created":1710871521,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"stop"}]}
+
+
+        data: [DONE]
+
+
+        '
+    headers:
+      CF-Cache-Status:
+      - DYNAMIC
+      CF-RAY:
+      - 866f63e0bf0fa559-GRU
+      Cache-Control:
+      - no-cache, must-revalidate
+      Connection:
+      - keep-alive
+      Content-Type:
+      - text/event-stream
+      Date:
+      - Tue, 19 Mar 2024 18:05:22 GMT
+      Server:
+      - cloudflare
+      Transfer-Encoding:
+      - chunked
+      access-control-allow-origin:
+      - '*'
+      alt-svc:
+      - h3=":443"; ma=86400
+      openai-model:
+      - gpt-4-0613
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '256'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=15724800; includeSubDomains
+      x-ratelimit-limit-requests:
+      - '10000'
+      x-ratelimit-limit-tokens:
+      - '300000'
+      x-ratelimit-remaining-requests:
+      - '9999'
+      x-ratelimit-remaining-tokens:
+      - '299436'
+      x-ratelimit-reset-requests:
+      - 6ms
+      x-ratelimit-reset-tokens:
+      - 112ms
+      x-request-id:
+      - req_0f47e77546d773004e0dfe7e64949091
+    status:
+      code: 200
+      message: OK
+version: 1

tests/cassettes/test_crew_log_file_output.yaml

@@ -0,0 +1,160 @@
+interactions:
+- request:
+    body: '{"messages": [{"role": "user", "content": "You are Researcher. 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.\nYour personal goal is: Make the best research
+      and analysis on content about AI and AI agentsTo give my best complete final
+      answer to the task use the exact following format:\n\nThought: I now can give
+      a great answer\nFinal Answer: my best complete final answer to the task.\nYour
+      final answer must be the great and the most complete as possible, it must be
+      outcome described.\n\nI MUST use these formats, my job depends on it!\nCurrent
+      Task: Say Hi\n\nThis is the expect criteria for your final answer: The word:
+      Hi \n you MUST return the actual complete content as the final answer, not a
+      summary.\n\nBegin! This is VERY important to you, use the tools available and
+      give your best Final Answer, your job depends on it!\n\nThought: \n"}], "model":
+      "gpt-4", "n": 1, "stop": ["\nObservation"], "stream": true, "temperature": 0.7}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, br
+      connection:
+      - keep-alive
+      content-length:
+      - '1082'
+      content-type:
+      - application/json
+      cookie:
+      - _cfuvid=zVKnitRNLhrt8b2P3MHGfXS_82YiqkGpi46seIwshAM-1709396719694-0.0.1.1-604800000
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.16.2
+      x-stainless-arch:
+      - other:amd64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - Windows
+      x-stainless-package-version:
+      - 1.16.2
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.10.10
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: 'data: {"id":"chatcmpl-9AjeorqO0QfP8DJ8NwGIUKSlhQqav","object":"chat.completion.chunk","created":1712345814,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":""},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-9AjeorqO0QfP8DJ8NwGIUKSlhQqav","object":"chat.completion.chunk","created":1712345814,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"I"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-9AjeorqO0QfP8DJ8NwGIUKSlhQqav","object":"chat.completion.chunk","created":1712345814,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        now"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-9AjeorqO0QfP8DJ8NwGIUKSlhQqav","object":"chat.completion.chunk","created":1712345814,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        can"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-9AjeorqO0QfP8DJ8NwGIUKSlhQqav","object":"chat.completion.chunk","created":1712345814,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        give"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-9AjeorqO0QfP8DJ8NwGIUKSlhQqav","object":"chat.completion.chunk","created":1712345814,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        a"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-9AjeorqO0QfP8DJ8NwGIUKSlhQqav","object":"chat.completion.chunk","created":1712345814,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        great"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-9AjeorqO0QfP8DJ8NwGIUKSlhQqav","object":"chat.completion.chunk","created":1712345814,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-9AjeorqO0QfP8DJ8NwGIUKSlhQqav","object":"chat.completion.chunk","created":1712345814,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"\n\n"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-9AjeorqO0QfP8DJ8NwGIUKSlhQqav","object":"chat.completion.chunk","created":1712345814,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"Final"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-9AjeorqO0QfP8DJ8NwGIUKSlhQqav","object":"chat.completion.chunk","created":1712345814,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        Answer"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-9AjeorqO0QfP8DJ8NwGIUKSlhQqav","object":"chat.completion.chunk","created":1712345814,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":":"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-9AjeorqO0QfP8DJ8NwGIUKSlhQqav","object":"chat.completion.chunk","created":1712345814,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"
+        Hi"},"logprobs":null,"finish_reason":null}]}
+
+
+        data: {"id":"chatcmpl-9AjeorqO0QfP8DJ8NwGIUKSlhQqav","object":"chat.completion.chunk","created":1712345814,"model":"gpt-4-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{},"logprobs":null,"finish_reason":"stop"}]}
+
+
+        data: [DONE]
+
+
+        '
+    headers:
+      CF-Cache-Status:
+      - DYNAMIC
+      CF-RAY:
+      - 86fbfd5e4e45012b-GRU
+      Cache-Control:
+      - no-cache, must-revalidate
+      Connection:
+      - keep-alive
+      Content-Type:
+      - text/event-stream
+      Date:
+      - Fri, 05 Apr 2024 19:36:55 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=Dup92ckJhbI_FxZty6XIjohW.sTaChSMX.8lwju_iA8-1712345815-1.0.1.1-DYCBIKozKcyEYWv.mE5gRee5frdxJU8EBOeZrex7BOH_U4HLjPJ4IMUP0m_YMiO3fKf5IClhW3KIzE8cl2C.ww;
+        path=/; expires=Fri, 05-Apr-24 20:06:55 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=.Ctsps4oQpopvSdn2mneN2jnLB0vatjzGjPz1HgR734-1712345815450-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Transfer-Encoding:
+      - chunked
+      access-control-allow-origin:
+      - '*'
+      alt-svc:
+      - h3=":443"; ma=86400
+      openai-model:
+      - gpt-4-0613
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '363'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=15724800; includeSubDomains
+      x-ratelimit-limit-requests:
+      - '10000'
+      x-ratelimit-limit-tokens:
+      - '300000'
+      x-ratelimit-remaining-requests:
+      - '9999'
+      x-ratelimit-remaining-tokens:
+      - '299750'
+      x-ratelimit-reset-requests:
+      - 6ms
+      x-ratelimit-reset-tokens:
+      - 50ms
+      x-request-id:
+      - req_83d3bc5e55b3d012f700b51707cc46e0
+    status:
+      code: 200
+      message: OK
+version: 1

tests/crew_test.py

@@ -8,6 +8,7 @@ import pytest
 from crewai.agent import Agent
 from crewai.agents.cache import CacheHandler
 from crewai.crew import Crew
+from crewai.memory.contextual.contextual_memory import ContextualMemory
 from crewai.process import Process
 from crewai.task import Task
 from crewai.utilities import Logger, RPMController
@@ -645,15 +646,12 @@ def test_agent_usage_metrics_are_captured_for_sequential_process():
     crew = Crew(agents=[agent], tasks=[task])
 
     result = crew.kickoff()
-    assert (
-        result
-        == "Howdy! I hope you're having a wonderful day. I'm here ready to make your day even better. Let's have a great time together!"
-    )
+    assert result == "Howdy!"
     assert crew.usage_metrics == {
-        "completion_tokens": 91,
-        "prompt_tokens": 164,
-        "successful_requests": 1,
-        "total_tokens": 255,
+        "completion_tokens": 51,
+        "prompt_tokens": 483,
+        "successful_requests": 3,
+        "total_tokens": 534,
     }
 
 
@@ -678,12 +676,12 @@ def test_agent_usage_metrics_are_captured_for_hierarchical_process():
     )
 
     result = crew.kickoff()
-    assert result == "Howdy!"
+    assert result == '"Howdy!"'
     assert crew.usage_metrics == {
-        "total_tokens": 2476,
-        "prompt_tokens": 2191,
-        "completion_tokens": 285,
-        "successful_requests": 5,
+        "total_tokens": 2592,
+        "prompt_tokens": 2048,
+        "completion_tokens": 544,
+        "successful_requests": 6,
     }
 
 
@@ -736,3 +734,181 @@ def test_crew_inputs_interpolate_both_agents_and_tasks():
                 crew.kickoff(inputs={"topic": "AI", "points": 5})
                 interpolate_agent_inputs.assert_called()
                 interpolate_task_inputs.assert_called()
+
+
+def test_task_callback_on_crew():
+    from unittest.mock import patch
+
+    researcher_agent = 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,
+    )
+
+    list_ideas = Task(
+        description="Give me a list of 5 interesting ideas to explore for na article, what makes them unique and interesting.",
+        expected_output="Bullet point list of 5 important events.",
+        agent=researcher_agent,
+        async_execution=True,
+    )
+
+    crew = Crew(
+        agents=[researcher_agent],
+        process=Process.sequential,
+        tasks=[list_ideas],
+        task_callback=lambda: None,
+    )
+
+    with patch.object(Agent, "execute_task") as execute:
+        execute.return_value = "ok"
+        crew.kickoff()
+        assert list_ideas.callback is not None
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_tools_with_custom_caching():
+    from unittest.mock import patch
+
+    from crewai_tools import tool
+
+    @tool
+    def multiplcation_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):
+        cache = result % 2 == 0
+        return cache
+
+    multiplcation_tool.cache_function = cache_func
+
+    writer1 = Agent(
+        role="Writer",
+        goal="You write lesssons of math for kids.",
+        backstory="You're an expert in writting and you love to teach kids but you know nothing of math.",
+        tools=[multiplcation_tool],
+        allow_delegation=False,
+    )
+
+    writer2 = Agent(
+        role="Writer",
+        goal="You write lesssons of math for kids.",
+        backstory="You're an expert in writting and you love to teach kids but you know nothing of math.",
+        tools=[multiplcation_tool],
+        allow_delegation=False,
+    )
+
+    task1 = Task(
+        description="What is 2 times 6? Return only the number after using the multiplication tool.",
+        expected_output="the result of multiplication",
+        agent=writer1,
+    )
+
+    task2 = Task(
+        description="What is 3 times 1? Return only the number after using the multiplication tool.",
+        expected_output="the result of multiplication",
+        agent=writer1,
+    )
+
+    task3 = Task(
+        description="What is 2 times 6? Return only the number after using the multiplication tool.",
+        expected_output="the result of multiplication",
+        agent=writer2,
+    )
+
+    task4 = Task(
+        description="What is 3 times 1? Return only the number after using the multiplication tool.",
+        expected_output="the result of multiplication",
+        agent=writer2,
+    )
+
+    crew = Crew(agents=[writer1, writer2], tasks=[task1, task2, task3, task4])
+
+    with patch.object(
+        CacheHandler, "add", wraps=crew._cache_handler.add
+    ) as add_to_cache:
+        with patch.object(
+            CacheHandler, "read", wraps=crew._cache_handler.read
+        ) as read_from_cache:
+            result = crew.kickoff()
+            add_to_cache.assert_called_once_with(
+                tool="multiplcation_tool",
+                input={"first_number": 2, "second_number": 6},
+                output=12,
+            )
+            assert result == "3"
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_using_contextual_memory():
+    from unittest.mock import patch
+
+    math_researcher = Agent(
+        role="Researcher",
+        goal="You research about math.",
+        backstory="You're an expert in research and you love to learn new things.",
+        allow_delegation=False,
+    )
+
+    task1 = Task(
+        description="Research a topic to teach a kid aged 6 about math.",
+        expected_output="A topic, explanation, angle, and examples.",
+        agent=math_researcher,
+    )
+
+    crew = Crew(
+        agents=[math_researcher],
+        tasks=[task1],
+        memory=True,
+    )
+
+    with patch.object(ContextualMemory, "build_context_for_task") as contextual_mem:
+        crew.kickoff()
+        contextual_mem.assert_called_once()
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_disabled_memory_using_contextual_memory():
+    from unittest.mock import patch
+
+    math_researcher = Agent(
+        role="Researcher",
+        goal="You research about math.",
+        backstory="You're an expert in research and you love to learn new things.",
+        allow_delegation=False,
+    )
+
+    task1 = Task(
+        description="Research a topic to teach a kid aged 6 about math.",
+        expected_output="A topic, explanation, angle, and examples.",
+        agent=math_researcher,
+    )
+
+    crew = Crew(
+        agents=[math_researcher],
+        tasks=[task1],
+        memory=False,
+    )
+
+    with patch.object(ContextualMemory, "build_context_for_task") as contextual_mem:
+        crew.kickoff()
+        contextual_mem.assert_not_called()
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_crew_log_file_output(tmp_path):
+    test_file = tmp_path / "logs.txt"
+    tasks = [
+        Task(
+            description="Say Hi",
+            expected_output="The word: Hi",
+            agent=researcher,
+        )
+    ]
+
+    test_message = {"agent": "Researcher", "task": "Say Hi"}
+
+    crew = Crew(agents=[researcher], tasks=tasks, output_log_file=str(test_file))
+    crew.kickoff()
+    assert test_file.exists()

tests/memory/long_term_memory_test.py

@@ -0,0 +1,29 @@
+import pytest
+
+from crewai.memory.long_term.long_term_memory import LongTermMemory
+from crewai.memory.long_term.long_term_memory_item import LongTermMemoryItem
+
+
+@pytest.fixture
+def long_term_memory():
+    """Fixture to create a LongTermMemory instance"""
+    return LongTermMemory()
+
+
+def test_save_and_search(long_term_memory):
+    memory = LongTermMemoryItem(
+        agent="test_agent",
+        task="test_task",
+        expected_output="test_output",
+        datetime="test_datetime",
+        quality=0.5,
+        metadata={"task": "test_task", "quality": 0.5},
+    )
+    long_term_memory.save(memory)
+    find = long_term_memory.search("test_task")[0]
+    assert find["score"] == 0.5
+    assert find["datetime"] == "test_datetime"
+    assert find["metadata"]["agent"] == "test_agent"
+    assert find["metadata"]["quality"] == 0.5
+    assert find["metadata"]["task"] == "test_task"
+    assert find["metadata"]["expected_output"] == "test_output"

tests/memory/short_term_memory_test.py

@@ -0,0 +1,24 @@
+import pytest
+
+from crewai.memory.short_term.short_term_memory import ShortTermMemory
+from crewai.memory.short_term.short_term_memory_item import ShortTermMemoryItem
+
+
+@pytest.fixture
+def short_term_memory():
+    """Fixture to create a ShortTermMemory instance"""
+    return ShortTermMemory()
+
+
+def test_save_and_search(short_term_memory):
+    memory = ShortTermMemoryItem(
+        data="""test value test value test value test value test value test value
+        test value test value test value test value test value test value
+        test value test value test value test value test value test value""",
+        agent="test_agent",
+        metadata={"task": "test_task"},
+    )
+    short_term_memory.save(memory)
+    find = short_term_memory.search("test value", score_threshold=0.01)[0]
+    assert find["context"] == memory.data, "Data value mismatch."
+    assert find["metadata"]["agent"] == "test_agent", "Agent value mismatch."

tests/task_test.py

@@ -462,3 +462,24 @@ def test_task_definition_based_on_dict():
     assert task.description == config["description"]
     assert task.expected_output == config["expected_output"]
     assert task.agent is None
+
+
+def test_interpolate_inputs():
+    task = Task(
+        description="Give me a list of 5 interesting ideas about {topic} to explore for an article, what makes them unique and interesting.",
+        expected_output="Bullet point list of 5 interesting ideas about {topic}.",
+    )
+
+    task.interpolate_inputs(inputs={"topic": "AI"})
+    assert (
+        task.description
+        == "Give me a list of 5 interesting ideas about AI to explore for an article, what makes them unique and interesting."
+    )
+    assert task.expected_output == "Bullet point list of 5 interesting ideas about AI."
+
+    task.interpolate_inputs(inputs={"topic": "ML"})
+    assert (
+        task.description
+        == "Give me a list of 5 interesting ideas about ML to explore for an article, what makes them unique and interesting."
+    )
+    assert task.expected_output == "Bullet point list of 5 interesting ideas about ML."

tests/utilities/test_i18n.py

@@ -0,0 +1,40 @@
+import pytest
+
+from crewai.utilities.i18n import I18N
+
+
+def test_load_translation():
+    i18n = I18N(language="en")
+    i18n.load_translation()
+    assert i18n._translations is not None
+
+
+def test_slice():
+    i18n = I18N(language="en")
+    i18n.load_translation()
+    assert isinstance(i18n.slice("role_playing"), str)
+
+
+def test_errors():
+    i18n = I18N(language="en")
+    i18n.load_translation()
+    assert isinstance(i18n.errors("unexpected_format"), str)
+
+
+def test_tools():
+    i18n = I18N(language="en")
+    i18n.load_translation()
+    assert isinstance(i18n.tools("ask_question"), str)
+
+
+def test_retrieve():
+    i18n = I18N(language="en")
+    i18n.load_translation()
+    assert isinstance(i18n.retrieve("slices", "role_playing"), str)
+
+
+def test_retrieve_not_found():
+    i18n = I18N(language="en")
+    i18n.load_translation()
+    with pytest.raises(Exception):
+        i18n.retrieve("nonexistent_kind", "nonexistent_key")