Merge branch 'main' into feat/individual-react-agent

Created a new Excalidraw file that includes a diagram illustrating the input box, database, and output box with connecting arrows. This visual aid enhances understanding of the data flow within the application.

.github/workflows/notify-downstream.yml

@@ -1,33 +0,0 @@
-name: Notify Downstream
-
-on:
-  push:
-    branches:
-      - main
-
-permissions:
-  contents: read
-
-jobs:
-  notify-downstream:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Generate GitHub App token
-        id: app-token
-        uses: tibdex/github-app-token@v2
-        with:
-          app_id: ${{ secrets.OSS_SYNC_APP_ID }}
-          private_key: ${{ secrets.OSS_SYNC_APP_PRIVATE_KEY }}
-
-      - name: Notify Repo B
-        uses: peter-evans/repository-dispatch@v3
-        with:
-          token: ${{ steps.app-token.outputs.token }}
-          repository: ${{ secrets.OSS_SYNC_DOWNSTREAM_REPO }}
-          event-type: upstream-commit
-          client-payload: |
-            {
-              "commit_sha": "${{ github.sha }}"
-            }
-

.github/workflows/tests.yml

@@ -12,9 +12,6 @@ jobs:
   tests:
     runs-on: ubuntu-latest
     timeout-minutes: 15
-    strategy:
-      matrix:
-        python-version: ['3.10', '3.11', '3.12']
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
@@ -24,8 +21,9 @@ jobs:
         with:
           enable-cache: true
 
-      - name: Set up Python ${{ matrix.python-version }}
-        run: uv python install ${{ matrix.python-version }}
+
+      - name: Set up Python
+        run: uv python install 3.12.8
 
       - name: Install the project
         run: uv sync --dev --all-extras

.gitignore

@@ -25,5 +25,4 @@ agentops.log
 test_flow.html
 crewairules.mdc
 plan.md
-conceptual_plan.md
-build_image
+conceptual_plan.md

README.md

@@ -257,14 +257,10 @@ reporting_task:
 from crewai import Agent, Crew, Process, Task
 from crewai.project import CrewBase, agent, crew, task
 from crewai_tools import SerperDevTool
-from crewai.agents.agent_builder.base_agent import BaseAgent
-from typing import List
 
 @CrewBase
 class LatestAiDevelopmentCrew():
 	"""LatestAiDevelopment crew"""
-	agents: List[BaseAgent]
-	tasks: List[Task]
 
 	@agent
 	def researcher(self) -> Agent:

docs/changelog.mdx

@@ -4,36 +4,6 @@ description: View the latest updates and changes to CrewAI
 icon: timeline
 ---
 
-<Update label="2025-04-07" description="v0.114.0">
-  ## Release Highlights
-  <Frame>
-    <img src="/images/v01140.png" />
-  </Frame>
-
-  **New Features & Enhancements**
-  - Agents as an atomic unit. (`Agent(...).kickoff()`)
-  - Support for [Custom LLM implementations](https://docs.crewai.com/guides/advanced/custom-llm).
-  - Integrated External Memory and [Opik observability](https://docs.crewai.com/how-to/opik-observability).
-  - Enhanced YAML extraction.
-  - Multimodal agent validation.
-  - Added Secure fingerprints for agents and crews.
-
-  **Core Improvements & Fixes**
-  - Improved serialization, agent copying, and Python compatibility.
-  - Added wildcard support to `emit()`
-  - Added support for additional router calls and context window adjustments.
-  - Fixed typing issues, validation, and import statements.
-  - Improved method performance.
-  - Enhanced agent task handling, event emissions, and memory management.
-  - Fixed CLI issues, conditional tasks, cloning behavior, and tool outputs.
-
-  **Documentation & Guides**
-  - Improved documentation structure, theme, and organization.
-  - Added guides for Local NVIDIA NIM with WSL2, W&B Weave, and Arize Phoenix.
-  - Updated tool configuration examples, prompts, and observability docs.
-  - Guide on using singular agents within Flows.
-</Update>
-
 <Update label="2025-03-17" description="v0.108.0">
   **Features**
   - Converted tabs to spaces in `crew.py` template

docs/concepts/agents.mdx

@@ -18,18 +18,6 @@ In the CrewAI framework, an `Agent` is an autonomous unit that can:
 Think of an agent as a specialized team member with specific skills, expertise, and responsibilities. For example, a `Researcher` agent might excel at gathering and analyzing information, while a `Writer` agent might be better at creating content.
 </Tip>
 
-<Note type="info" title="Enterprise Enhancement: Visual Agent Builder">
-CrewAI Enterprise includes a Visual Agent Builder that simplifies agent creation and configuration without writing code. Design your agents visually and test them in real-time.
-
-![Visual Agent Builder Screenshot](../images/enterprise/crew-studio-quickstart)
-
-The Visual Agent Builder enables:
-- Intuitive agent configuration with form-based interfaces
-- Real-time testing and validation
-- Template library with pre-configured agent types
-- Easy customization of agent attributes and behaviors
-</Note>
-
 ## Agent Attributes
 
 | Attribute                               | Parameter                | Type                          | Description                                                                                                          |
@@ -118,7 +106,7 @@ class LatestAiDevelopmentCrew():
   @agent
   def researcher(self) -> Agent:
     return Agent(
-      config=self.agents_config['researcher'], # type: ignore[index]
+      config=self.agents_config['researcher'],
       verbose=True,
       tools=[SerperDevTool()]
     )
@@ -126,7 +114,7 @@ class LatestAiDevelopmentCrew():
   @agent
   def reporting_analyst(self) -> Agent:
     return Agent(
-      config=self.agents_config['reporting_analyst'], # type: ignore[index]
+      config=self.agents_config['reporting_analyst'],
       verbose=True
     )
 ```
@@ -245,7 +233,7 @@ custom_agent = Agent(
 
 #### Code Execution
 - `allow_code_execution`: Must be True to run code
-- `code_execution_mode`:
+- `code_execution_mode`: 
   - `"safe"`: Uses Docker (recommended for production)
   - `"unsafe"`: Direct execution (use only in trusted environments)
 

docs/concepts/cli.mdx

@@ -179,78 +179,7 @@ def crew(self) -> Crew:
 ```
 </Note>
 
-### 10. Deploy
-
-Deploy the crew or flow to [CrewAI Enterprise](https://app.crewai.com).
-
-- **Authentication**: You need to be authenticated to deploy to CrewAI Enterprise.
-    ```shell Terminal
-    crewai signup
-    ```
-    If you already have an account, you can login with:
-    ```shell Terminal
-    crewai login
-    ```
-
-- **Create a deployment**: Once you are authenticated, you can create a deployment for your crew or flow from the root of your localproject.
-    ```shell Terminal
-    crewai deploy create
-    ```
-    - Reads your local project configuration.
-    - Prompts you to confirm the environment variables (like `OPENAI_API_KEY`, `SERPER_API_KEY`) found locally. These will be securely stored with the deployment on the Enterprise platform. Ensure your sensitive keys are correctly configured locally (e.g., in a `.env` file) before running this.
-    - Links the deployment to the corresponding remote GitHub repository (it usually detects this automatically).
-
-- **Deploy the Crew**: Once you are authenticated, you can deploy your crew or flow to CrewAI Enterprise.
-    ```shell Terminal
-    crewai deploy push
-    ``` 
-    - Initiates the deployment process on the CrewAI Enterprise platform.
-    - Upon successful initiation, it will output the Deployment created successfully! message along with the Deployment Name and a unique Deployment ID (UUID).
-
-- **Deployment Status**: You can check the status of your deployment with:
-    ```shell Terminal
-    crewai deploy status
-    ```
-    This fetches the latest deployment status of your most recent deployment attempt (e.g., `Building Images for Crew`, `Deploy Enqueued`, `Online`).
-
-- **Deployment Logs**: You can check the logs of your deployment with:
-    ```shell Terminal
-    crewai deploy logs
-    ```
-    This streams the deployment logs to your terminal.
-
-- **List deployments**: You can list all your deployments with:
-    ```shell Terminal
-    crewai deploy list
-    ```
-    This lists all your deployments.
-
-- **Delete a deployment**: You can delete a deployment with:
-    ```shell Terminal
-    crewai deploy remove
-    ```
-    This deletes the deployment from the CrewAI Enterprise platform.
-
-- **Help Command**: You can get help with the CLI with:
-    ```shell Terminal
-    crewai deploy --help
-    ```
-    This shows the help message for the CrewAI Deploy CLI.
-
-Watch this video tutorial for a step-by-step demonstration of deploying your crew to [CrewAI Enterprise](http://app.crewai.com) using the CLI.
-
-<iframe
-  width="100%"
-  height="400"
-  src="https://www.youtube.com/embed/3EqSV-CYDZA"
-  title="CrewAI Deployment Guide"
-  frameborder="0"
-  style={{ borderRadius: '10px' }}
-  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
-  allowfullscreen
-></iframe>
-
-### 11. API Keys
+### 10. API Keys
 
 When running ```crewai create crew``` command, the CLI will first show you the top 5 most common LLM providers and ask you to select one.
 

docs/concepts/collaboration.mdx

@@ -23,7 +23,8 @@ The `Crew` class has been enriched with several attributes to support advanced f
 | **Process Flow** (`process`)           | Defines execution logic (e.g., sequential, hierarchical) for task distribution.                                                                                                                                                |
 | **Verbose Logging** (`verbose`)        | Provides detailed logging for monitoring and debugging. Accepts integer and boolean values to control verbosity level.                                                                                                       |
 | **Rate Limiting** (`max_rpm`)          | Limits requests per minute to optimize resource usage. Setting guidelines depend on task complexity and load.                                                                                                                 |
-| **Internationalization / Customization** (`prompt_file`) | Supports prompt customization for global usability. [Example of file](https://github.com/joaomdmoura/crewAI/blob/main/src/crewai/translations/en.json)                                                                                      |
+| **Internationalization / Customization** (`language`, `prompt_file`) | Supports prompt customization for global usability. [Example of file](https://github.com/joaomdmoura/crewAI/blob/main/src/crewai/translations/en.json)                                                                                      |
+| **Execution and Output Handling** (`full_output`) | Controls output granularity, distinguishing between full and final outputs.                                                                                                                                                  |
 | **Callback and Telemetry** (`step_callback`, `task_callback`) | Enables step-wise and task-level execution monitoring and telemetry for performance analytics.                                                                                                                               |
 | **Crew Sharing** (`share_crew`)        | Allows sharing crew data with CrewAI for model improvement. Privacy implications and benefits should be considered.                                                                                                          |
 | **Usage Metrics** (`usage_metrics`)    | Logs all LLM usage metrics during task execution for performance insights.                                                                                                                           |
@@ -48,4 +49,4 @@ Consider a crew with a researcher agent tasked with data gathering and a writer
 
 ## 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/concepts/crews.mdx

@@ -20,10 +20,13 @@ A crew in crewAI represents a collaborative group of agents working together to
 | **Function Calling LLM** _(optional)_ | `function_calling_llm` | If passed, the crew will use this LLM to do function calling for tools for all agents in the crew. Each agent can have its own LLM, which overrides the crew's LLM for function calling.                                                                  |
 | **Config** _(optional)_               | `config`               | Optional configuration settings for the crew, in `Json` or `Dict[str, Any]` format.                                                                                                                                                                       |
 | **Max RPM** _(optional)_              | `max_rpm`              | Maximum requests per minute the crew adheres to during execution. Defaults to `None`.                                                                                                                                                                     |
+| **Language** _(optional)_             | `language`             | Language used for the crew, defaults to English.                                                                                                                                                                                                          |
+| **Language File** _(optional)_        | `language_file`        | Path to the language file to be used for the crew.                                                                                                                                                                                                        |
 | **Memory** _(optional)_               | `memory`               | Utilized for storing execution memories (short-term, long-term, entity memory).                                                                                                                                                                           |
 | **Memory Config** _(optional)_        | `memory_config`        | Configuration for the memory provider to be used by the crew.                                                                                                                                                                                             |
 | **Cache** _(optional)_                | `cache`                | Specifies whether to use a cache for storing the results of tools' execution. Defaults to `True`.                                                                                                                                                         |
 | **Embedder** _(optional)_             | `embedder`             | Configuration for the embedder to be used by the crew. Mostly used by memory for now. Default is `{"provider": "openai"}`.                                                                                                                                |
+| **Full Output** _(optional)_          | `full_output`          | Whether the crew should return the full output with all tasks outputs or just the final output. Defaults to `False`.                                                                                                                                      |
 | **Step Callback** _(optional)_        | `step_callback`        | A function that is called after each step of every agent. This can be used to log the agent's actions or to perform other operations; it won't override the agent-specific `step_callback`.                                                               |
 | **Task Callback** _(optional)_        | `task_callback`        | A function that is called after the completion of each task. Useful for monitoring or additional operations post-task execution.                                                                                                                          |
 | **Share Crew** _(optional)_           | `share_crew`           | Whether you want to share the complete crew information and execution with the crewAI team to make the library better, and allow us to train models.                                                                                                      |
@@ -52,16 +55,12 @@ After creating your CrewAI project as outlined in the [Installation](/installati
 ```python code
 from crewai import Agent, Crew, Task, Process
 from crewai.project import CrewBase, agent, task, crew, before_kickoff, after_kickoff
-from crewai.agents.agent_builder.base_agent import BaseAgent
-from typing import List
+
 
 @CrewBase
 class YourCrewName:
     """Description of your crew"""
 
-    agents: List[BaseAgent]
-    tasks: List[Task]
-
     # Paths to your YAML configuration files
     # To see an example agent and task defined in YAML, checkout the following:
     # - Task: https://docs.crewai.com/concepts/tasks#yaml-configuration-recommended
@@ -84,27 +83,27 @@ class YourCrewName:
     @agent
     def agent_one(self) -> Agent:
         return Agent(
-            config=self.agents_config['agent_one'], # type: ignore[index]
+            config=self.agents_config['agent_one'],
             verbose=True
         )
 
     @agent
     def agent_two(self) -> Agent:
         return Agent(
-            config=self.agents_config['agent_two'], # type: ignore[index]
+            config=self.agents_config['agent_two'],
             verbose=True
         )
 
     @task
     def task_one(self) -> Task:
         return Task(
-            config=self.tasks_config['task_one'] # type: ignore[index]
+            config=self.tasks_config['task_one']
         )
 
     @task
     def task_two(self) -> Task:
         return Task(
-            config=self.tasks_config['task_two'] # type: ignore[index]
+            config=self.tasks_config['task_two']
         )
 
     @crew

docs/concepts/event-listener.mdx

@@ -18,20 +18,6 @@ CrewAI uses an event bus architecture to emit events throughout the execution li
 
 When specific actions occur in CrewAI (like a Crew starting execution, an Agent completing a task, or a tool being used), the system emits corresponding events. You can register handlers for these events to execute custom code when they occur.
 
-<Note type="info" title="Enterprise Enhancement: Prompt Tracing">
-CrewAI Enterprise provides a built-in Prompt Tracing feature that leverages the event system to track, store, and visualize all prompts, completions, and associated metadata. This provides powerful debugging capabilities and transparency into your agent operations.
-
-![Prompt Tracing Dashboard](../images/enterprise/prompt-tracing.png)
-
-With Prompt Tracing you can:
-- View the complete history of all prompts sent to your LLM
-- Track token usage and costs
-- Debug agent reasoning failures
-- Share prompt sequences with your team
-- Compare different prompt strategies
-- Export traces for compliance and auditing
-</Note>
-
 ## Creating a Custom Event Listener
 
 To create a custom event listener, you need to:
@@ -54,17 +40,17 @@ from crewai.utilities.events.base_event_listener import BaseEventListener
 class MyCustomListener(BaseEventListener):
     def __init__(self):
         super().__init__()
-
+    
     def setup_listeners(self, crewai_event_bus):
         @crewai_event_bus.on(CrewKickoffStartedEvent)
         def on_crew_started(source, event):
             print(f"Crew '{event.crew_name}' has started execution!")
-
+        
         @crewai_event_bus.on(CrewKickoffCompletedEvent)
         def on_crew_completed(source, event):
             print(f"Crew '{event.crew_name}' has completed execution!")
             print(f"Output: {event.output}")
-
+        
         @crewai_event_bus.on(AgentExecutionCompletedEvent)
         def on_agent_execution_completed(source, event):
             print(f"Agent '{event.agent.role}' completed task")
@@ -97,7 +83,7 @@ my_listener = MyCustomListener()
 
 class MyCustomCrew:
     # Your crew implementation...
-
+    
     def crew(self):
         return Crew(
             agents=[...],
@@ -120,7 +106,7 @@ my_listener = MyCustomListener()
 
 class MyCustomFlow(Flow):
     # Your flow implementation...
-
+    
     @start()
     def first_step(self):
         # ...
@@ -338,9 +324,9 @@ with crewai_event_bus.scoped_handlers():
     @crewai_event_bus.on(CrewKickoffStartedEvent)
     def temp_handler(source, event):
         print("This handler only exists within this context")
-
+    
     # Do something that emits events
-
+    
 # Outside the context, the temporary handler is removed
 ```
 

docs/concepts/flows.mdx

@@ -545,20 +545,16 @@ The `third_method` and `fourth_method` listen to the output of the `second_metho
 
 When you run this Flow, the output will change based on the random boolean value generated by the `start_method`.
 
-## Adding Agents to Flows
+## Adding LiteAgent to Flows
 
-Agents can be seamlessly integrated into your flows, providing a lightweight alternative to full Crews when you need simpler, focused task execution. Here's an example of how to use an Agent within a flow to perform market research:
+LiteAgents can be seamlessly integrated into your flows, providing a lightweight alternative to full Crews when you need simpler, focused task execution. Here's an example of how to use a LiteAgent within a flow to perform market research:
 
 ```python
-import asyncio
-from typing import Any, Dict, List
-
-from crewai_tools import SerperDevTool
+from typing import List, cast
+from crewai_tools.tools.website_search.website_search_tool import WebsiteSearchTool
 from pydantic import BaseModel, Field
-
-from crewai.agent import Agent
 from crewai.flow.flow import Flow, listen, start
-
+from crewai.lite_agent import LiteAgent
 
 # Define a structured output format
 class MarketAnalysis(BaseModel):
@@ -566,30 +562,28 @@ class MarketAnalysis(BaseModel):
     market_size: str = Field(description="Estimated market size")
     competitors: List[str] = Field(description="Major competitors in the space")
 
-
 # Define flow state
 class MarketResearchState(BaseModel):
     product: str = ""
     analysis: MarketAnalysis | None = None
 
-
-# Create a flow class
 class MarketResearchFlow(Flow[MarketResearchState]):
     @start()
-    def initialize_research(self) -> Dict[str, Any]:
+    def initialize_research(self):
         print(f"Starting market research for {self.state.product}")
-        return {"product": self.state.product}
 
     @listen(initialize_research)
-    async def analyze_market(self) -> Dict[str, Any]:
-        # Create an Agent for market research
-        analyst = Agent(
+    def analyze_market(self):
+        # Create a LiteAgent for market research
+        analyst = LiteAgent(
             role="Market Research Analyst",
             goal=f"Analyze the market for {self.state.product}",
             backstory="You are an experienced market analyst with expertise in "
             "identifying market trends and opportunities.",
-            tools=[SerperDevTool()],
+            llm="gpt-4o",
+            tools=[WebsiteSearchTool()],
             verbose=True,
+            response_format=MarketAnalysis,
         )
 
         # Define the research query
@@ -598,65 +592,49 @@ class MarketResearchFlow(Flow[MarketResearchState]):
         1. Key market trends
         2. Market size
         3. Major competitors
-
+        
         Format your response according to the specified structure.
         """
 
-        # Execute the analysis with structured output format
-        result = await analyst.kickoff_async(query, response_format=MarketAnalysis)
-        if result.pydantic:
-            print("result", result.pydantic)
-        else:
-            print("result", result)
-
-        # Return the analysis to update the state
-        return {"analysis": result.pydantic}
+        # Execute the analysis
+        result = analyst.kickoff(query)
+        self.state.analysis = cast(MarketAnalysis, result.pydantic)
+        return result.pydantic
 
     @listen(analyze_market)
-    def present_results(self, analysis) -> None:
+    def present_results(self):
+        analysis = self.state.analysis
+        if analysis is None:
+            print("No analysis results available")
+            return
+
         print("\nMarket Analysis Results")
         print("=====================")
 
-        if isinstance(analysis, dict):
-            # If we got a dict with 'analysis' key, extract the actual analysis object
-            market_analysis = analysis.get("analysis")
-        else:
-            market_analysis = analysis
+        print("\nKey Market Trends:")
+        for trend in analysis.key_trends:
+            print(f"- {trend}")
 
-        if market_analysis and isinstance(market_analysis, MarketAnalysis):
-            print("\nKey Market Trends:")
-            for trend in market_analysis.key_trends:
-                print(f"- {trend}")
-
-            print(f"\nMarket Size: {market_analysis.market_size}")
-
-            print("\nMajor Competitors:")
-            for competitor in market_analysis.competitors:
-                print(f"- {competitor}")
-        else:
-            print("No structured analysis data available.")
-            print("Raw analysis:", analysis)
+        print(f"\nMarket Size: {analysis.market_size}")
 
+        print("\nMajor Competitors:")
+        for competitor in analysis.competitors:
+            print(f"- {competitor}")
 
 # Usage example
-async def run_flow():
-    flow = MarketResearchFlow()
-    result = await flow.kickoff_async(inputs={"product": "AI-powered chatbots"})
-    return result
-
-
-# Run the flow
-if __name__ == "__main__":
-    asyncio.run(run_flow())
+flow = MarketResearchFlow()
+result = flow.kickoff(inputs={"product": "AI-powered chatbots"})
 ```
 
-This example demonstrates several key features of using Agents in flows:
+This example demonstrates several key features of using LiteAgents in flows:
 
 1. **Structured Output**: Using Pydantic models to define the expected output format (`MarketAnalysis`) ensures type safety and structured data throughout the flow.
 
 2. **State Management**: The flow state (`MarketResearchState`) maintains context between steps and stores both inputs and outputs.
 
-3. **Tool Integration**: Agents can use tools (like `WebsiteSearchTool`) to enhance their capabilities.
+3. **Tool Integration**: LiteAgents can use tools (like `WebsiteSearchTool`) to enhance their capabilities.
+
+If you want to learn more about LiteAgents, check out the [LiteAgent](/concepts/lite-agent) page.
 
 ## Adding Crews to Flows
 

docs/concepts/knowledge.mdx

@@ -42,16 +42,6 @@ CrewAI supports various types of knowledge sources out of the box:
 | `collection_name`          | **str**                              | No       | Name of the collection where the knowledge will be stored. Used to identify different sets of knowledge. Defaults to "knowledge" if not provided.     |
 | `storage`                  | **Optional[KnowledgeStorage]**       | No       | Custom storage configuration for managing how the knowledge is stored and retrieved. If not provided, a default storage will be created.              |
 
-
-<Tip>
-Unlike retrieval from a vector database using a tool, agents preloaded with knowledge will not need a retrieval persona or task.
-Simply add the relevant knowledge sources your agent or crew needs to function.
-
-Knowledge sources can be added at the agent or crew level.
-Crew level knowledge sources will be used by **all agents** in the crew.
-Agent level knowledge sources will be used by the **specific agent** that is preloaded with the knowledge.
-</Tip>
-
 ## Quickstart Example
 
 <Tip>
@@ -156,26 +146,6 @@ result = crew.kickoff(
 )
 ```
 
-## Knowledge Configuration
-
-You can configure the knowledge configuration for the crew or agent.
-
-```python Code
-from crewai.knowledge.knowledge_config import KnowledgeConfig
-
-knowledge_config = KnowledgeConfig(results_limit=10, score_threshold=0.5)
-
-agent = Agent(
-    ...
-    knowledge_config=knowledge_config
-)
-```
-
-<Tip>
-  `results_limit`: is the number of relevant documents to return. Default is 3.
-  `score_threshold`: is the minimum score for a document to be considered relevant. Default is 0.35.
-</Tip>
-
 ## More Examples
 
 Here are examples of how to use different types of knowledge sources:

docs/concepts/langchain-tools.mdx

@@ -1,10 +1,10 @@
 ---
-title: LangChain Tool
-description: The `LangChainTool` is a wrapper for LangChain tools and query engines.
+title: Using LangChain Tools
+description: Learn how to integrate LangChain tools with CrewAI agents to enhance search-based queries and more.
 icon: link
 ---
 
-## `LangChainTool`
+## Using LangChain Tools
 
 <Info>
     CrewAI seamlessly integrates with LangChain's comprehensive [list of tools](https://python.langchain.com/docs/integrations/tools/), all of which can be used with CrewAI.

docs/concepts/lite-agent.mdx

@@ -0,0 +1,242 @@
+---
+title: LiteAgent
+description: A lightweight, single-purpose agent for simple autonomous tasks within the CrewAI framework.
+icon: feather
+---
+
+## Overview
+
+A `LiteAgent` is a streamlined version of CrewAI's Agent, designed for simpler, standalone tasks that don't require the full complexity of a crew-based workflow. It's perfect for quick automations, single-purpose tasks, or when you need a lightweight solution.
+
+<Tip>
+  Think of a LiteAgent as a specialized worker that excels at individual tasks.
+  While regular Agents are team players in a crew, LiteAgents are solo
+  performers optimized for specific operations.
+</Tip>
+
+## LiteAgent Attributes
+
+| Attribute                        | Parameter         | Type                   | Description                                                     |
+| :------------------------------- | :---------------- | :--------------------- | :-------------------------------------------------------------- |
+| **Role**                         | `role`            | `str`                  | Defines the agent's function and expertise.                     |
+| **Goal**                         | `goal`            | `str`                  | The specific objective that guides the agent's actions.         |
+| **Backstory**                    | `backstory`       | `str`                  | Provides context and personality to the agent.                  |
+| **LLM** _(optional)_             | `llm`             | `Union[str, LLM, Any]` | Language model powering the agent. Defaults to "gpt-4".         |
+| **Tools** _(optional)_           | `tools`           | `List[BaseTool]`       | Capabilities available to the agent. Defaults to an empty list. |
+| **Verbose** _(optional)_         | `verbose`         | `bool`                 | Enable detailed execution logs. Default is False.               |
+| **Response Format** _(optional)_ | `response_format` | `Type[BaseModel]`      | Pydantic model for structured output. Optional.                 |
+
+## Creating a LiteAgent
+
+Here's a simple example of creating and using a standalone LiteAgent:
+
+```python
+from typing import List, cast
+
+from crewai_tools import SerperDevTool
+from pydantic import BaseModel, Field
+
+from crewai.lite_agent import LiteAgent
+
+
+# Define a structured output format
+class MovieReview(BaseModel):
+    title: str = Field(description="The title of the movie")
+    rating: float = Field(description="Rating out of 10")
+    pros: List[str] = Field(description="List of positive aspects")
+    cons: List[str] = Field(description="List of negative aspects")
+
+
+# Create a LiteAgent
+critic = LiteAgent(
+    role="Movie Critic",
+    goal="Provide insightful movie reviews",
+    backstory="You are an experienced film critic known for balanced, thoughtful reviews.",
+    tools=[SerperDevTool()],
+    verbose=True,
+    response_format=MovieReview,
+)
+
+# Use the agent
+query = """
+Review the movie 'Inception'. Include:
+1. Your rating out of 10
+2. Key positive aspects
+3. Areas that could be improved
+"""
+
+result = critic.kickoff(query)
+
+
+# Access the structured output
+review = cast(MovieReview, result.pydantic)
+print(f"\nMovie Review: {review.title}")
+print(f"Rating: {review.rating}/10")
+print("\nPros:")
+for pro in review.pros:
+    print(f"- {pro}")
+print("\nCons:")
+for con in review.cons:
+    print(f"- {con}")
+
+```
+
+This example demonstrates the core features of a LiteAgent:
+
+- Structured output using Pydantic models
+- Tool integration with WebSearchTool
+- Simple execution with `kickoff()`
+- Easy access to both raw and structured results
+
+## Using LiteAgent in a Flow
+
+For more complex scenarios, you can integrate LiteAgents into a Flow. Here's an example of a market research flow:
+
+````python
+from typing import List
+from pydantic import BaseModel, Field
+from crewai.flow.flow import Flow, start, listen
+from crewai.lite_agent import LiteAgent
+from crewai.tools import WebSearchTool
+
+# Define a structured output format
+class MarketAnalysis(BaseModel):
+    key_trends: List[str] = Field(description="List of identified market trends")
+    market_size: str = Field(description="Estimated market size")
+    competitors: List[str] = Field(description="Major competitors in the space")
+
+# Define flow state
+class MarketResearchState(BaseModel):
+    product: str = ""
+    analysis: MarketAnalysis = None
+
+# Create a flow class
+class MarketResearchFlow(Flow[MarketResearchState]):
+    @start()
+    def initialize_research(self, product: str):
+        print(f"Starting market research for {product}")
+        self.state.product = product
+
+    @listen(initialize_research)
+    async def analyze_market(self):
+        # Create a LiteAgent for market research
+        analyst = LiteAgent(
+            role="Market Research Analyst",
+            goal=f"Analyze the market for {self.state.product}",
+            backstory="You are an experienced market analyst with expertise in "
+                     "identifying market trends and opportunities.",
+            tools=[WebSearchTool()],
+            verbose=True,
+            response_format=MarketAnalysis
+        )
+
+        # Define the research query
+        query = f"""
+        Research the market for {self.state.product}. Include:
+        1. Key market trends
+        2. Market size
+        3. Major competitors
+
+        Format your response according to the specified structure.
+        """
+
+        # Execute the analysis
+        result = await analyst.kickoff_async(query)
+        self.state.analysis = result.pydantic
+        return result.pydantic
+
+    @listen(analyze_market)
+    def present_results(self):
+        analysis = self.state.analysis
+        print("\nMarket Analysis Results")
+        print("=====================")
+
+        print("\nKey Market Trends:")
+        for trend in analysis.key_trends:
+            print(f"- {trend}")
+
+        print(f"\nMarket Size: {analysis.market_size}")
+
+        print("\nMajor Competitors:")
+        for competitor in analysis.competitors:
+            print(f"- {competitor}")
+
+# Usage example
+import asyncio
+
+async def run_flow():
+    flow = MarketResearchFlow()
+    result = await flow.kickoff(inputs={"product": "AI-powered chatbots"})
+    return result
+
+# Run the flow
+if __name__ == "__main__":
+    asyncio.run(run_flow())
+
+## Key Features
+
+### 1. Simplified Setup
+Unlike regular Agents, LiteAgents are designed for quick setup and standalone operation. They don't require crew configuration or task management.
+
+### 2. Structured Output
+LiteAgents support Pydantic models for response formatting, making it easy to get structured, type-safe data from your agent's operations.
+
+### 3. Tool Integration
+Just like regular Agents, LiteAgents can use tools to enhance their capabilities:
+```python
+from crewai.tools import SerperDevTool, CalculatorTool
+
+agent = LiteAgent(
+    role="Research Assistant",
+    goal="Find and analyze information",
+    tools=[SerperDevTool(), CalculatorTool()],
+    verbose=True
+)
+````
+
+### 4. Async Support
+
+LiteAgents support asynchronous execution through the `kickoff_async` method, making them suitable for non-blocking operations in your application.
+
+## Response Formatting
+
+LiteAgents support structured output through Pydantic models using the `response_format` parameter. This feature ensures type safety and consistent output structure, making it easier to work with agent responses in your application.
+
+### Basic Usage
+
+```python
+from pydantic import BaseModel, Field
+
+class SearchResult(BaseModel):
+    title: str = Field(description="The title of the found content")
+    summary: str = Field(description="A brief summary of the content")
+    relevance_score: float = Field(description="Relevance score from 0 to 1")
+
+agent = LiteAgent(
+    role="Search Specialist",
+    goal="Find and summarize relevant information",
+    response_format=SearchResult
+)
+
+result = await agent.kickoff_async("Find information about quantum computing")
+print(f"Title: {result.pydantic.title}")
+print(f"Summary: {result.pydantic.summary}")
+print(f"Relevance: {result.pydantic.relevance_score}")
+```
+
+### Handling Responses
+
+When using `response_format`, the agent's response will be available in two forms:
+
+1. **Raw Response**: Access the unstructured string response
+
+   ```python
+   result = await agent.kickoff_async("Analyze the market")
+   print(result.raw)  # Original LLM response
+   ```
+
+2. **Structured Response**: Access the parsed Pydantic model
+   ```python
+   print(result.pydantic)  # Parsed response as Pydantic model
+   print(result.pydantic.dict())  # Convert to dictionary
+   ```

docs/concepts/llamaindex-tools.mdx

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

docs/concepts/llms.mdx

@@ -438,7 +438,7 @@ In this section, you'll find detailed examples that help you select, configure,
         @agent
         def researcher(self) -> Agent:
             return Agent(
-                config=self.agents_config['researcher'], # type: ignore[index]
+                config=self.agents_config['researcher'],
                 llm=local_nvidia_nim_llm
             )
         
@@ -535,13 +535,14 @@ In this section, you'll find detailed examples that help you select, configure,
   <Accordion title="Hugging Face">
     Set the following environment variables in your `.env` file:
     ```toml Code
-    HF_TOKEN=<your-api-key>
+    HUGGINGFACE_API_KEY=<your-api-key>
     ```
 
     Example usage in your CrewAI project:
     ```python Code
     llm = LLM(
-        model="huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct"
+        model="huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct",
+        base_url="your_api_endpoint"
     )
     ```
   </Accordion>

docs/concepts/memory.mdx

@@ -18,8 +18,7 @@ reason, and learn from past interactions.
 | **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. Uses `RAG` for storing entity information. |
 | **Contextual Memory**| Maintains the context of interactions by combining `ShortTermMemory`, `LongTermMemory`, and `EntityMemory`, aiding in the coherence and relevance of agent responses over a sequence of tasks or a conversation. |
-| **External Memory**  | Enables integration with external memory systems and providers (like Mem0), allowing for specialized memory storage and retrieval across different applications. Supports custom storage implementations for flexible memory management. |
-| **User Memory**      | ⚠️ **DEPRECATED**: This component is deprecated and will be removed in a future version. Please use [External Memory](#using-external-memory) instead. |
+| **User Memory**      | Stores user-specific information and preferences, enhancing personalization and user experience. |
 
 ## How Memory Systems Empower Agents
 
@@ -145,7 +144,6 @@ from crewai.memory import LongTermMemory
 # Simple memory configuration
 crew = Crew(memory=True)  # Uses default storage locations
 ```
-Note that External Memory won’t be defined when `memory=True` is set, as we can’t infer which external memory would be suitable for your case
 
 ### Custom Storage Configuration
 ```python
@@ -276,104 +274,6 @@ crew = Crew(
 )
 ```
 
-### Using External Memory
-
-External Memory is a powerful feature that allows you to integrate external memory systems with your CrewAI applications. This is particularly useful when you want to use specialized memory providers or maintain memory across different applications.
-Since it’s an external memory, we’re not able to add a default value to it - unlike with Long Term and Short Term memory. 
-
-#### Basic Usage with Mem0
-
-The most common way to use External Memory is with Mem0 as the provider:
-
-```python
-import os
-from crewai import Agent, Crew, Process, Task
-from crewai.memory.external.external_memory import ExternalMemory
-
-os.environ["MEM0_API_KEY"] = "YOUR-API-KEY"
-
-agent = Agent(
-    role="You are a helpful assistant",
-    goal="Plan a vacation for the user",
-    backstory="You are a helpful assistant that can plan a vacation for the user",
-    verbose=True,
-)
-task = Task(
-    description="Give things related to the user's vacation",
-    expected_output="A plan for the vacation",
-    agent=agent,
-)
-
-crew = Crew(
-    agents=[agent],
-    tasks=[task],
-    verbose=True,
-    process=Process.sequential,
-    external_memory=ExternalMemory(
-        embedder_config={"provider": "mem0", "config": {"user_id": "U-123"}} # you can provide an entire Mem0 configuration
-    ),
-)
-
-crew.kickoff(
-    inputs={"question": "which destination is better for a beach vacation?"}
-)
-```
-
-#### Using External Memory with Custom Storage
-
-You can also create custom storage implementations for External Memory. Here's an example of how to create a custom storage:
-
-```python
-from crewai import Agent, Crew, Process, Task
-from crewai.memory.external.external_memory import ExternalMemory
-from crewai.memory.storage.interface import Storage
-
-
-class CustomStorage(Storage):
-    def __init__(self):
-        self.memories = []
-
-    def save(self, value, metadata=None, agent=None):
-        self.memories.append({"value": value, "metadata": metadata, "agent": agent})
-
-    def search(self, query, limit=10, score_threshold=0.5):
-        # Implement your search logic here
-        return []
-
-    def reset(self):
-        self.memories = []
-
-
-# Create external memory with custom storage
-external_memory = ExternalMemory(
-    storage=CustomStorage(),
-    embedder_config={"provider": "mem0", "config": {"user_id": "U-123"}},
-)
-
-agent = Agent(
-    role="You are a helpful assistant",
-    goal="Plan a vacation for the user",
-    backstory="You are a helpful assistant that can plan a vacation for the user",
-    verbose=True,
-)
-task = Task(
-    description="Give things related to the user's vacation",
-    expected_output="A plan for the vacation",
-    agent=agent,
-)
-
-crew = Crew(
-    agents=[agent],
-    tasks=[task],
-    verbose=True,
-    process=Process.sequential,
-    external_memory=external_memory,
-)
-
-crew.kickoff(
-    inputs={"question": "which destination is better for a beach vacation?"}
-)
-```
 
 
 ## Additional Embedding Providers

docs/concepts/tasks.mdx

@@ -12,18 +12,6 @@ Tasks provide all necessary details for execution, such as a description, the ag
 
 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.
 
-<Note type="info" title="Enterprise Enhancement: Visual Task Builder">
-CrewAI Enterprise includes a Visual Task Builder in Crew Studio that simplifies complex task creation and chaining. Design your task flows visually and test them in real-time without writing code.
-
-![Task Builder Screenshot](../images/enterprise/crew-studio-quickstart.png)
-
-The Visual Task Builder enables:
-- Drag-and-drop task creation
-- Visual task dependencies and flow
-- Real-time testing and validation
-- Easy sharing and collaboration
-</Note>
-
 ### Task Execution Flow
 
 Tasks can be executed in two ways:
@@ -113,7 +101,7 @@ class LatestAiDevelopmentCrew():
   @agent
   def researcher(self) -> Agent:
     return Agent(
-      config=self.agents_config['researcher'], # type: ignore[index]
+      config=self.agents_config['researcher'],
       verbose=True,
       tools=[SerperDevTool()]
     )
@@ -121,20 +109,20 @@ class LatestAiDevelopmentCrew():
   @agent
   def reporting_analyst(self) -> Agent:
     return Agent(
-      config=self.agents_config['reporting_analyst'], # type: ignore[index]
+      config=self.agents_config['reporting_analyst'],
       verbose=True
     )
 
   @task
   def research_task(self) -> Task:
     return Task(
-      config=self.tasks_config['research_task'] # type: ignore[index]
+      config=self.tasks_config['research_task']
     )
 
   @task
   def reporting_task(self) -> Task:
     return Task(
-      config=self.tasks_config['reporting_task'] # type: ignore[index]
+      config=self.tasks_config['reporting_task']
     )
 
   @crew
@@ -288,20 +276,26 @@ To add a guardrail to a task, provide a validation function through the `guardra
 
 ```python Code
 from typing import Tuple, Union, Dict, Any
-from crewai import TaskOutput
 
-def validate_blog_content(result: TaskOutput) -> Tuple[bool, Any]:
+def validate_blog_content(result: str) -> Tuple[bool, Union[Dict[str, Any], str]]:
     """Validate blog content meets requirements."""
     try:
         # Check word count
         word_count = len(result.split())
         if word_count > 200:
-            return (False, "Blog content exceeds 200 words")
+            return (False, {
+                "error": "Blog content exceeds 200 words",
+                "code": "WORD_COUNT_ERROR",
+                "context": {"word_count": word_count}
+            })
 
         # Additional validation logic here
         return (True, result.strip())
     except Exception as e:
-        return (False, "Unexpected error during validation")
+        return (False, {
+            "error": "Unexpected error during validation",
+            "code": "SYSTEM_ERROR"
+        })
 
 blog_task = Task(
     description="Write a blog post about AI",
@@ -319,24 +313,29 @@ blog_task = Task(
    - Type hints are recommended but optional
 
 2. **Return Values**:
-   - On success: it returns a tuple of `(bool, Any)`. For example: `(True, validated_result)` 
-   - On Failure: it returns a tuple of `(bool, str)`. For example: `(False, "Error message explain the failure")`
+   - Success: Return `(True, validated_result)`
+   - Failure: Return `(False, error_details)`
 
 ### Error Handling Best Practices
 
 1. **Structured Error Responses**:
 ```python Code
-from crewai import TaskOutput
-
-def validate_with_context(result: TaskOutput) -> Tuple[bool, Any]:
+def validate_with_context(result: str) -> Tuple[bool, Union[Dict[str, Any], str]]:
     try:
         # Main validation logic
         validated_data = perform_validation(result)
         return (True, validated_data)
     except ValidationError as e:
-        return (False, f"VALIDATION_ERROR: {str(e)}")
+        return (False, {
+            "error": str(e),
+            "code": "VALIDATION_ERROR",
+            "context": {"input": result}
+        })
     except Exception as e:
-        return (False, str(e))
+        return (False, {
+            "error": "Unexpected error",
+            "code": "SYSTEM_ERROR"
+        })
 ```
 
 2. **Error Categories**:
@@ -347,25 +346,28 @@ def validate_with_context(result: TaskOutput) -> Tuple[bool, Any]:
 3. **Validation Chain**:
 ```python Code
 from typing import Any, Dict, List, Tuple, Union
-from crewai import TaskOutput
 
-def complex_validation(result: TaskOutput) -> Tuple[bool, Any]:
+def complex_validation(result: str) -> Tuple[bool, Union[str, Dict[str, Any]]]:
     """Chain multiple validation steps."""
     # Step 1: Basic validation
     if not result:
-        return (False, "Empty result")
+        return (False, {"error": "Empty result", "code": "EMPTY_INPUT"})
 
     # Step 2: Content validation
     try:
         validated = validate_content(result)
         if not validated:
-            return (False, "Invalid content")
+            return (False, {"error": "Invalid content", "code": "CONTENT_ERROR"})
 
         # Step 3: Format validation
         formatted = format_output(validated)
         return (True, formatted)
     except Exception as e:
-        return (False, str(e))
+        return (False, {
+            "error": str(e),
+            "code": "VALIDATION_ERROR",
+            "context": {"step": "content_validation"}
+        })
 ```
 
 ### Handling Guardrail Results
@@ -380,16 +382,19 @@ When a guardrail returns `(False, error)`:
 Example with retry handling:
 ```python Code
 from typing import Optional, Tuple, Union
-from crewai import TaskOutput, Task
 
-def validate_json_output(result: TaskOutput) -> Tuple[bool, Any]:
+def validate_json_output(result: str) -> Tuple[bool, Union[Dict[str, Any], str]]:
     """Validate and parse JSON output."""
     try:
         # Try to parse as JSON
         data = json.loads(result)
         return (True, data)
     except json.JSONDecodeError as e:
-        return (False, "Invalid JSON format")
+        return (False, {
+            "error": "Invalid JSON format",
+            "code": "JSON_ERROR",
+            "context": {"line": e.lineno, "column": e.colno}
+        })
 
 task = Task(
     description="Generate a JSON report",
@@ -409,7 +414,7 @@ It's also important to note that the output of the final task of a crew becomes
 ### Using `output_pydantic`
 The `output_pydantic` property allows you to define a Pydantic model that the task output should conform to. This ensures that the output is not only structured but also validated according to the Pydantic model.
 
-Here's an example demonstrating how to use output_pydantic:
+Here’s an example demonstrating how to use output_pydantic:
 
 ```python Code
 import json
@@ -490,7 +495,7 @@ In this example:
 ### Using `output_json`
 The `output_json` property allows you to define the expected output in JSON format. This ensures that the task's output is a valid JSON structure that can be easily parsed and used in your application.
 
-Here's an example demonstrating how to use `output_json`:
+Here’s an example demonstrating how to use `output_json`:
 
 ```python Code
 import json

docs/concepts/tools.mdx

@@ -15,18 +15,6 @@ A tool in CrewAI is a skill or function that agents can utilize to perform vario
 This includes tools from the [CrewAI Toolkit](https://github.com/joaomdmoura/crewai-tools) and [LangChain Tools](https://python.langchain.com/docs/integrations/tools),
 enabling everything from simple searches to complex interactions and effective teamwork among agents.
 
-<Note type="info" title="Enterprise Enhancement: Tools Repository">
-CrewAI Enterprise provides a comprehensive Tools Repository with pre-built integrations for common business systems and APIs. Deploy agents with enterprise tools in minutes instead of days.
-
-![Tools Repository Screenshot](../images/enterprise/tools-repository.png)
-
-The Enterprise Tools Repository includes:
-- Pre-built connectors for popular enterprise systems
-- Custom tool creation interface
-- Version control and sharing capabilities
-- Security and compliance features
-</Note>
-
 ## Key Characteristics of Tools
 
 - **Utility**: Crafted for tasks such as web searching, data analysis, content generation, and agent collaboration.
@@ -91,7 +79,7 @@ research = Task(
 )
 
 write = Task(
-    description='Write an engaging blog post about the AI industry, based on the research analyst's summary. Draw inspiration from the latest blog posts in the directory.',
+    description='Write an engaging blog post about the AI industry, based on the research analyst’s summary. Draw inspiration from the latest blog posts in the directory.',
     expected_output='A 4-paragraph blog post formatted in markdown with engaging, informative, and accessible content, avoiding complex jargon.',
     agent=writer,
     output_file='blog-posts/new_post.md'  # The final blog post will be saved here
@@ -153,7 +141,7 @@ Here is a list of the available tools and their descriptions:
 ## Creating your own Tools
 
 <Tip>
-  Developers can craft `custom tools` tailored for their agent's needs or
+  Developers can craft `custom tools` tailored for their agent’s needs or
   utilize pre-built options.
 </Tip>
 

docs/custom_llm.md

@@ -1,13 +1,9 @@
----
-title: Custom LLM Implementation
-description: Learn how to create custom LLM implementations in CrewAI.
-icon: code
----
-
-## Custom LLM Implementations
+# Custom LLM Implementations
 
 CrewAI now supports custom LLM implementations through the `BaseLLM` abstract base class. This allows you to create your own LLM implementations that don't rely on litellm's authentication mechanism.
 
+## Using Custom LLM Implementations
+
 To create a custom LLM implementation, you need to:
 
 1. Inherit from the `BaseLLM` abstract base class

docs/docs.json

@@ -8,27 +8,25 @@
     "dark": "#C94C3C"
   },
   "favicon": "favicon.svg",
-  "contextual": {
-    "options": ["copy", "view", "chatgpt", "claude"]
-  },
   "navigation": {
     "tabs": [
       {
-        "tab": "Documentation",
+        "tab": "Get Started",
         "groups": [
           {
             "group": "Get Started",
             "pages": [
               "introduction",
               "installation",
-              "quickstart"
+              "quickstart",
+              "changelog"
             ]
           },
           {
             "group": "Guides",
             "pages": [
               {
-                "group": "Strategy",
+                "group": "Concepts",
                 "pages": [
                   "guides/concepts/evaluating-use-cases"
                 ]
@@ -68,6 +66,7 @@
               "concepts/tasks",
               "concepts/crews",
               "concepts/flows",
+              "concepts/lite-agent",
               "concepts/knowledge",
               "concepts/llms",
               "concepts/processes",
@@ -78,7 +77,42 @@
               "concepts/testing",
               "concepts/cli",
               "concepts/tools",
-              "concepts/event-listener"
+              "concepts/event-listener",
+              "concepts/langchain-tools",
+              "concepts/llamaindex-tools"
+            ]
+          },
+          {
+            "group": "How to Guides",
+            "pages": [
+              "how-to/create-custom-tools",
+              "how-to/sequential-process",
+              "how-to/hierarchical-process",
+              "how-to/custom-manager-agent",
+              "how-to/llm-connections",
+              "how-to/customizing-agents",
+              "how-to/multimodal-agents",
+              "how-to/coding-agents",
+              "how-to/force-tool-output-as-result",
+              "how-to/human-input-on-execution",
+              "how-to/kickoff-async",
+              "how-to/kickoff-for-each",
+              "how-to/replay-tasks-from-latest-crew-kickoff",
+              "how-to/conditional-tasks"
+            ]
+          },
+          {
+            "group": "Agent Monitoring & Observability",
+            "pages": [
+              "how-to/agentops-observability",
+              "how-to/langfuse-observability",
+              "how-to/langtrace-observability",
+              "how-to/mlflow-observability",
+              "how-to/openlit-observability",
+              "how-to/opik-observability",
+              "how-to/phoenix-observability",
+              "how-to/portkey-observability",
+              "how-to/weave-integration"
             ]
           },
           {
@@ -108,7 +142,6 @@
               "tools/hyperbrowserloadtool",
               "tools/linkupsearchtool",
               "tools/llamaindextool",
-              "tools/langchaintool",
               "tools/serperdevtool",
               "tools/s3readertool",
               "tools/s3writertool",
@@ -138,40 +171,6 @@
               "tools/youtubevideosearchtool"
             ]
           },
-          {
-            "group": "Agent Monitoring & Observability",
-            "pages": [
-              "how-to/agentops-observability",
-              "how-to/arize-phoenix-observability",
-              "how-to/langfuse-observability",
-              "how-to/langtrace-observability",
-              "how-to/mlflow-observability",
-              "how-to/openlit-observability",
-              "how-to/opik-observability",
-              "how-to/portkey-observability",
-              "how-to/weave-integration"
-            ]
-          },
-          {
-            "group": "Learn",
-            "pages": [
-              "how-to/conditional-tasks",
-              "how-to/coding-agents",
-              "how-to/create-custom-tools",
-              "how-to/custom-llm",
-              "how-to/custom-manager-agent",
-              "how-to/customizing-agents",
-              "how-to/force-tool-output-as-result",
-              "how-to/hierarchical-process",
-              "how-to/human-input-on-execution",
-              "how-to/kickoff-async",
-              "how-to/kickoff-for-each",
-              "how-to/llm-connections",
-              "how-to/multimodal-agents",
-              "how-to/replay-tasks-from-latest-crew-kickoff",
-              "how-to/sequential-process"
-            ]
-          },
           {
             "group": "Telemetry",
             "pages": [
@@ -190,35 +189,14 @@
             ]
           }
         ]
-      },
-      {
-        "tab": "Releases",
-        "groups": [
-          {
-            "group": "Releases",
-            "pages": [
-              "changelog"
-            ]
-          }
-        ]
       }
     ],
     "global": {
       "anchors": [
         {
-          "anchor": "Website",
-          "href": "https://crewai.com",
-          "icon": "globe"
-        },
-        {
-          "anchor": "Forum",
+          "anchor": "Community",
           "href": "https://community.crewai.com",
           "icon": "discourse"
-        },
-        {
-          "anchor": "Get Help",
-          "href": "mailto:support@crewai.com",
-          "icon": "headset"
         }
       ]
     }
@@ -232,12 +210,6 @@
     "strict": false
   },
   "navbar": {
-    "links": [
-      {
-        "label": "Start Free Trial",
-        "href": "https://app.crewai.com"
-      }
-    ],
     "primary": {
       "type": "github",
       "href": "https://github.com/crewAIInc/crewAI"
@@ -247,12 +219,7 @@
     "prompt": "Search CrewAI docs"
   },
   "seo": {
-    "indexing": "all"
-  },
-  "errors": {
-    "404": {
-      "redirect": true
-    }
+    "indexing": "navigable"
   },
   "footer": {
     "socials": {
@@ -264,4 +231,4 @@
       "reddit": "https://www.reddit.com/r/crewAIInc/"
     }
   }
-}
+}

docs/guides/crews/first-crew.mdx

@@ -185,20 +185,15 @@ Let's modify the `crew.py` file:
 from crewai import Agent, Crew, Process, Task
 from crewai.project import CrewBase, agent, crew, task
 from crewai_tools import SerperDevTool
-from crewai.agents.agent_builder.base_agent import BaseAgent
-from typing import List
 
 @CrewBase
 class ResearchCrew():
     """Research crew for comprehensive topic analysis and reporting"""
 
-    agents: List[BaseAgent]
-    tasks: List[Task]
-
     @agent
     def researcher(self) -> Agent:
         return Agent(
-            config=self.agents_config['researcher'], # type: ignore[index]
+            config=self.agents_config['researcher'],
             verbose=True,
             tools=[SerperDevTool()]
         )
@@ -206,20 +201,20 @@ class ResearchCrew():
     @agent
     def analyst(self) -> Agent:
         return Agent(
-            config=self.agents_config['analyst'], # type: ignore[index]
+            config=self.agents_config['analyst'],
             verbose=True
         )
 
     @task
     def research_task(self) -> Task:
         return Task(
-            config=self.tasks_config['research_task'] # type: ignore[index]
+            config=self.tasks_config['research_task']
         )
 
     @task
     def analysis_task(self) -> Task:
         return Task(
-            config=self.tasks_config['analysis_task'], # type: ignore[index]
+            config=self.tasks_config['analysis_task'],
             output_file='output/report.md'
         )
 
@@ -392,4 +387,4 @@ Now that you've built your first crew, you can:
 
 <Check>
 Congratulations! You've successfully built your first CrewAI crew that can research and analyze any topic you provide. This foundational experience has equipped you with the skills to create increasingly sophisticated AI systems that can tackle complex, multi-stage problems through collaborative intelligence.
-</Check>
+</Check>

docs/guides/flows/first-flow.mdx

@@ -203,40 +203,35 @@ These task definitions provide detailed instructions to our agents, ensuring the
 # src/guide_creator_flow/crews/content_crew/content_crew.py
 from crewai import Agent, Crew, Process, Task
 from crewai.project import CrewBase, agent, crew, task
-from crewai.agents.agent_builder.base_agent import BaseAgent
-from typing import List
 
 @CrewBase
 class ContentCrew():
     """Content writing crew"""
 
-    agents: List[BaseAgent]
-    tasks: List[Task]
-
     @agent
     def content_writer(self) -> Agent:
         return Agent(
-            config=self.agents_config['content_writer'], # type: ignore[index]
+            config=self.agents_config['content_writer'],
             verbose=True
         )
 
     @agent
     def content_reviewer(self) -> Agent:
         return Agent(
-            config=self.agents_config['content_reviewer'], # type: ignore[index]
+            config=self.agents_config['content_reviewer'],
             verbose=True
         )
 
     @task
     def write_section_task(self) -> Task:
         return Task(
-            config=self.tasks_config['write_section_task'] # type: ignore[index]
+            config=self.tasks_config['write_section_task']
         )
 
     @task
     def review_section_task(self) -> Task:
         return Task(
-            config=self.tasks_config['review_section_task'], # type: ignore[index]
+            config=self.tasks_config['review_section_task'],
             context=[self.write_section_task()]
         )
 
@@ -268,7 +263,6 @@ Let's create our flow in the `main.py` file:
 ```python
 #!/usr/bin/env python
 import json
-import os
 from typing import List, Dict
 from pydantic import BaseModel, Field
 from crewai import LLM
@@ -347,9 +341,6 @@ class GuideCreatorFlow(Flow[GuideCreatorState]):
         outline_dict = json.loads(response)
         self.state.guide_outline = GuideOutline(**outline_dict)
 
-        # Ensure output directory exists before saving
-        os.makedirs("output", exist_ok=True)
-
         # Save the outline to a file
         with open("output/guide_outline.json", "w") as f:
             json.dump(outline_dict, f, indent=2)

docs/how-to/bring-your-own-agent.mdx

@@ -1,443 +0,0 @@
----
-title: Bring your own agent
-description: Learn how to bring your own agents that work within a Crew.
-icon: robots
----
-
-Interoperability is a core concept in CrewAI. This guide will show you how to bring your own agents that work within a Crew.
-
-
-## Adapter Guide for Bringing your own agents (Langgraph Agents, OpenAI Agents, etc...)
-We require 3 adapters to turn any agent from different frameworks to work within crew.
-
-1. BaseAgentAdapter
-2. BaseToolAdapter
-3. BaseConverter
-
-
-## BaseAgentAdapter
-This abstract class defines the common interface and functionality that all
-agent adapters must implement. It extends BaseAgent to maintain compatibility
-with the CrewAI framework while adding adapter-specific requirements.
-
-Required Methods:
-
-1. `def configure_tools`
-2. `def configure_structured_output`
-
-## Creating your own Adapter
-To integrate an agent from a different framework (e.g., LangGraph, Autogen, OpenAI Assistants) into CrewAI, you need to create a custom adapter by inheriting from `BaseAgentAdapter`. This adapter acts as a compatibility layer, translating between the CrewAI interfaces and the specific requirements of your external agent.
-
-Here's how you implement your custom adapter:
-
-1.  **Inherit from `BaseAgentAdapter`**:
-    ```python
-    from crewai.agents.agent_adapters.base_agent_adapter import BaseAgentAdapter
-    from crewai.tools import BaseTool
-    from typing import List, Optional, Any, Dict
-
-    class MyCustomAgentAdapter(BaseAgentAdapter):
-        # ... implementation details ...
-    ```
-
-2.  **Implement `__init__`**:
-    The constructor should call the parent class constructor `super().__init__(**kwargs)` and perform any initialization specific to your external agent. You can use the optional `agent_config` dictionary passed during CrewAI's `Agent` initialization to configure your adapter and the underlying agent.
-
-    ```python
-    def __init__(self, agent_config: Optional[Dict[str, Any]] = None, **kwargs: Any):
-        super().__init__(agent_config=agent_config, **kwargs)
-        # Initialize your external agent here, possibly using agent_config
-        # Example: self.external_agent = initialize_my_agent(agent_config)
-        print(f"Initializing MyCustomAgentAdapter with config: {agent_config}")
-    ```
-
-3.  **Implement `configure_tools`**:
-    This abstract method is crucial. It receives a list of CrewAI `BaseTool` instances. Your implementation must convert or adapt these tools into the format expected by your external agent framework. This might involve wrapping them, extracting specific attributes, or registering them with the external agent instance.
-
-    ```python
-    def configure_tools(self, tools: Optional[List[BaseTool]] = None) -> None:
-        if tools:
-            adapted_tools = []
-            for tool in tools:
-                # Adapt CrewAI BaseTool to the format your agent expects
-                # Example: adapted_tool = adapt_to_my_framework(tool)
-                # adapted_tools.append(adapted_tool)
-                pass # Replace with your actual adaptation logic
-
-            # Configure the external agent with the adapted tools
-            # Example: self.external_agent.set_tools(adapted_tools)
-            print(f"Configuring tools for MyCustomAgentAdapter: {adapted_tools}") # Placeholder
-        else:
-            # Handle the case where no tools are provided
-            # Example: self.external_agent.set_tools([])
-            print("No tools provided for MyCustomAgentAdapter.")
-    ```
-
-4.  **Implement `configure_structured_output`**:
-    This method is called when the CrewAI `Agent` is configured with structured output requirements (e.g., `output_json` or `output_pydantic`). Your adapter needs to ensure the external agent is set up to comply with these requirements. This might involve setting specific parameters on the external agent or ensuring its underlying model supports the requested format. If the external agent doesn't support structured output in a way compatible with CrewAI's expectations, you might need to handle the conversion or raise an appropriate error.
-
-    ```python
-    def configure_structured_output(self, structured_output: Any) -> None:
-        # Configure your external agent to produce output in the specified format
-        # Example: self.external_agent.set_output_format(structured_output)
-        self.adapted_structured_output = True # Signal that structured output is handled
-        print(f"Configuring structured output for MyCustomAgentAdapter: {structured_output}")
-    ```
-
-By implementing these methods, your `MyCustomAgentAdapter` will allow your custom agent implementation to function correctly within a CrewAI crew, interacting with tasks and tools seamlessly. Remember to replace the example comments and print statements with your actual adaptation logic specific to the external agent framework you are integrating.
-
-## BaseToolAdapter implementation
-The `BaseToolAdapter` class is responsible for converting CrewAI's native `BaseTool` objects into a format that your specific external agent framework can understand and utilize. Different agent frameworks (like LangGraph, OpenAI Assistants, etc.) have their own unique ways of defining and handling tools, and the `BaseToolAdapter` acts as the translator.
-
-Here's how you implement your custom tool adapter:
-
-1.  **Inherit from `BaseToolAdapter`**:
-    ```python
-    from crewai.agents.agent_adapters.base_tool_adapter import BaseToolAdapter
-    from crewai.tools import BaseTool
-    from typing import List, Any
-
-    class MyCustomToolAdapter(BaseToolAdapter):
-        # ... implementation details ...
-    ```
-
-2.  **Implement `configure_tools`**:
-    This is the core abstract method you must implement. It receives a list of CrewAI `BaseTool` instances provided to the agent. Your task is to iterate through this list, adapt each `BaseTool` into the format expected by your external framework, and store the converted tools in the `self.converted_tools` list (which is initialized in the base class constructor).
-
-    ```python
-    def configure_tools(self, tools: List[BaseTool]) -> None:
-        """Configure and convert CrewAI tools for the specific implementation."""
-        self.converted_tools = [] # Reset in case it's called multiple times
-        for tool in tools:
-            # Sanitize the tool name if required by the target framework
-            sanitized_name = self.sanitize_tool_name(tool.name)
-
-            # --- Your Conversion Logic Goes Here ---
-            # Example: Convert BaseTool to a dictionary format for LangGraph
-            # converted_tool = {
-            #     "name": sanitized_name,
-            #     "description": tool.description,
-            #     "parameters": tool.args_schema.schema() if tool.args_schema else {},
-            #     # Add any other framework-specific fields
-            # }
-
-            # Example: Convert BaseTool to an OpenAI function definition
-            # converted_tool = {
-            #     "type": "function",
-            #     "function": {
-            #         "name": sanitized_name,
-            #         "description": tool.description,
-            #         "parameters": tool.args_schema.schema() if tool.args_schema else {"type": "object", "properties": {}},
-            #     }
-            # }
-
-            # --- Replace above examples with your actual adaptation ---
-            converted_tool = self.adapt_tool_to_my_framework(tool, sanitized_name) # Placeholder
-
-            self.converted_tools.append(converted_tool)
-            print(f"Adapted tool '{tool.name}' to '{sanitized_name}' for MyCustomToolAdapter") # Placeholder
-
-        print(f"MyCustomToolAdapter finished configuring tools: {len(self.converted_tools)} adapted.") # Placeholder
-
-    # --- Helper method for adaptation (Example) ---
-    def adapt_tool_to_my_framework(self, tool: BaseTool, sanitized_name: str) -> Any:
-        # Replace this with the actual logic to convert a CrewAI BaseTool
-        # to the format needed by your specific external agent framework.
-        # This will vary greatly depending on the target framework.
-        adapted_representation = {
-            "framework_specific_name": sanitized_name,
-            "framework_specific_description": tool.description,
-            "inputs": tool.args_schema.schema() if tool.args_schema else None,
-            "implementation_reference": tool.run # Or however the framework needs to call it
-        }
-        # Also ensure the tool works both sync and async
-        async def async_tool_wrapper(*args, **kwargs):
-            output = tool.run(*args, **kwargs)
-            if inspect.isawaitable(output):
-                return await output
-            else:
-                return output
-
-        adapted_tool = MyFrameworkTool(
-            name=sanitized_name,
-            description=tool.description,
-            inputs=tool.args_schema.schema() if tool.args_schema else None,
-            implementation_reference=async_tool_wrapper
-        )
-        
-        return adapted_representation
-
-    ```
-
-3.  **Using the Adapter**:
-    Typically, you would instantiate your `MyCustomToolAdapter` within your `MyCustomAgentAdapter`'s `configure_tools` method and use it to process the tools before configuring your external agent.
-
-    ```python
-    # Inside MyCustomAgentAdapter.configure_tools
-    def configure_tools(self, tools: Optional[List[BaseTool]] = None) -> None:
-        if tools:
-            tool_adapter = MyCustomToolAdapter() # Instantiate your tool adapter
-            tool_adapter.configure_tools(tools)  # Convert the tools
-            adapted_tools = tool_adapter.tools() # Get the converted tools
-
-            # Now configure your external agent with the adapted_tools
-            # Example: self.external_agent.set_tools(adapted_tools)
-            print(f"Configuring external agent with adapted tools: {adapted_tools}") # Placeholder
-        else:
-            # Handle no tools case
-            print("No tools provided for MyCustomAgentAdapter.")
-    ```
-
-By creating a `BaseToolAdapter`, you decouple the tool conversion logic from the agent adaptation, making the integration cleaner and more modular. Remember to replace the placeholder examples with the actual conversion logic required by your specific external agent framework.
-
-## BaseConverter
-The `BaseConverterAdapter` plays a crucial role when a CrewAI `Task` requires an agent to return its final output in a specific structured format, such as JSON or a Pydantic model. It bridges the gap between CrewAI's structured output requirements and the capabilities of your external agent.
-
-Its primary responsibilities are:
-1.  **Configuring the Agent for Structured Output:** Based on the `Task`'s requirements (`output_json` or `output_pydantic`), it instructs the associated `BaseAgentAdapter` (and indirectly, the external agent) on what format is expected.
-2.  **Enhancing the System Prompt:** It modifies the agent's system prompt to include clear instructions on *how* to generate the output in the required structure.
-3.  **Post-processing the Result:** It takes the raw output from the agent and attempts to parse, validate, and format it according to the required structure, ultimately returning a string representation (e.g., a JSON string).
-
-Here's how you implement your custom converter adapter:
-
-1.  **Inherit from `BaseConverterAdapter`**:
-    ```python
-    from crewai.agents.agent_adapters.base_converter_adapter import BaseConverterAdapter
-    # Assuming you have your MyCustomAgentAdapter defined
-    # from .my_custom_agent_adapter import MyCustomAgentAdapter
-    from crewai.task import Task
-    from typing import Any
-
-    class MyCustomConverterAdapter(BaseConverterAdapter):
-        # Store the expected output type (e.g., 'json', 'pydantic', 'text')
-        _output_type: str = 'text' 
-        _output_schema: Any = None # Store JSON schema or Pydantic model
-
-        # ... implementation details ...
-    ```
-
-2.  **Implement `__init__`**:
-    The constructor must accept the corresponding `agent_adapter` instance it will work with.
-
-    ```python
-    def __init__(self, agent_adapter: Any): # Use your specific AgentAdapter type hint
-        self.agent_adapter = agent_adapter
-        print(f"Initializing MyCustomConverterAdapter for agent adapter: {type(agent_adapter).__name__}")
-    ```
-
-3.  **Implement `configure_structured_output`**:
-    This method receives the CrewAI `Task` object. You need to check the task's `output_json` and `output_pydantic` attributes to determine the required output structure. Store this information (e.g., in `_output_type` and `_output_schema`) and potentially call configuration methods on your `self.agent_adapter` if the external agent needs specific setup for structured output (which might have been partially handled in the agent adapter's `configure_structured_output` already).
-
-    ```python
-    def configure_structured_output(self, task: Task) -> None:
-        """Configure the expected structured output based on the task."""
-        if task.output_pydantic:
-            self._output_type = 'pydantic'
-            self._output_schema = task.output_pydantic
-            print(f"Converter: Configured for Pydantic output: {self._output_schema.__name__}")
-        elif task.output_json:
-            self._output_type = 'json'
-            self._output_schema = task.output_json
-            print(f"Converter: Configured for JSON output with schema: {self._output_schema}")
-        else:
-            self._output_type = 'text'
-            self._output_schema = None
-            print("Converter: Configured for standard text output.")
-
-        # Optionally, inform the agent adapter if needed
-        # self.agent_adapter.set_output_mode(self._output_type, self._output_schema)
-    ```
-
-4.  **Implement `enhance_system_prompt`**:
-    This method takes the agent's base system prompt string and should append instructions tailored to the currently configured `_output_type` and `_output_schema`. The goal is to guide the LLM powering the agent to produce output in the correct format.
-
-    ```python
-    def enhance_system_prompt(self, base_prompt: str) -> str:
-        """Enhance the system prompt with structured output instructions."""
-        if self._output_type == 'text':
-            return base_prompt # No enhancement needed for plain text
-
-        instructions = "\n\nYour final answer MUST be formatted as "
-        if self._output_type == 'json':
-            schema_str = json.dumps(self._output_schema, indent=2)
-            instructions += f"a JSON object conforming to the following schema:\n```json\n{schema_str}\n```"
-        elif self._output_type == 'pydantic':
-            schema_str = json.dumps(self._output_schema.model_json_schema(), indent=2)
-            instructions += f"a JSON object conforming to the Pydantic model '{self._output_schema.__name__}' with the following schema:\n```json\n{schema_str}\n```"
-
-        instructions += "\nEnsure your entire response is ONLY the valid JSON object, without any introductory text, explanations, or concluding remarks."
-        
-        print(f"Converter: Enhancing prompt for {self._output_type} output.")
-        return base_prompt + instructions
-    ```
-    *Note: The exact prompt engineering might need tuning based on the agent/LLM being used.* 
-
-5.  **Implement `post_process_result`**:
-    This method receives the raw string output from the agent. If structured output was requested (`json` or `pydantic`), you should attempt to parse the string into the expected format. Handle potential parsing errors (e.g., log them, attempt simple fixes, or raise an exception). Crucially, the method must **always return a string**, even if the intermediate format was a dictionary or Pydantic object (e.g., by serializing it back to a JSON string).
-
-    ```python
-    import json
-    from pydantic import ValidationError
-
-    def post_process_result(self, result: str) -> str:
-        """Post-process the agent's result to ensure it matches the expected format."""
-        print(f"Converter: Post-processing result for {self._output_type} output.")
-        if self._output_type == 'json':
-            try:
-                # Attempt to parse and re-serialize to ensure validity and consistent format
-                parsed_json = json.loads(result)
-                # Optional: Validate against self._output_schema if it's a JSON schema dictionary
-                # from jsonschema import validate
-                # validate(instance=parsed_json, schema=self._output_schema)
-                return json.dumps(parsed_json)
-            except json.JSONDecodeError as e:
-                print(f"Error: Failed to parse JSON output: {e}\nRaw output:\n{result}")
-                # Handle error: return raw, raise exception, or try to fix
-                return result # Example: return raw output on failure
-            # except Exception as e: # Catch validation errors if using jsonschema
-            #     print(f"Error: JSON output failed schema validation: {e}\nRaw output:\n{result}")
-            #     return result
-        elif self._output_type == 'pydantic':
-            try:
-                # Attempt to parse into the Pydantic model
-                model_instance = self._output_schema.model_validate_json(result)
-                # Return the model serialized back to JSON
-                return model_instance.model_dump_json()
-            except ValidationError as e:
-                print(f"Error: Failed to validate Pydantic output: {e}\nRaw output:\n{result}")
-                # Handle error
-                return result # Example: return raw output on failure
-            except json.JSONDecodeError as e:
-                 print(f"Error: Failed to parse JSON for Pydantic model: {e}\nRaw output:\n{result}")
-                 return result
-        else: # 'text'
-            return result # No processing needed for plain text
-    ```
-
-By implementing these methods, your `MyCustomConverterAdapter` ensures that structured output requests from CrewAI tasks are correctly handled by your integrated external agent, improving the reliability and usability of your custom agent within the CrewAI framework.
-
-## Out of the Box Adapters
-
-We provide out of the box adapters for the following frameworks:
-1. LangGraph
-2. OpenAI Agents
-
-## Kicking off a crew with adapted agents:
-
-```python
-import json
-import os
-from typing import List
-
-from crewai_tools import SerperDevTool
-from src.crewai import Agent, Crew, Task
-from langchain_openai import ChatOpenAI
-from pydantic import BaseModel
-
-from crewai.agents.agent_adapters.langgraph.langgraph_adapter import (
-    LangGraphAgentAdapter,
-)
-from crewai.agents.agent_adapters.openai_agents.openai_adapter import OpenAIAgentAdapter
-
-# CrewAI Agent
-code_helper_agent = Agent(
-    role="Code Helper",
-    goal="Help users solve coding problems effectively and provide clear explanations.",
-    backstory="You are an experienced programmer with deep knowledge across multiple programming languages and frameworks. You specialize in solving complex coding challenges and explaining solutions clearly.",
-    allow_delegation=False,
-    verbose=True,
-)
-# OpenAI Agent Adapter
-link_finder_agent = OpenAIAgentAdapter(
-    role="Link Finder",
-    goal="Find the most relevant and high-quality resources for coding tasks.",
-    backstory="You are a research specialist with a talent for finding the most helpful resources. You're skilled at using search tools to discover documentation, tutorials, and examples that directly address the user's coding needs.",
-    tools=[SerperDevTool()],
-    allow_delegation=False,
-    verbose=True,
-)
-
-# LangGraph Agent Adapter
-reporter_agent = LangGraphAgentAdapter(
-    role="Reporter",
-    goal="Report the results of the tasks.",
-    backstory="You are a reporter who reports the results of the other tasks",
-    llm=ChatOpenAI(model="gpt-4o"),
-    allow_delegation=True,
-    verbose=True,
-)
-
-
-class Code(BaseModel):
-    code: str
-
-
-task = Task(
-    description="Give an answer to the coding question: {task}",
-    expected_output="A thorough answer to the coding question: {task}",
-    agent=code_helper_agent,
-    output_json=Code,
-)
-task2 = Task(
-    description="Find links to resources that can help with coding tasks. Use the serper tool to find resources that can help.",
-    expected_output="A list of links to resources that can help with coding tasks",
-    agent=link_finder_agent,
-)
-
-
-class Report(BaseModel):
-    code: str
-    links: List[str]
-
-
-task3 = Task(
-    description="Report the results of the tasks.",
-    expected_output="A report of the results of the tasks. this is the code produced and then the links to the resources that can help with the coding task.",
-    agent=reporter_agent,
-    output_json=Report,
-)
-# Use in CrewAI
-crew = Crew(
-    agents=[code_helper_agent, link_finder_agent, reporter_agent],
-    tasks=[task, task2, task3],
-    verbose=True,
-)
-
-result = crew.kickoff(
-    inputs={"task": "How do you implement an abstract class in python?"}
-)
-
-# Print raw result first
-print("Raw result:", result)
-
-# Handle result based on its type
-if hasattr(result, "json_dict") and result.json_dict:
-    json_result = result.json_dict
-    print("\nStructured JSON result:")
-    print(f"{json.dumps(json_result, indent=2)}")
-
-    # Access fields safely
-    if isinstance(json_result, dict):
-        if "code" in json_result:
-            print("\nCode:")
-            print(
-                json_result["code"][:200] + "..."
-                if len(json_result["code"]) > 200
-                else json_result["code"]
-            )
-
-        if "links" in json_result:
-            print("\nLinks:")
-            for link in json_result["links"][:5]:  # Print first 5 links
-                print(f"- {link}")
-            if len(json_result["links"]) > 5:
-                print(f"...and {len(json_result['links']) - 5} more links")
-elif hasattr(result, "pydantic") and result.pydantic:
-    print("\nPydantic model result:")
-    print(result.pydantic.model_dump_json(indent=2))
-else:
-    # Fallback to raw output
-    print("\nNo structured result available, using raw output:")
-    print(result.raw[:500] + "..." if len(result.raw) > 500 else result.raw)
-
-```

docs/how-to/custom-manager-agent.mdx

@@ -1,5 +1,5 @@
 ---
-title: Custom Manager Agent
+title: Create Your Own Manager Agent
 description: Learn how to set a custom agent as the manager in CrewAI, providing more control over task management and coordination.
 icon: user-shield
 ---

docs/how-to/elasticsearch-integration.md

@@ -1,117 +0,0 @@
-# Elasticsearch Integration
-
-CrewAI supports using Elasticsearch as an alternative to ChromaDB for RAG (Retrieval Augmented Generation) storage. This allows you to leverage Elasticsearch's powerful search capabilities and scalability for your AI agents.
-
-## Installation
-
-To use Elasticsearch with CrewAI, you need to install the Elasticsearch Python client:
-
-```bash
-pip install elasticsearch
-```
-
-## Using Elasticsearch for Memory
-
-You can configure your crew to use Elasticsearch for memory storage:
-
-```python
-from crewai import Agent, Crew, Task
-
-# Create agents and tasks
-agent = Agent(
-    role="Researcher",
-    goal="Research a topic",
-    backstory="You are a researcher who loves to find information.",
-)
-
-task = Task(
-    description="Research about AI",
-    expected_output="Information about AI",
-    agent=agent,
-)
-
-# Create a crew with Elasticsearch memory
-crew = Crew(
-    agents=[agent],
-    tasks=[task],
-    memory_config={
-        "provider": "elasticsearch",
-        "host": "localhost",  # Optional, defaults to localhost
-        "port": 9200,         # Optional, defaults to 9200
-        "username": "user",   # Optional
-        "password": "pass",   # Optional
-    },
-)
-
-# Execute the crew
-result = crew.kickoff()
-```
-
-## Using Elasticsearch for Knowledge
-
-You can also use Elasticsearch for knowledge storage:
-
-```python
-from crewai import Agent, Crew, Task
-from crewai.knowledge import Knowledge
-from crewai.knowledge.source.string_knowledge_source import StringKnowledgeSource
-
-# Create knowledge with Elasticsearch storage
-content = "AI is a field of computer science that focuses on creating machines that can perform tasks that typically require human intelligence."
-string_source = StringKnowledgeSource(
-    content=content, metadata={"topic": "AI"}
-)
-
-knowledge = Knowledge(
-    collection_name="test",
-    sources=[string_source],
-    storage_provider="elasticsearch",  # Use Elasticsearch
-    # Optional Elasticsearch configuration
-    host="localhost",
-    port=9200,
-    username="user",
-    password="pass",
-)
-
-# Create an agent with the knowledge
-agent = Agent(
-    role="AI Expert",
-    goal="Explain AI",
-    backstory="You are an AI expert who loves to explain AI concepts.",
-    knowledge=[knowledge],
-)
-
-# Create a task
-task = Task(
-    description="Explain what AI is",
-    expected_output="Explanation of AI",
-    agent=agent,
-)
-
-# Create a crew
-crew = Crew(
-    agents=[agent],
-    tasks=[task],
-)
-
-# Execute the crew
-result = crew.kickoff()
-```
-
-## Configuration Options
-
-The Elasticsearch integration supports the following configuration options:
-
-- `host`: Elasticsearch host (default: "localhost")
-- `port`: Elasticsearch port (default: 9200)
-- `username`: Elasticsearch username (optional)
-- `password`: Elasticsearch password (optional)
-- Additional keyword arguments are passed directly to the Elasticsearch client
-
-## Running Tests
-
-To run the Elasticsearch tests, you need to set the `RUN_ELASTICSEARCH_TESTS` environment variable to `true`:
-
-```bash
-RUN_ELASTICSEARCH_TESTS=true pytest tests/memory/elasticsearch_storage_test.py tests/knowledge/elasticsearch_knowledge_storage_test.py tests/integration/elasticsearch_integration_test.py
-```

docs/how-to/phoenix-observability.mdx

@@ -1,10 +1,10 @@
 ---
-title: Arize Phoenix
-description: Arize Phoenix integration for CrewAI with OpenTelemetry and OpenInference
+title: Agent Monitoring with Arize Phoenix
+description: Learn how to integrate Arize Phoenix with CrewAI via OpenTelemetry using OpenInference
 icon: magnifying-glass-chart
 ---
 
-# Arize Phoenix Integration
+# Integrate Arize Phoenix with CrewAI
 
 This guide demonstrates how to integrate **Arize Phoenix** with **CrewAI** using OpenTelemetry via the [OpenInference](https://github.com/openinference/openinference) SDK. By the end of this guide, you will be able to trace your CrewAI agents and easily debug your agents.
 

docs/how-to/replay-tasks-from-latest-crew-kickoff.mdx

@@ -20,8 +20,10 @@ Here's an example of how to replay from a task:
 To use the replay feature, follow these steps:
 
 <Steps>
-   <Step title="Open your terminal or command prompt."></Step>
-   <Step title="Navigate to the directory where your CrewAI project is located."></Step>
+   <Step title="Open your terminal or command prompt.">
+   </Step>
+   <Step title="Navigate to the directory where your CrewAI project is located.">
+   </Step>
    <Step title="Run the following commands:">
       To view the latest kickoff task_ids use:
 

docs/installation.mdx

@@ -4,29 +4,14 @@ description: Get started with CrewAI - Install, configure, and build your first
 icon: wrench
 ---
 
-## Video Tutorial
-Watch this video tutorial for a step-by-step demonstration of the installation process:
-
-<iframe
-  width="100%"
-  height="400"
-  src="https://www.youtube.com/embed/-kSOTtYzgEw"
-  title="CrewAI Installation Guide"
-  frameborder="0"
-  style={{ borderRadius: '10px' }}
-  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
-  allowfullscreen
-></iframe>
-
-## Text Tutorial
 <Note>
   **Python Version Requirements**
-
+  
   CrewAI requires `Python >=3.10 and <3.13`. Here's how to check your version:
   ```bash
   python3 --version
   ```
-
+  
   If you need to update Python, visit [python.org/downloads](https://python.org/downloads)
 </Note>
 
@@ -155,27 +140,6 @@ We recommend using the `YAML` template scaffolding for a structured approach to
   </Step>
 </Steps>
 
-## Enterprise Installation Options
-
-<Note type="info">
-For teams and organizations, CrewAI offers enterprise deployment options that eliminate setup complexity:
-
-### CrewAI Enterprise (SaaS)
-- Zero installation required - just sign up for free at [app.crewai.com](https://app.crewai.com)
-- Automatic updates and maintenance
-- Managed infrastructure and scaling
-- Build Crews with no Code
-
-### CrewAI Factory (Self-hosted)
-- Containerized deployment for your infrastructure
-- Supports any hyperscaler including on prem depployments
-- Integration with your existing security systems
-
-<Card title="Explore Enterprise Options" icon="building" href="https://crewai.com/enterprise">
-  Learn about CrewAI's enterprise offerings and schedule a demo
-</Card>
-</Note>
-
 ## Next Steps
 
 <CardGroup cols={2}>

docs/introduction.mdx

@@ -15,7 +15,6 @@ CrewAI empowers developers with both high-level simplicity and precise low-level
 
 With over 100,000 developers certified through our community courses, CrewAI is rapidly becoming the standard for enterprise-ready AI automation.
 
-
 ## How Crews Work
 
 <Note>

docs/quickstart.mdx

@@ -87,20 +87,15 @@ Follow the steps below to get Crewing! 🚣‍♂️
     from crewai import Agent, Crew, Process, Task
     from crewai.project import CrewBase, agent, crew, task
     from crewai_tools import SerperDevTool
-    from crewai.agents.agent_builder.base_agent import BaseAgent
-    from typing import List
 
     @CrewBase
     class LatestAiDevelopmentCrew():
       """LatestAiDevelopment crew"""
 
-      agents: List[BaseAgent]
-      tasks: List[Task]
-
       @agent
       def researcher(self) -> Agent:
         return Agent(
-          config=self.agents_config['researcher'], # type: ignore[index]
+          config=self.agents_config['researcher'],
           verbose=True,
           tools=[SerperDevTool()]
         )
@@ -108,20 +103,20 @@ Follow the steps below to get Crewing! 🚣‍♂️
       @agent
       def reporting_analyst(self) -> Agent:
         return Agent(
-          config=self.agents_config['reporting_analyst'], # type: ignore[index]
+          config=self.agents_config['reporting_analyst'],
           verbose=True
         )
 
       @task
       def research_task(self) -> Task:
         return Task(
-          config=self.tasks_config['research_task'], # type: ignore[index]
+          config=self.tasks_config['research_task'],
         )
 
       @task
       def reporting_task(self) -> Task:
         return Task(
-          config=self.tasks_config['reporting_task'], # type: ignore[index]
+          config=self.tasks_config['reporting_task'],
           output_file='output/report.md' # This is the file that will be contain the final report.
         )
 
@@ -205,22 +200,6 @@ Follow the steps below to get Crewing! 🚣‍♂️
         ```
       </CodeGroup>
   </Step>
-
-  <Step title="Enterprise Alternative: Create in Crew Studio">
-  For CrewAI Enterprise users, you can create the same crew without writing code:
-
-  1. Log in to your CrewAI Enterprise account (create a free account at [app.crewai.com](https://app.crewai.com))
-  2. Open Crew Studio
-  3. Type what is the automation you're tryign to build
-  4. Create your tasks visually and connect them in sequence
-  5. Configure your inputs and click "Download Code" or "Deploy"
-
-  ![Crew Studio Quickstart](../images/enterprise/crew-studio-quickstart.png)
-
-  <Card title="Try CrewAI Enterprise" icon="rocket" href="https://app.crewai.com">
-    Start your free account at CrewAI Enterprise
-  </Card>
-  </Step>
   <Step title="View your final report">
   You should see the output in the console and the `report.md` file should be created in the root of your project with the final report.
 
@@ -292,7 +271,7 @@ Follow the steps below to get Crewing! 🚣‍♂️
 </Steps>
 
 <Check>
-Congratulations!
+Congratulations! 
 
 You have successfully set up your crew project and are ready to start building your own agentic workflows!
 </Check>
@@ -336,22 +315,9 @@ email_summarizer_task:
       - research_task
 ```
 
-## Deploying Your Crew
+## Deploying Your Project
 
-The easiest way to deploy your crew to production is through [CrewAI Enterprise](http://app.crewai.com).
-
-Watch this video tutorial for a step-by-step demonstration of deploying your crew to [CrewAI Enterprise](http://app.crewai.com) using the CLI.
-
-<iframe
-  width="100%"
-  height="400"
-  src="https://www.youtube.com/embed/3EqSV-CYDZA"
-  title="CrewAI Deployment Guide"
-  frameborder="0"
-  style={{ borderRadius: '10px' }}
-  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
-  allowfullscreen
-></iframe>
+The easiest way to deploy your crew is through [CrewAI Enterprise](http://app.crewai.com), where you can deploy your crew in a few clicks.
 
 <CardGroup cols={2}>
   <Card

docs/telemetry.mdx

@@ -22,16 +22,7 @@ usage of tools, API calls, responses, any data processed by the agents, or secre
 When the `share_crew` feature is enabled, detailed data including task descriptions, agents' backstories or goals, and other specific attributes are collected 
 to provide deeper insights. This expanded data collection may include personal information if users have incorporated it into their crews or tasks. 
 Users should carefully consider the content of their crews and tasks before enabling `share_crew`. 
-Users can disable telemetry by setting the environment variable `CREWAI_DISABLE_TELEMETRY` to `true` or by setting `OTEL_SDK_DISABLED` to `true` (note that the latter disables all OpenTelemetry instrumentation globally).
-
-### Examples:
-```python
-# Disable CrewAI telemetry only
-os.environ['CREWAI_DISABLE_TELEMETRY'] = 'true'
-
-# Disable all OpenTelemetry (including CrewAI)
-os.environ['OTEL_SDK_DISABLED'] = 'true'
-```
+Users can disable telemetry by setting the environment variable `OTEL_SDK_DISABLED` to `true`.
 
 ### Data Explanation:
 | Defaulted | Data                                      | Reason and Specifics                                                                                                       |
@@ -64,4 +55,4 @@ This enables a deeper insight into usage patterns.
 <Warning>
     If you enable `share_crew`, the collected data may include personal information if it has been incorporated into crew configurations, task descriptions, or outputs. 
     Users should carefully review their data and ensure compliance with GDPR and other applicable privacy regulations before enabling this feature.
-</Warning>
+</Warning>

docs/tools/jsonsearchtool.mdx

@@ -30,7 +30,7 @@ pip install 'crewai[tools]'
 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 Code
-from crewai_tools import JSONSearchTool
+from crewai.json_tools import JSONSearchTool  # Updated import path
 
 # General JSON content search
 # This approach is suitable when the JSON path is either known beforehand or can be dynamically identified.

docs/tools/weaviatevectorsearchtool.mdx

@@ -25,7 +25,7 @@ uv add weaviate-client
 To effectively use the `WeaviateVectorSearchTool`, follow these steps:
 
 1. **Package Installation**: Confirm that the `crewai[tools]` and `weaviate-client` packages are installed in your Python environment.
-2. **Weaviate Setup**: Set up a Weaviate cluster. You can follow the [Weaviate documentation](https://weaviate.io/developers/wcs/manage-clusters/connect) for instructions.
+2. **Weaviate Setup**: Set up a Weaviate cluster. You can follow the [Weaviate documentation](https://weaviate.io/developers/wcs/connect) for instructions.
 3. **API Keys**: Obtain your Weaviate cluster URL and API key.
 4. **OpenAI API Key**: Ensure you have an OpenAI API key set in your environment variables as `OPENAI_API_KEY`.
 
@@ -161,4 +161,4 @@ rag_agent = Agent(
 
 ## Conclusion
 
-The `WeaviateVectorSearchTool` provides a powerful way to search for semantically similar documents in a Weaviate vector database. By leveraging vector embeddings, it enables more accurate and contextually relevant search results compared to traditional keyword-based searches. This tool is particularly useful for applications that require finding information based on meaning rather than exact matches. 
+The `WeaviateVectorSearchTool` provides a powerful way to search for semantically similar documents in a Weaviate vector database. By leveraging vector embeddings, it enables more accurate and contextually relevant search results compared to traditional keyword-based searches. This tool is particularly useful for applications that require finding information based on meaning rather than exact matches. 

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "crewai"
-version = "0.114.0"
+version = "0.108.0"
 description = "Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks."
 readme = "README.md"
 requires-python = ">=3.10,<3.13"
@@ -37,7 +37,6 @@ dependencies = [
     "tomli>=2.0.2",
     "blinker>=1.9.0",
     "json5>=0.10.0",
-    "elasticsearch>=9.0.0",
 ]
 
 [project.urls]
@@ -46,7 +45,7 @@ Documentation = "https://docs.crewai.com"
 Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
-tools = ["crewai-tools~=0.40.1"]
+tools = ["crewai-tools~=0.38.0"]
 embeddings = [
     "tiktoken~=0.7.0"
 ]
@@ -82,10 +81,10 @@ dev-dependencies = [
     "pillow>=10.2.0",
     "cairosvg>=2.7.1",
     "pytest>=8.0.0",
+    "pytest-vcr>=1.0.2",
     "python-dotenv>=1.0.0",
     "pytest-asyncio>=0.23.7",
     "pytest-subprocess>=1.5.2",
-    "pytest-recording>=0.13.2",
 ]
 
 [project.scripts]

src/crewai/__init__.py

@@ -2,14 +2,12 @@ import warnings
 
 from crewai.agent import Agent
 from crewai.crew import Crew
-from crewai.crews.crew_output import CrewOutput
 from crewai.flow.flow import Flow
 from crewai.knowledge.knowledge import Knowledge
 from crewai.llm import LLM
 from crewai.llms.base_llm import BaseLLM
 from crewai.process import Process
 from crewai.task import Task
-from crewai.tasks.task_output import TaskOutput
 
 warnings.filterwarnings(
     "ignore",
@@ -17,16 +15,14 @@ warnings.filterwarnings(
     category=UserWarning,
     module="pydantic.main",
 )
-__version__ = "0.114.0"
+__version__ = "0.108.0"
 __all__ = [
     "Agent",
     "Crew",
-    "CrewOutput",
     "Process",
     "Task",
     "LLM",
     "BaseLLM",
     "Flow",
     "Knowledge",
-    "TaskOutput",
 ]

src/crewai/agent.py

@@ -1,6 +1,7 @@
+import re
 import shutil
 import subprocess
-from typing import Any, Dict, List, Literal, Optional, Sequence, Type, Union
+from typing import Any, Dict, List, Literal, Optional, Sequence, Union
 
 from pydantic import Field, InstanceOf, PrivateAttr, model_validator
 
@@ -10,7 +11,6 @@ from crewai.agents.crew_agent_executor import CrewAgentExecutor
 from crewai.knowledge.knowledge import Knowledge
 from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
 from crewai.knowledge.utils.knowledge_utils import extract_knowledge_context
-from crewai.lite_agent import LiteAgent, LiteAgentOutput
 from crewai.llm import BaseLLM
 from crewai.memory.contextual.contextual_memory import ContextualMemory
 from crewai.security import Fingerprint
@@ -114,14 +114,6 @@ class Agent(BaseAgent):
         default=None,
         description="Embedder configuration for the agent.",
     )
-    agent_knowledge_context: Optional[str] = Field(
-        default=None,
-        description="Knowledge context for the agent.",
-    )
-    crew_knowledge_context: Optional[str] = Field(
-        default=None,
-        description="Knowledge context for the crew.",
-    )
 
     @model_validator(mode="after")
     def post_init_setup(self):
@@ -164,28 +156,11 @@ class Agent(BaseAgent):
         except (TypeError, ValueError) as e:
             raise ValueError(f"Invalid Knowledge Configuration: {str(e)}")
 
-    def _is_any_available_memory(self) -> bool:
-        """Check if any memory is available."""
-        if not self.crew:
-            return False
-
-        memory_attributes = [
-            "memory",
-            "memory_config",
-            "_short_term_memory",
-            "_long_term_memory",
-            "_entity_memory",
-            "_user_memory",
-            "_external_memory",
-        ]
-
-        return any(getattr(self.crew, attr) for attr in memory_attributes)
-
     def execute_task(
         self,
         task: Task,
         context: Optional[str] = None,
-        tools: Optional[List[BaseTool]] = None
+        tools: Optional[List[BaseTool]] = None,
     ) -> str:
         """Execute a task with the agent.
 
@@ -196,11 +171,6 @@ class Agent(BaseAgent):
 
         Returns:
             Output of the agent
-
-        Raises:
-            TimeoutError: If execution exceeds the maximum execution time.
-            ValueError: If the max execution time is not a positive integer.
-            RuntimeError: If the agent execution fails for other reasons.
         """
         if self.tools_handler:
             self.tools_handler.last_used_tool = {}  # type: ignore # Incompatible types in assignment (expression has type "dict[Never, Never]", variable has type "ToolCalling")
@@ -230,42 +200,33 @@ class Agent(BaseAgent):
                 task=task_prompt, context=context
             )
 
-        if self._is_any_available_memory():
+        if self.crew and self.crew.memory:
             contextual_memory = ContextualMemory(
                 self.crew.memory_config,
                 self.crew._short_term_memory,
                 self.crew._long_term_memory,
                 self.crew._entity_memory,
                 self.crew._user_memory,
-                self.crew._external_memory,
             )
             memory = contextual_memory.build_context_for_task(task, context)
             if memory.strip() != "":
                 task_prompt += self.i18n.slice("memory").format(memory=memory)
-        knowledge_config = (
-            self.knowledge_config.model_dump() if self.knowledge_config else {}
-        )
+
         if self.knowledge:
-            agent_knowledge_snippets = self.knowledge.query(
-                [task.prompt()], **knowledge_config
-            )
+            agent_knowledge_snippets = self.knowledge.query([task.prompt()])
             if agent_knowledge_snippets:
-                self.agent_knowledge_context = extract_knowledge_context(
+                agent_knowledge_context = extract_knowledge_context(
                     agent_knowledge_snippets
                 )
-                if self.agent_knowledge_context:
-                    task_prompt += self.agent_knowledge_context
+                if agent_knowledge_context:
+                    task_prompt += agent_knowledge_context
 
         if self.crew:
-            knowledge_snippets = self.crew.query_knowledge(
-                [task.prompt()], **knowledge_config
-            )
+            knowledge_snippets = self.crew.query_knowledge([task.prompt()])
             if knowledge_snippets:
-                self.crew_knowledge_context = extract_knowledge_context(
-                    knowledge_snippets
-                )
-                if self.crew_knowledge_context:
-                    task_prompt += self.crew_knowledge_context
+                crew_knowledge_context = extract_knowledge_context(knowledge_snippets)
+                if crew_knowledge_context:
+                    task_prompt += crew_knowledge_context
 
         tools = tools or self.tools or []
         self.create_agent_executor(tools=tools, task=task)
@@ -285,26 +246,14 @@ class Agent(BaseAgent):
                     task=task,
                 ),
             )
-
-            # Determine execution method based on timeout setting
-            if self.max_execution_time is not None:
-                if not isinstance(self.max_execution_time, int) or self.max_execution_time <= 0:
-                    raise ValueError("Max Execution time must be a positive integer greater than zero")
-                result = self._execute_with_timeout(task_prompt, task, self.max_execution_time)
-            else:
-                result = self._execute_without_timeout(task_prompt, task)
-                
-        except TimeoutError as e:
-            # Propagate TimeoutError without retry
-            crewai_event_bus.emit(
-                self,
-                event=AgentExecutionErrorEvent(
-                    agent=self,
-                    task=task,
-                    error=str(e),
-                ),
-            )
-            raise e
+            result = self.agent_executor.invoke(
+                {
+                    "input": task_prompt,
+                    "tool_names": self.agent_executor.tools_names,
+                    "tools": self.agent_executor.tools_description,
+                    "ask_for_human_input": task.human_input,
+                }
+            )["output"]
         except Exception as e:
             if e.__class__.__module__.startswith("litellm"):
                 # Do not retry on litellm errors
@@ -345,66 +294,6 @@ class Agent(BaseAgent):
         )
         return result
 
-    def _execute_with_timeout(
-        self,
-        task_prompt: str,
-        task: Task,
-        timeout: int
-    ) -> str:
-        """Execute a task with a timeout.
-        
-        Args:
-            task_prompt: The prompt to send to the agent.
-            task: The task being executed.
-            timeout: Maximum execution time in seconds.
-            
-        Returns:
-            The output of the agent.
-            
-        Raises:
-            TimeoutError: If execution exceeds the timeout.
-            RuntimeError: If execution fails for other reasons.
-        """
-        import concurrent.futures
-        with concurrent.futures.ThreadPoolExecutor() as executor:
-            future = executor.submit(
-                self._execute_without_timeout,
-                task_prompt=task_prompt,
-                task=task
-            )
-            
-            try:
-                return future.result(timeout=timeout)
-            except concurrent.futures.TimeoutError:
-                future.cancel()
-                raise TimeoutError(f"Task '{task.description}' execution timed out after {timeout} seconds. Consider increasing max_execution_time or optimizing the task.")
-            except Exception as e:
-                future.cancel()
-                raise RuntimeError(f"Task execution failed: {str(e)}")
-
-    def _execute_without_timeout(
-        self,
-        task_prompt: str,
-        task: Task
-    ) -> str:
-        """Execute a task without a timeout.
-        
-        Args:
-            task_prompt: The prompt to send to the agent.
-            task: The task being executed.
-            
-        Returns:
-            The output of the agent.
-        """
-        return self.agent_executor.invoke(
-            {
-                "input": task_prompt,
-                "tool_names": self.agent_executor.tools_names,
-                "tools": self.agent_executor.tools_description,
-                "ask_for_human_input": task.human_input,
-            }
-        )["output"]
-
     def create_agent_executor(
         self, tools: Optional[List[BaseTool]] = None, task=None
     ) -> None:
@@ -559,76 +448,3 @@ class Agent(BaseAgent):
 
     def set_fingerprint(self, fingerprint: Fingerprint):
         self.security_config.fingerprint = fingerprint
-
-    def kickoff(
-        self,
-        messages: Union[str, List[Dict[str, str]]],
-        response_format: Optional[Type[Any]] = None,
-    ) -> LiteAgentOutput:
-        """
-        Execute the agent with the given messages using a LiteAgent instance.
-
-        This method is useful when you want to use the Agent configuration but
-        with the simpler and more direct execution flow of LiteAgent.
-
-        Args:
-            messages: Either a string query or a list of message dictionaries.
-                     If a string is provided, it will be converted to a user message.
-                     If a list is provided, each dict should have 'role' and 'content' keys.
-            response_format: Optional Pydantic model for structured output.
-
-        Returns:
-            LiteAgentOutput: The result of the agent execution.
-        """
-        lite_agent = LiteAgent(
-            role=self.role,
-            goal=self.goal,
-            backstory=self.backstory,
-            llm=self.llm,
-            tools=self.tools or [],
-            max_iterations=self.max_iter,
-            max_execution_time=self.max_execution_time,
-            respect_context_window=self.respect_context_window,
-            verbose=self.verbose,
-            response_format=response_format,
-            i18n=self.i18n,
-            original_agent=self,
-        )
-
-        return lite_agent.kickoff(messages)
-
-    async def kickoff_async(
-        self,
-        messages: Union[str, List[Dict[str, str]]],
-        response_format: Optional[Type[Any]] = None,
-    ) -> LiteAgentOutput:
-        """
-        Execute the agent asynchronously with the given messages using a LiteAgent instance.
-
-        This is the async version of the kickoff method.
-
-        Args:
-            messages: Either a string query or a list of message dictionaries.
-                     If a string is provided, it will be converted to a user message.
-                     If a list is provided, each dict should have 'role' and 'content' keys.
-            response_format: Optional Pydantic model for structured output.
-
-        Returns:
-            LiteAgentOutput: The result of the agent execution.
-        """
-        lite_agent = LiteAgent(
-            role=self.role,
-            goal=self.goal,
-            backstory=self.backstory,
-            llm=self.llm,
-            tools=self.tools or [],
-            max_iterations=self.max_iter,
-            max_execution_time=self.max_execution_time,
-            respect_context_window=self.respect_context_window,
-            verbose=self.verbose,
-            response_format=response_format,
-            i18n=self.i18n,
-            original_agent=self,
-        )
-
-        return await lite_agent.kickoff_async(messages)

src/crewai/agents/agent_adapters/base_agent_adapter.py

@@ -1,42 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional
-
-from pydantic import PrivateAttr
-
-from crewai.agent import BaseAgent
-from crewai.tools import BaseTool
-
-
-class BaseAgentAdapter(BaseAgent, ABC):
-    """Base class for all agent adapters in CrewAI.
-
-    This abstract class defines the common interface and functionality that all
-    agent adapters must implement. It extends BaseAgent to maintain compatibility
-    with the CrewAI framework while adding adapter-specific requirements.
-    """
-
-    adapted_structured_output: bool = False
-    _agent_config: Optional[Dict[str, Any]] = PrivateAttr(default=None)
-
-    model_config = {"arbitrary_types_allowed": True}
-
-    def __init__(self, agent_config: Optional[Dict[str, Any]] = None, **kwargs: Any):
-        super().__init__(adapted_agent=True, **kwargs)
-        self._agent_config = agent_config
-
-    @abstractmethod
-    def configure_tools(self, tools: Optional[List[BaseTool]] = None) -> None:
-        """Configure and adapt tools for the specific agent implementation.
-
-        Args:
-            tools: Optional list of BaseTool instances to be configured
-        """
-        pass
-
-    def configure_structured_output(self, structured_output: Any) -> None:
-        """Configure the structured output for the specific agent implementation.
-
-        Args:
-            structured_output: The structured output to be configured
-        """
-        pass

src/crewai/agents/agent_adapters/base_converter_adapter.py

@@ -1,29 +0,0 @@
-from abc import ABC, abstractmethod
-
-
-class BaseConverterAdapter(ABC):
-    """Base class for all converter adapters in CrewAI.
-
-    This abstract class defines the common interface and functionality that all
-    converter adapters must implement for converting structured output.
-    """
-
-    def __init__(self, agent_adapter):
-        self.agent_adapter = agent_adapter
-
-    @abstractmethod
-    def configure_structured_output(self, task) -> None:
-        """Configure agents to return structured output.
-        Must support json and pydantic output.
-        """
-        pass
-
-    @abstractmethod
-    def enhance_system_prompt(self, base_prompt: str) -> str:
-        """Enhance the system prompt with structured output instructions."""
-        pass
-
-    @abstractmethod
-    def post_process_result(self, result: str) -> str:
-        """Post-process the result to ensure it matches the expected format: string."""
-        pass

src/crewai/agents/agent_adapters/base_tool_adapter.py

@@ -1,37 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, List, Optional
-
-from crewai.tools.base_tool import BaseTool
-
-
-class BaseToolAdapter(ABC):
-    """Base class for all tool adapters in CrewAI.
-
-    This abstract class defines the common interface that all tool adapters
-    must implement. It provides the structure for adapting CrewAI tools to
-    different frameworks and platforms.
-    """
-
-    original_tools: List[BaseTool]
-    converted_tools: List[Any]
-
-    def __init__(self, tools: Optional[List[BaseTool]] = None):
-        self.original_tools = tools or []
-        self.converted_tools = []
-
-    @abstractmethod
-    def configure_tools(self, tools: List[BaseTool]) -> None:
-        """Configure and convert tools for the specific implementation.
-
-        Args:
-            tools: List of BaseTool instances to be configured and converted
-        """
-        pass
-
-    def tools(self) -> List[Any]:
-        """Return all converted tools."""
-        return self.converted_tools
-
-    def sanitize_tool_name(self, tool_name: str) -> str:
-        """Sanitize tool name for API compatibility."""
-        return tool_name.replace(" ", "_")

src/crewai/agents/agent_adapters/langgraph/langgraph_adapter.py

@@ -1,226 +0,0 @@
-from typing import Any, AsyncIterable, Dict, List, Optional
-
-from pydantic import Field, PrivateAttr
-
-from crewai.agents.agent_adapters.base_agent_adapter import BaseAgentAdapter
-from crewai.agents.agent_adapters.langgraph.langgraph_tool_adapter import (
-    LangGraphToolAdapter,
-)
-from crewai.agents.agent_adapters.langgraph.structured_output_converter import (
-    LangGraphConverterAdapter,
-)
-from crewai.agents.agent_builder.base_agent import BaseAgent
-from crewai.tools.agent_tools.agent_tools import AgentTools
-from crewai.tools.base_tool import BaseTool
-from crewai.utilities import Logger
-from crewai.utilities.converter import Converter
-from crewai.utilities.events import crewai_event_bus
-from crewai.utilities.events.agent_events import (
-    AgentExecutionCompletedEvent,
-    AgentExecutionErrorEvent,
-    AgentExecutionStartedEvent,
-)
-
-try:
-    from langchain_core.messages import ToolMessage
-    from langgraph.checkpoint.memory import MemorySaver
-    from langgraph.prebuilt import create_react_agent
-
-    LANGGRAPH_AVAILABLE = True
-except ImportError:
-    LANGGRAPH_AVAILABLE = False
-
-
-class LangGraphAgentAdapter(BaseAgentAdapter):
-    """Adapter for LangGraph agents to work with CrewAI."""
-
-    model_config = {"arbitrary_types_allowed": True}
-
-    _logger: Logger = PrivateAttr(default_factory=lambda: Logger())
-    _tool_adapter: LangGraphToolAdapter = PrivateAttr()
-    _graph: Any = PrivateAttr(default=None)
-    _memory: Any = PrivateAttr(default=None)
-    _max_iterations: int = PrivateAttr(default=10)
-    function_calling_llm: Any = Field(default=None)
-    step_callback: Any = Field(default=None)
-
-    model: str = Field(default="gpt-4o")
-    verbose: bool = Field(default=False)
-
-    def __init__(
-        self,
-        role: str,
-        goal: str,
-        backstory: str,
-        tools: Optional[List[BaseTool]] = None,
-        llm: Any = None,
-        max_iterations: int = 10,
-        agent_config: Optional[Dict[str, Any]] = None,
-        **kwargs,
-    ):
-        """Initialize the LangGraph agent adapter."""
-        if not LANGGRAPH_AVAILABLE:
-            raise ImportError(
-                "LangGraph Agent Dependencies are not installed. Please install it using `uv add langchain-core langgraph`"
-            )
-        super().__init__(
-            role=role,
-            goal=goal,
-            backstory=backstory,
-            tools=tools,
-            llm=llm or self.model,
-            agent_config=agent_config,
-            **kwargs,
-        )
-        self._tool_adapter = LangGraphToolAdapter(tools=tools)
-        self._converter_adapter = LangGraphConverterAdapter(self)
-        self._max_iterations = max_iterations
-        self._setup_graph()
-
-    def _setup_graph(self) -> None:
-        """Set up the LangGraph workflow graph."""
-        try:
-            self._memory = MemorySaver()
-
-            converted_tools: List[Any] = self._tool_adapter.tools()
-            if self._agent_config:
-                self._graph = create_react_agent(
-                    model=self.llm,
-                    tools=converted_tools,
-                    checkpointer=self._memory,
-                    debug=self.verbose,
-                    **self._agent_config,
-                )
-            else:
-                self._graph = create_react_agent(
-                    model=self.llm,
-                    tools=converted_tools or [],
-                    checkpointer=self._memory,
-                    debug=self.verbose,
-                )
-
-        except ImportError as e:
-            self._logger.log(
-                "error", f"Failed to import LangGraph dependencies: {str(e)}"
-            )
-            raise
-        except Exception as e:
-            self._logger.log("error", f"Error setting up LangGraph agent: {str(e)}")
-            raise
-
-    def _build_system_prompt(self) -> str:
-        """Build a system prompt for the LangGraph agent."""
-        base_prompt = f"""
-            You are {self.role}.
-        
-            Your goal is: {self.goal}
-
-            Your backstory: {self.backstory}
-
-            When working on tasks, think step-by-step and use the available tools when necessary.
-        """
-        return self._converter_adapter.enhance_system_prompt(base_prompt)
-
-    def execute_task(
-        self,
-        task: Any,
-        context: Optional[str] = None,
-        tools: Optional[List[BaseTool]] = None,
-    ) -> str:
-        """Execute a task using the LangGraph workflow."""
-        self.create_agent_executor(tools)
-
-        self.configure_structured_output(task)
-
-        try:
-            task_prompt = task.prompt() if hasattr(task, "prompt") else str(task)
-
-            if context:
-                task_prompt = self.i18n.slice("task_with_context").format(
-                    task=task_prompt, context=context
-                )
-
-            crewai_event_bus.emit(
-                self,
-                event=AgentExecutionStartedEvent(
-                    agent=self,
-                    tools=self.tools,
-                    task_prompt=task_prompt,
-                    task=task,
-                ),
-            )
-
-            session_id = f"task_{id(task)}"
-
-            config = {"configurable": {"thread_id": session_id}}
-
-            result = self._graph.invoke(
-                {
-                    "messages": [
-                        ("system", self._build_system_prompt()),
-                        ("user", task_prompt),
-                    ]
-                },
-                config,
-            )
-
-            messages = result.get("messages", [])
-            last_message = messages[-1] if messages else None
-
-            final_answer = ""
-            if isinstance(last_message, dict):
-                final_answer = last_message.get("content", "")
-            elif hasattr(last_message, "content"):
-                final_answer = getattr(last_message, "content", "")
-
-            final_answer = (
-                self._converter_adapter.post_process_result(final_answer)
-                or "Task execution completed but no clear answer was provided."
-            )
-            crewai_event_bus.emit(
-                self,
-                event=AgentExecutionCompletedEvent(
-                    agent=self, task=task, output=final_answer
-                ),
-            )
-
-            return final_answer
-
-        except Exception as e:
-            self._logger.log("error", f"Error executing LangGraph task: {str(e)}")
-            crewai_event_bus.emit(
-                self,
-                event=AgentExecutionErrorEvent(
-                    agent=self,
-                    task=task,
-                    error=str(e),
-                ),
-            )
-            raise
-
-    def create_agent_executor(self, tools: Optional[List[BaseTool]] = None) -> None:
-        """Configure the LangGraph agent for execution."""
-        self.configure_tools(tools)
-
-    def configure_tools(self, tools: Optional[List[BaseTool]] = None) -> None:
-        """Configure tools for the LangGraph agent."""
-        if tools:
-            all_tools = list(self.tools or []) + list(tools or [])
-            self._tool_adapter.configure_tools(all_tools)
-            available_tools = self._tool_adapter.tools()
-            self._graph.tools = available_tools
-
-    def get_delegation_tools(self, agents: List[BaseAgent]) -> List[BaseTool]:
-        """Implement delegation tools support for LangGraph."""
-        agent_tools = AgentTools(agents=agents)
-        return agent_tools.tools()
-
-    def get_output_converter(
-        self, llm: Any, text: str, model: Any, instructions: str
-    ) -> Any:
-        """Convert output format if needed."""
-        return Converter(llm=llm, text=text, model=model, instructions=instructions)
-
-    def configure_structured_output(self, task) -> None:
-        """Configure the structured output for LangGraph."""
-        self._converter_adapter.configure_structured_output(task)

src/crewai/agents/agent_adapters/langgraph/langgraph_tool_adapter.py

@@ -1,61 +0,0 @@
-import inspect
-from typing import Any, List, Optional
-
-from crewai.agents.agent_adapters.base_tool_adapter import BaseToolAdapter
-from crewai.tools.base_tool import BaseTool
-
-
-class LangGraphToolAdapter(BaseToolAdapter):
-    """Adapts CrewAI tools to LangGraph agent tool compatible format"""
-
-    def __init__(self, tools: Optional[List[BaseTool]] = None):
-        self.original_tools = tools or []
-        self.converted_tools = []
-
-    def configure_tools(self, tools: List[BaseTool]) -> None:
-        """
-        Configure and convert CrewAI tools to LangGraph-compatible format.
-        LangGraph expects tools in langchain_core.tools format.
-        """
-        from langchain_core.tools import BaseTool, StructuredTool
-
-        converted_tools = []
-        if self.original_tools:
-            all_tools = tools + self.original_tools
-        else:
-            all_tools = tools
-        for tool in all_tools:
-            if isinstance(tool, BaseTool):
-                converted_tools.append(tool)
-                continue
-
-            sanitized_name = self.sanitize_tool_name(tool.name)
-
-            async def tool_wrapper(*args, tool=tool, **kwargs):
-                output = None
-                if len(args) > 0 and isinstance(args[0], str):
-                    output = tool.run(args[0])
-                elif "input" in kwargs:
-                    output = tool.run(kwargs["input"])
-                else:
-                    output = tool.run(**kwargs)
-
-                if inspect.isawaitable(output):
-                    result = await output
-                else:
-                    result = output
-                return result
-
-            converted_tool = StructuredTool(
-                name=sanitized_name,
-                description=tool.description,
-                func=tool_wrapper,
-                args_schema=tool.args_schema,
-            )
-
-            converted_tools.append(converted_tool)
-
-        self.converted_tools = converted_tools
-
-    def tools(self) -> List[Any]:
-        return self.converted_tools or []

src/crewai/agents/agent_adapters/langgraph/structured_output_converter.py

@@ -1,80 +0,0 @@
-import json
-
-from crewai.agents.agent_adapters.base_converter_adapter import BaseConverterAdapter
-from crewai.utilities.converter import generate_model_description
-
-
-class LangGraphConverterAdapter(BaseConverterAdapter):
-    """Adapter for handling structured output conversion in LangGraph agents"""
-
-    def __init__(self, agent_adapter):
-        """Initialize the converter adapter with a reference to the agent adapter"""
-        self.agent_adapter = agent_adapter
-        self._output_format = None
-        self._schema = None
-        self._system_prompt_appendix = None
-
-    def configure_structured_output(self, task) -> None:
-        """Configure the structured output for LangGraph."""
-        if not (task.output_json or task.output_pydantic):
-            self._output_format = None
-            self._schema = None
-            self._system_prompt_appendix = None
-            return
-
-        if task.output_json:
-            self._output_format = "json"
-            self._schema = generate_model_description(task.output_json)
-        elif task.output_pydantic:
-            self._output_format = "pydantic"
-            self._schema = generate_model_description(task.output_pydantic)
-
-        self._system_prompt_appendix = self._generate_system_prompt_appendix()
-
-    def _generate_system_prompt_appendix(self) -> str:
-        """Generate an appendix for the system prompt to enforce structured output"""
-        if not self._output_format or not self._schema:
-            return ""
-
-        return f"""
-Important: Your final answer MUST be provided in the following structured format:
-
-{self._schema}
-
-DO NOT include any markdown code blocks, backticks, or other formatting around your response. 
-The output should be raw JSON that exactly matches the specified schema.
-"""
-
-    def enhance_system_prompt(self, original_prompt: str) -> str:
-        """Add structured output instructions to the system prompt if needed"""
-        if not self._system_prompt_appendix:
-            return original_prompt
-
-        return f"{original_prompt}\n{self._system_prompt_appendix}"
-
-    def post_process_result(self, result: str) -> str:
-        """Post-process the result to ensure it matches the expected format"""
-        if not self._output_format:
-            return result
-
-        # Try to extract valid JSON if it's wrapped in code blocks or other text
-        if self._output_format in ["json", "pydantic"]:
-            try:
-                # First, try to parse as is
-                json.loads(result)
-                return result
-            except json.JSONDecodeError:
-                # Try to extract JSON from the text
-                import re
-
-                json_match = re.search(r"(\{.*\})", result, re.DOTALL)
-                if json_match:
-                    try:
-                        extracted = json_match.group(1)
-                        # Validate it's proper JSON
-                        json.loads(extracted)
-                        return extracted
-                    except:
-                        pass
-
-        return result

src/crewai/agents/agent_adapters/openai_agents/openai_adapter.py

@@ -1,178 +0,0 @@
-from typing import Any, List, Optional
-
-from pydantic import Field, PrivateAttr
-
-from crewai.agents.agent_adapters.base_agent_adapter import BaseAgentAdapter
-from crewai.agents.agent_adapters.openai_agents.structured_output_converter import (
-    OpenAIConverterAdapter,
-)
-from crewai.agents.agent_builder.base_agent import BaseAgent
-from crewai.tools import BaseTool
-from crewai.tools.agent_tools.agent_tools import AgentTools
-from crewai.utilities import Logger
-from crewai.utilities.events import crewai_event_bus
-from crewai.utilities.events.agent_events import (
-    AgentExecutionCompletedEvent,
-    AgentExecutionErrorEvent,
-    AgentExecutionStartedEvent,
-)
-
-try:
-    from agents import Agent as OpenAIAgent  # type: ignore
-    from agents import Runner, enable_verbose_stdout_logging  # type: ignore
-
-    from .openai_agent_tool_adapter import OpenAIAgentToolAdapter
-
-    OPENAI_AVAILABLE = True
-except ImportError:
-    OPENAI_AVAILABLE = False
-
-
-class OpenAIAgentAdapter(BaseAgentAdapter):
-    """Adapter for OpenAI Assistants"""
-
-    model_config = {"arbitrary_types_allowed": True}
-
-    _openai_agent: "OpenAIAgent" = PrivateAttr()
-    _logger: Logger = PrivateAttr(default_factory=lambda: Logger())
-    _active_thread: Optional[str] = PrivateAttr(default=None)
-    function_calling_llm: Any = Field(default=None)
-    step_callback: Any = Field(default=None)
-    _tool_adapter: "OpenAIAgentToolAdapter" = PrivateAttr()
-    _converter_adapter: OpenAIConverterAdapter = PrivateAttr()
-
-    def __init__(
-        self,
-        model: str = "gpt-4o-mini",
-        tools: Optional[List[BaseTool]] = None,
-        agent_config: Optional[dict] = None,
-        **kwargs,
-    ):
-        if not OPENAI_AVAILABLE:
-            raise ImportError(
-                "OpenAI Agent Dependencies are not installed. Please install it using `uv add openai-agents`"
-            )
-        else:
-            role = kwargs.pop("role", None)
-            goal = kwargs.pop("goal", None)
-            backstory = kwargs.pop("backstory", None)
-            super().__init__(
-                role=role,
-                goal=goal,
-                backstory=backstory,
-                tools=tools,
-                agent_config=agent_config,
-                **kwargs,
-            )
-            self._tool_adapter = OpenAIAgentToolAdapter(tools=tools)
-            self.llm = model
-            self._converter_adapter = OpenAIConverterAdapter(self)
-
-    def _build_system_prompt(self) -> str:
-        """Build a system prompt for the OpenAI agent."""
-        base_prompt = f"""
-            You are {self.role}.
-        
-            Your goal is: {self.goal}
-
-            Your backstory: {self.backstory}
-
-            When working on tasks, think step-by-step and use the available tools when necessary.
-        """
-        return self._converter_adapter.enhance_system_prompt(base_prompt)
-
-    def execute_task(
-        self,
-        task: Any,
-        context: Optional[str] = None,
-        tools: Optional[List[BaseTool]] = None,
-    ) -> str:
-        """Execute a task using the OpenAI Assistant"""
-        self._converter_adapter.configure_structured_output(task)
-        self.create_agent_executor(tools)
-
-        if self.verbose:
-            enable_verbose_stdout_logging()
-
-        try:
-            task_prompt = task.prompt()
-            if context:
-                task_prompt = self.i18n.slice("task_with_context").format(
-                    task=task_prompt, context=context
-                )
-            crewai_event_bus.emit(
-                self,
-                event=AgentExecutionStartedEvent(
-                    agent=self,
-                    tools=self.tools,
-                    task_prompt=task_prompt,
-                    task=task,
-                ),
-            )
-            result = self.agent_executor.run_sync(self._openai_agent, task_prompt)
-            final_answer = self.handle_execution_result(result)
-            crewai_event_bus.emit(
-                self,
-                event=AgentExecutionCompletedEvent(
-                    agent=self, task=task, output=final_answer
-                ),
-            )
-            return final_answer
-
-        except Exception as e:
-            self._logger.log("error", f"Error executing OpenAI task: {str(e)}")
-            crewai_event_bus.emit(
-                self,
-                event=AgentExecutionErrorEvent(
-                    agent=self,
-                    task=task,
-                    error=str(e),
-                ),
-            )
-            raise
-
-    def create_agent_executor(self, tools: Optional[List[BaseTool]] = None) -> None:
-        """
-        Configure the OpenAI agent for execution.
-        While OpenAI handles execution differently through Runner,
-        we can use this method to set up tools and configurations.
-        """
-        all_tools = list(self.tools or []) + list(tools or [])
-
-        instructions = self._build_system_prompt()
-        self._openai_agent = OpenAIAgent(
-            name=self.role,
-            instructions=instructions,
-            model=self.llm,
-            **self._agent_config or {},
-        )
-
-        if all_tools:
-            self.configure_tools(all_tools)
-
-        self.agent_executor = Runner
-
-    def configure_tools(self, tools: Optional[List[BaseTool]] = None) -> None:
-        """Configure tools for the OpenAI Assistant"""
-        if tools:
-            self._tool_adapter.configure_tools(tools)
-            if self._tool_adapter.converted_tools:
-                self._openai_agent.tools = self._tool_adapter.converted_tools
-
-    def handle_execution_result(self, result: Any) -> str:
-        """Process OpenAI Assistant execution result converting any structured output to a string"""
-        return self._converter_adapter.post_process_result(result.final_output)
-
-    def get_delegation_tools(self, agents: List[BaseAgent]) -> List[BaseTool]:
-        """Implement delegation tools support"""
-        agent_tools = AgentTools(agents=agents)
-        tools = agent_tools.tools()
-        return tools
-
-    def configure_structured_output(self, task) -> None:
-        """Configure the structured output for the specific agent implementation.
-
-        Args:
-            structured_output: The structured output to be configured
-        """
-        self._converter_adapter.configure_structured_output(task)

src/crewai/agents/agent_adapters/openai_agents/openai_agent_tool_adapter.py

@@ -1,91 +0,0 @@
-import inspect
-from typing import Any, List, Optional
-
-from agents import FunctionTool, Tool
-
-from crewai.agents.agent_adapters.base_tool_adapter import BaseToolAdapter
-from crewai.tools import BaseTool
-
-
-class OpenAIAgentToolAdapter(BaseToolAdapter):
-    """Adapter for OpenAI Assistant tools"""
-
-    def __init__(self, tools: Optional[List[BaseTool]] = None):
-        self.original_tools = tools or []
-
-    def configure_tools(self, tools: List[BaseTool]) -> None:
-        """Configure tools for the OpenAI Assistant"""
-        if self.original_tools:
-            all_tools = tools + self.original_tools
-        else:
-            all_tools = tools
-        if all_tools:
-            self.converted_tools = self._convert_tools_to_openai_format(all_tools)
-
-    def _convert_tools_to_openai_format(
-        self, tools: Optional[List[BaseTool]]
-    ) -> List[Tool]:
-        """Convert CrewAI tools to OpenAI Assistant tool format"""
-        if not tools:
-            return []
-
-        def sanitize_tool_name(name: str) -> str:
-            """Convert tool name to match OpenAI's required pattern"""
-            import re
-
-            sanitized = re.sub(r"[^a-zA-Z0-9_-]", "_", name).lower()
-            return sanitized
-
-        def create_tool_wrapper(tool: BaseTool):
-            """Create a wrapper function that handles the OpenAI function tool interface"""
-
-            async def wrapper(context_wrapper: Any, arguments: Any) -> Any:
-                # Get the parameter name from the schema
-                param_name = list(
-                    tool.args_schema.model_json_schema()["properties"].keys()
-                )[0]
-
-                # Handle different argument types
-                if isinstance(arguments, dict):
-                    args_dict = arguments
-                elif isinstance(arguments, str):
-                    try:
-                        import json
-
-                        args_dict = json.loads(arguments)
-                    except json.JSONDecodeError:
-                        args_dict = {param_name: arguments}
-                else:
-                    args_dict = {param_name: str(arguments)}
-
-                # Run the tool with the processed arguments
-                output = tool._run(**args_dict)
-
-                # Await if the tool returned a coroutine
-                if inspect.isawaitable(output):
-                    result = await output
-                else:
-                    result = output
-
-                # Ensure the result is JSON serializable
-                if isinstance(result, (dict, list, str, int, float, bool, type(None))):
-                    return result
-                return str(result)
-
-            return wrapper
-
-        openai_tools = []
-        for tool in tools:
-            schema = tool.args_schema.model_json_schema()
-
-            schema.update({"additionalProperties": False, "type": "object"})
-
-            openai_tool = FunctionTool(
-                name=sanitize_tool_name(tool.name),
-                description=tool.description,
-                params_json_schema=schema,
-                on_invoke_tool=create_tool_wrapper(tool),
-            )
-            openai_tools.append(openai_tool)
-
-        return openai_tools

src/crewai/agents/agent_adapters/openai_agents/structured_output_converter.py

@@ -1,122 +0,0 @@
-import json
-import re
-
-from crewai.agents.agent_adapters.base_converter_adapter import BaseConverterAdapter
-from crewai.utilities.converter import generate_model_description
-from crewai.utilities.i18n import I18N
-
-
-class OpenAIConverterAdapter(BaseConverterAdapter):
-    """
-    Adapter for handling structured output conversion in OpenAI agents.
-
-    This adapter enhances the OpenAI agent to handle structured output formats
-    and post-processes the results when needed.
-
-    Attributes:
-        _output_format: The expected output format (json, pydantic, or None)
-        _schema: The schema description for the expected output
-        _output_model: The Pydantic model for the output
-    """
-
-    def __init__(self, agent_adapter):
-        """Initialize the converter adapter with a reference to the agent adapter"""
-        self.agent_adapter = agent_adapter
-        self._output_format = None
-        self._schema = None
-        self._output_model = None
-
-    def configure_structured_output(self, task) -> None:
-        """
-        Configure the structured output for OpenAI agent based on task requirements.
-
-        Args:
-            task: The task containing output format requirements
-        """
-        # Reset configuration
-        self._output_format = None
-        self._schema = None
-        self._output_model = None
-
-        # If no structured output is required, return early
-        if not (task.output_json or task.output_pydantic):
-            return
-
-        # Configure based on task output format
-        if task.output_json:
-            self._output_format = "json"
-            self._schema = generate_model_description(task.output_json)
-            self.agent_adapter._openai_agent.output_type = task.output_json
-            self._output_model = task.output_json
-        elif task.output_pydantic:
-            self._output_format = "pydantic"
-            self._schema = generate_model_description(task.output_pydantic)
-            self.agent_adapter._openai_agent.output_type = task.output_pydantic
-            self._output_model = task.output_pydantic
-
-    def enhance_system_prompt(self, base_prompt: str) -> str:
-        """
-        Enhance the base system prompt with structured output requirements if needed.
-
-        Args:
-            base_prompt: The original system prompt
-
-        Returns:
-            Enhanced system prompt with output format instructions if needed
-        """
-        if not self._output_format:
-            return base_prompt
-
-        output_schema = (
-            I18N()
-            .slice("formatted_task_instructions")
-            .format(output_format=self._schema)
-        )
-
-        return f"{base_prompt}\n\n{output_schema}"
-
-    def post_process_result(self, result: str) -> str:
-        """
-        Post-process the result to ensure it matches the expected format.
-
-        This method attempts to extract valid JSON from the result if necessary.
-
-        Args:
-            result: The raw result from the agent
-
-        Returns:
-            Processed result conforming to the expected output format
-        """
-        if not self._output_format:
-            return result
-        # Try to extract valid JSON if it's wrapped in code blocks or other text
-        if isinstance(result, str) and self._output_format in ["json", "pydantic"]:
-            # First, try to parse as is
-            try:
-                json.loads(result)
-                return result
-            except json.JSONDecodeError:
-                # Try to extract JSON from markdown code blocks
-                code_block_pattern = r"```(?:json)?\s*([\s\S]*?)```"
-                code_blocks = re.findall(code_block_pattern, result)
-
-                for block in code_blocks:
-                    try:
-                        json.loads(block.strip())
-                        return block.strip()
-                    except json.JSONDecodeError:
-                        continue
-
-                # Try to extract any JSON-like structure
-                json_pattern = r"(\{[\s\S]*\})"
-                json_matches = re.findall(json_pattern, result, re.DOTALL)
-
-                for match in json_matches:
-                    try:
-                        json.loads(match)
-                        return match
-                    except json.JSONDecodeError:
-                        continue
-
-        # If all extraction attempts fail, return the original
-        return str(result)

src/crewai/agents/agent_builder/base_agent.py

@@ -19,7 +19,6 @@ from crewai.agents.agent_builder.utilities.base_token_process import TokenProces
 from crewai.agents.cache.cache_handler import CacheHandler
 from crewai.agents.tools_handler import ToolsHandler
 from crewai.knowledge.knowledge import Knowledge
-from crewai.knowledge.knowledge_config import KnowledgeConfig
 from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
 from crewai.security.security_config import SecurityConfig
 from crewai.tools.base_tool import BaseTool, Tool
@@ -63,6 +62,8 @@ class BaseAgent(ABC, BaseModel):
             Abstract method to execute a task.
         create_agent_executor(tools=None) -> None:
             Abstract method to create an agent executor.
+        _parse_tools(tools: List[BaseTool]) -> List[Any]:
+            Abstract method to parse tools.
         get_delegation_tools(agents: List["BaseAgent"]):
             Abstract method to set the agents task tools for handling delegation and question asking to other agents in crew.
         get_output_converter(llm, model, instructions):
@@ -153,13 +154,6 @@ class BaseAgent(ABC, BaseModel):
     callbacks: List[Callable] = Field(
         default=[], description="Callbacks to be used for the agent"
     )
-    adapted_agent: bool = Field(
-        default=False, description="Whether the agent is adapted"
-    )
-    knowledge_config: Optional[KnowledgeConfig] = Field(
-        default=None,
-        description="Knowledge configuration for the agent such as limits and threshold",
-    )
 
     @model_validator(mode="before")
     @classmethod
@@ -176,15 +170,15 @@ class BaseAgent(ABC, BaseModel):
         tool meets these criteria, it is processed and added to the list of
         tools. Otherwise, a ValueError is raised.
         """
-        if not tools:
-            return []
-
         processed_tools = []
-        required_attrs = ["name", "func", "description"]
         for tool in tools:
             if isinstance(tool, BaseTool):
                 processed_tools.append(tool)
-            elif all(hasattr(tool, attr) for attr in required_attrs):
+            elif (
+                hasattr(tool, "name")
+                and hasattr(tool, "func")
+                and hasattr(tool, "description")
+            ):
                 # Tool has the required attributes, create a Tool instance
                 processed_tools.append(Tool.from_langchain(tool))
             else:
@@ -266,6 +260,13 @@ class BaseAgent(ABC, BaseModel):
         """Set the task tools that init BaseAgenTools class."""
         pass
 
+    @abstractmethod
+    def get_output_converter(
+        self, llm: Any, text: str, model: type[BaseModel] | None, instructions: str
+    ) -> Converter:
+        """Get the converter class for the agent to create json/pydantic outputs."""
+        pass
+
     def copy(self: T) -> T:  # type: ignore # Signature of "copy" incompatible with supertype "BaseModel"
         """Create a deep copy of the Agent."""
         exclude = {

src/crewai/agents/agent_builder/base_agent_executor_mixin.py

@@ -47,31 +47,11 @@ class CrewAgentExecutorMixin:
                 print(f"Failed to add to short term memory: {e}")
                 pass
 
-    def _create_external_memory(self, output) -> None:
-        """Create and save a external-term memory item if conditions are met."""
-        if (
-            self.crew
-            and self.agent
-            and self.task
-            and hasattr(self.crew, "_external_memory")
-            and self.crew._external_memory
-        ):
-            try:
-                self.crew._external_memory.save(
-                    value=output.text,
-                    metadata={
-                        "description": self.task.description,
-                    },
-                    agent=self.agent.role,
-                )
-            except Exception as e:
-                print(f"Failed to add to external memory: {e}")
-                pass
-
     def _create_long_term_memory(self, output) -> None:
         """Create and save long-term and entity memory items based on evaluation."""
         if (
             self.crew
+            and self.crew.memory
             and self.crew._long_term_memory
             and self.crew._entity_memory
             and self.task
@@ -113,15 +93,6 @@ class CrewAgentExecutorMixin:
             except Exception as e:
                 print(f"Failed to add to long term memory: {e}")
                 pass
-        elif (
-            self.crew
-            and self.crew._long_term_memory
-            and self.crew._entity_memory is None
-        ):
-            self._printer.print(
-                content="Long term memory is enabled, but entity memory is not enabled. Please configure entity memory or set memory=True to automatically enable it.",
-                color="bold_yellow",
-            )
 
     def _ask_human_input(self, final_answer: str) -> str:
         """Prompt human input with mode-appropriate messaging."""

src/crewai/agents/crew_agent_executor.py

@@ -129,7 +129,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
 
         self._create_short_term_memory(formatted_answer)
         self._create_long_term_memory(formatted_answer)
-        self._create_external_memory(formatted_answer)
         return {"output": formatted_answer.output}
 
     def _invoke_loop(self) -> AgentFinish:

src/crewai/cli/constants.py

@@ -91,12 +91,6 @@ ENV_VARS = {
             "key_name": "CEREBRAS_API_KEY",
         },
     ],
-    "huggingface": [
-        {
-            "prompt": "Enter your Huggingface API key (HF_TOKEN) (press Enter to skip)",
-            "key_name": "HF_TOKEN",
-        },
-    ],
     "sambanova": [
         {
             "prompt": "Enter your SambaNovaCloud API key (press Enter to skip)",
@@ -112,7 +106,6 @@ PROVIDERS = [
     "gemini",
     "nvidia_nim",
     "groq",
-    "huggingface",
     "ollama",
     "watson",
     "bedrock",
@@ -277,12 +270,6 @@ MODELS = {
         "bedrock/mistral.mistral-7b-instruct-v0:2",
         "bedrock/mistral.mixtral-8x7b-instruct-v0:1",
     ],
-    "huggingface": [
-        "huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct",
-        "huggingface/mistralai/Mixtral-8x7B-Instruct-v0.1",
-        "huggingface/tiiuae/falcon-180B-chat",
-        "huggingface/google/gemma-7b-it",
-    ],
     "sambanova": [
         "sambanova/Meta-Llama-3.3-70B-Instruct",
         "sambanova/QwQ-32B-Preview",

src/crewai/cli/install_crew.py

@@ -3,10 +3,6 @@ import subprocess
 import click
 
 
-# Be mindful about changing this.
-# on some enviorments we don't use this command but instead uv sync directly
-# so if you expect this to support more things you will need to replicate it there
-# ask @joaomdmoura if you are unsure
 def install_crew(proxy_options: list[str]) -> None:
     """
     Install the crew by running the UV command to lock and install.

src/crewai/cli/templates/crew/crew.py

@@ -1,7 +1,6 @@
 from crewai import Agent, Crew, Process, Task
 from crewai.project import CrewBase, agent, crew, task
-from crewai.agents.agent_builder.base_agent import BaseAgent
-from typing import List
+
 # If you want to run a snippet of code before or after the crew starts,
 # you can use the @before_kickoff and @after_kickoff decorators
 # https://docs.crewai.com/concepts/crews#example-crew-class-with-decorators
@@ -10,26 +9,25 @@ from typing import List
 class {{crew_name}}():
     """{{crew_name}} crew"""
 
-    agents: List[BaseAgent]
-    tasks: List[Task]
-
     # Learn more about YAML configuration files here:
     # Agents: https://docs.crewai.com/concepts/agents#yaml-configuration-recommended
     # Tasks: https://docs.crewai.com/concepts/tasks#yaml-configuration-recommended
-    
+    agents_config = 'config/agents.yaml'
+    tasks_config = 'config/tasks.yaml'
+
     # If you would like to add tools to your agents, you can learn more about it here:
     # https://docs.crewai.com/concepts/agents#agent-tools
     @agent
     def researcher(self) -> Agent:
         return Agent(
-            config=self.agents_config['researcher'], # type: ignore[index]
+            config=self.agents_config['researcher'],
             verbose=True
         )
 
     @agent
     def reporting_analyst(self) -> Agent:
         return Agent(
-            config=self.agents_config['reporting_analyst'], # type: ignore[index]
+            config=self.agents_config['reporting_analyst'],
             verbose=True
         )
 
@@ -39,13 +37,13 @@ class {{crew_name}}():
     @task
     def research_task(self) -> Task:
         return Task(
-            config=self.tasks_config['research_task'], # type: ignore[index]
+            config=self.tasks_config['research_task'],
         )
 
     @task
     def reporting_task(self) -> Task:
         return Task(
-            config=self.tasks_config['reporting_task'], # type: ignore[index]
+            config=self.tasks_config['reporting_task'],
             output_file='report.md'
         )
 

src/crewai/cli/templates/crew/main.py

@@ -33,8 +33,7 @@ def train():
     Train the crew for a given number of iterations.
     """
     inputs = {
-        "topic": "AI LLMs",
-        'current_year': str(datetime.now().year)
+        "topic": "AI LLMs"
     }
     try:
         {{crew_name}}().crew().train(n_iterations=int(sys.argv[1]), filename=sys.argv[2], inputs=inputs)
@@ -60,9 +59,8 @@ def test():
         "topic": "AI LLMs",
         "current_year": str(datetime.now().year)
     }
-    
     try:
-        {{crew_name}}().crew().test(n_iterations=int(sys.argv[1]), eval_llm=sys.argv[2], inputs=inputs)
+        {{crew_name}}().crew().test(n_iterations=int(sys.argv[1]), openai_model_name=sys.argv[2], inputs=inputs)
 
     except Exception as e:
         raise Exception(f"An error occurred while testing the crew: {e}")

src/crewai/cli/templates/crew/pyproject.toml

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<3.13"
 dependencies = [
-    "crewai[tools]>=0.114.0,<1.0.0"
+    "crewai[tools]>=0.108.0,<1.0.0"
 ]
 
 [project.scripts]

src/crewai/cli/templates/flow/crews/poem_crew/poem_crew.py

@@ -1,7 +1,5 @@
 from crewai import Agent, Crew, Process, Task
 from crewai.project import CrewBase, agent, crew, task
-from crewai.agents.agent_builder.base_agent import BaseAgent
-from typing import List
 
 # If you want to run a snippet of code before or after the crew starts,
 # you can use the @before_kickoff and @after_kickoff decorators
@@ -12,9 +10,6 @@ from typing import List
 class PoemCrew:
     """Poem Crew"""
 
-    agents: List[BaseAgent]
-    tasks: List[Task]
-
     # Learn more about YAML configuration files here:
     # Agents: https://docs.crewai.com/concepts/agents#yaml-configuration-recommended
     # Tasks: https://docs.crewai.com/concepts/tasks#yaml-configuration-recommended
@@ -26,7 +21,7 @@ class PoemCrew:
     @agent
     def poem_writer(self) -> Agent:
         return Agent(
-            config=self.agents_config["poem_writer"],  # type: ignore[index]
+            config=self.agents_config["poem_writer"],
         )
 
     # To learn more about structured task outputs,
@@ -35,7 +30,7 @@ class PoemCrew:
     @task
     def write_poem(self) -> Task:
         return Task(
-            config=self.tasks_config["write_poem"],  # type: ignore[index]
+            config=self.tasks_config["write_poem"],
         )
 
     @crew

src/crewai/cli/templates/flow/pyproject.toml

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<3.13"
 dependencies = [
-    "crewai[tools]>=0.114.0,<1.0.0",
+    "crewai[tools]>=0.108.0,<1.0.0",
 ]
 
 [project.scripts]

src/crewai/cli/templates/tool/pyproject.toml

@@ -5,7 +5,7 @@ description = "Power up your crews with {{folder_name}}"
 readme = "README.md"
 requires-python = ">=3.10,<3.13"
 dependencies = [
-    "crewai[tools]>=0.114.0"
+    "crewai[tools]>=0.108.0"
 ]
 
 [tool.crewai]

src/crewai/cli/tools/main.py

@@ -117,9 +117,7 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
 
         published_handle = publish_response.json()["handle"]
         console.print(
-            f"Successfully published `{published_handle}` ({project_version}).\n\n"
-            + "⚠️ Security checks are running in the background. Your tool will be available once these are complete.\n"
-            + f"You can monitor the status or access your tool here:\nhttps://app.crewai.com/crewai_plus/tools/{published_handle}",
+            f"Successfully published {published_handle} ({project_version}).\nInstall it in other projects with crewai tool install {published_handle}",
             style="bold green",
         )
 
@@ -155,12 +153,8 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
         login_response_json = login_response.json()
 
         settings = Settings()
-        settings.tool_repository_username = login_response_json["credential"][
-            "username"
-        ]
-        settings.tool_repository_password = login_response_json["credential"][
-            "password"
-        ]
+        settings.tool_repository_username = login_response_json["credential"]["username"]
+        settings.tool_repository_password = login_response_json["credential"]["password"]
         settings.dump()
 
         console.print(
@@ -185,7 +179,7 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
             capture_output=False,
             env=self._build_env_with_credentials(repository_handle),
             text=True,
-            check=True,
+            check=True
         )
 
         if add_package_result.stderr:
@@ -210,11 +204,7 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
         settings = Settings()
 
         env = os.environ.copy()
-        env[f"UV_INDEX_{repository_handle}_USERNAME"] = str(
-            settings.tool_repository_username or ""
-        )
-        env[f"UV_INDEX_{repository_handle}_PASSWORD"] = str(
-            settings.tool_repository_password or ""
-        )
+        env[f"UV_INDEX_{repository_handle}_USERNAME"] = str(settings.tool_repository_username or "")
+        env[f"UV_INDEX_{repository_handle}_PASSWORD"] = str(settings.tool_repository_password or "")
 
         return env

src/crewai/cli/utils.py

@@ -273,9 +273,11 @@ def get_crew(crew_path: str = "crew.py", require: bool = False) -> Crew | None:
                         for attr_name in dir(module):
                             attr = getattr(module, attr_name)
                             try:
-                                if callable(attr) and hasattr(attr, "crew"):
-                                    crew_instance = attr().crew()
-                                    return crew_instance
+                                if isinstance(attr, Crew) and hasattr(attr, "kickoff"):
+                                    print(
+                                        f"Found valid crew object in attribute '{attr_name}' at {crew_os_path}."
+                                    )
+                                    return attr
 
                             except Exception as e:
                                 print(f"Error processing attribute {attr_name}: {e}")

src/crewai/crew.py

@@ -28,7 +28,6 @@ from crewai.knowledge.knowledge import Knowledge
 from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
 from crewai.llm import LLM, BaseLLM
 from crewai.memory.entity.entity_memory import EntityMemory
-from crewai.memory.external.external_memory import ExternalMemory
 from crewai.memory.long_term.long_term_memory import LongTermMemory
 from crewai.memory.short_term.short_term_memory import ShortTermMemory
 from crewai.memory.user.user_memory import UserMemory
@@ -106,7 +105,6 @@ class Crew(BaseModel):
     _long_term_memory: Optional[InstanceOf[LongTermMemory]] = PrivateAttr()
     _entity_memory: Optional[InstanceOf[EntityMemory]] = PrivateAttr()
     _user_memory: Optional[InstanceOf[UserMemory]] = PrivateAttr()
-    _external_memory: Optional[InstanceOf[ExternalMemory]] = PrivateAttr()
     _train: Optional[bool] = PrivateAttr(default=False)
     _train_iteration: Optional[int] = PrivateAttr()
     _inputs: Optional[Dict[str, Any]] = PrivateAttr(default=None)
@@ -147,10 +145,6 @@ class Crew(BaseModel):
         default=None,
         description="An instance of the UserMemory to be used by the Crew to store/fetch memories of a specific user.",
     )
-    external_memory: Optional[InstanceOf[ExternalMemory]] = Field(
-        default=None,
-        description="An Instance of the ExternalMemory to be used by the Crew",
-    )
     embedder: Optional[dict] = Field(
         default=None,
         description="Configuration for the embedder to be used for the crew.",
@@ -275,49 +269,40 @@ class Crew(BaseModel):
 
         return self
 
-    def _initialize_user_memory(self):
-        if (
-            self.memory_config
-            and "user_memory" in self.memory_config
-            and self.memory_config.get("provider") == "mem0"
-        ):  # Check for user_memory in config
-            user_memory_config = self.memory_config["user_memory"]
-            if isinstance(
-                user_memory_config, dict
-            ):  # Check if it's a configuration dict
-                self._user_memory = UserMemory(crew=self)
-            else:
-                raise TypeError("user_memory must be a configuration dictionary")
-
-    def _initialize_default_memories(self):
-        self._long_term_memory = self._long_term_memory or LongTermMemory()
-        self._short_term_memory = self._short_term_memory or ShortTermMemory(
-            crew=self,
-            embedder_config=self.embedder,
-        )
-        self._entity_memory = self.entity_memory or EntityMemory(
-            crew=self, embedder_config=self.embedder
-        )
-
     @model_validator(mode="after")
     def create_crew_memory(self) -> "Crew":
-        """Initialize private memory attributes."""
-        self._external_memory = (
-            # External memory doesn’t support a default value since it was designed to be managed entirely externally
-            self.external_memory.set_crew(self) if self.external_memory else None
-        )
-
-        self._long_term_memory = self.long_term_memory
-        self._short_term_memory = self.short_term_memory
-        self._entity_memory = self.entity_memory
-
-        # UserMemory is gonna to be deprecated in the future, but we have to initialize a default value for now
-        self._user_memory = None
-
+        """Set private attributes."""
         if self.memory:
-            self._initialize_default_memories()
-            self._initialize_user_memory()
-
+            self._long_term_memory = (
+                self.long_term_memory if self.long_term_memory else LongTermMemory()
+            )
+            self._short_term_memory = (
+                self.short_term_memory
+                if self.short_term_memory
+                else ShortTermMemory(
+                    crew=self,
+                    embedder_config=self.embedder,
+                )
+            )
+            self._entity_memory = (
+                self.entity_memory
+                if self.entity_memory
+                else EntityMemory(crew=self, embedder_config=self.embedder)
+            )
+            if (
+                self.memory_config
+                and "user_memory" in self.memory_config
+                and self.memory_config.get("provider") == "mem0"
+            ):  # Check for user_memory in config
+                user_memory_config = self.memory_config["user_memory"]
+                if isinstance(
+                    user_memory_config, dict
+                ):  # Check if it's a configuration dict
+                    self._user_memory = UserMemory(crew=self)
+                else:
+                    raise TypeError("user_memory must be a configuration dictionary")
+            else:
+                self._user_memory = None  # No user memory if not in config
         return self
 
     @model_validator(mode="after")
@@ -1134,13 +1119,9 @@ class Crew(BaseModel):
         result = self._execute_tasks(self.tasks, start_index, True)
         return result
 
-    def query_knowledge(
-        self, query: List[str], results_limit: int = 3, score_threshold: float = 0.35
-    ) -> Union[List[Dict[str, Any]], None]:
+    def query_knowledge(self, query: List[str]) -> Union[List[Dict[str, Any]], None]:
         if self.knowledge:
-            return self.knowledge.query(
-                query, results_limit=results_limit, score_threshold=score_threshold
-            )
+            return self.knowledge.query(query)
         return None
 
     def fetch_inputs(self) -> Set[str]:
@@ -1186,7 +1167,6 @@ class Crew(BaseModel):
             "_short_term_memory",
             "_long_term_memory",
             "_entity_memory",
-            "_external_memory",
             "_telemetry",
             "agents",
             "tasks",
@@ -1221,20 +1201,6 @@ class Crew(BaseModel):
 
         copied_data = self.model_dump(exclude=exclude)
         copied_data = {k: v for k, v in copied_data.items() if v is not None}
-        if self.short_term_memory:
-            copied_data["short_term_memory"] = self.short_term_memory.model_copy(
-                deep=True
-            )
-        if self.long_term_memory:
-            copied_data["long_term_memory"] = self.long_term_memory.model_copy(
-                deep=True
-            )
-        if self.entity_memory:
-            copied_data["entity_memory"] = self.entity_memory.model_copy(deep=True)
-        if self.external_memory:
-            copied_data["external_memory"] = self.external_memory.model_copy(deep=True)
-        if self.user_memory:
-            copied_data["user_memory"] = self.user_memory.model_copy(deep=True)
 
         copied_data.pop("agents", None)
         copied_data.pop("tasks", None)
@@ -1347,15 +1313,7 @@ class Crew(BaseModel):
             RuntimeError: If memory reset operation fails.
         """
         VALID_TYPES = frozenset(
-            [
-                "long",
-                "short",
-                "entity",
-                "knowledge",
-                "kickoff_outputs",
-                "all",
-                "external",
-            ]
+            ["long", "short", "entity", "knowledge", "kickoff_outputs", "all"]
         )
 
         if command_type not in VALID_TYPES:
@@ -1381,7 +1339,6 @@ class Crew(BaseModel):
         memory_systems = [
             ("short term", getattr(self, "_short_term_memory", None)),
             ("entity", getattr(self, "_entity_memory", None)),
-            ("external", getattr(self, "_external_memory", None)),
             ("long term", getattr(self, "_long_term_memory", None)),
             ("task output", getattr(self, "_task_output_handler", None)),
             ("knowledge", getattr(self, "knowledge", None)),
@@ -1404,15 +1361,11 @@ class Crew(BaseModel):
             RuntimeError: If the specified memory system fails to reset
         """
         reset_functions = {
-            "long": (getattr(self, "_long_term_memory", None), "long term"),
-            "short": (getattr(self, "_short_term_memory", None), "short term"),
-            "entity": (getattr(self, "_entity_memory", None), "entity"),
-            "knowledge": (getattr(self, "knowledge", None), "knowledge"),
-            "kickoff_outputs": (
-                getattr(self, "_task_output_handler", None),
-                "task output",
-            ),
-            "external": (getattr(self, "_external_memory", None), "external"),
+            "long": (self._long_term_memory, "long term"),
+            "short": (self._short_term_memory, "short term"),
+            "entity": (self._entity_memory, "entity"),
+            "knowledge": (self.knowledge, "knowledge"),
+            "kickoff_outputs": (self._task_output_handler, "task output"),
         }
 
         memory_system, name = reset_functions[memory_type]

src/crewai/flow/flow.py

@@ -1043,7 +1043,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
             import traceback
 
             traceback.print_exc()
-            raise
 
     def _log_flow_event(
         self, message: str, color: str = "yellow", level: str = "info"

src/crewai/flow/persistence/sqlite.py

@@ -21,7 +21,7 @@ class SQLiteFlowPersistence(FlowPersistence):
     moderate performance requirements.
     """
 
-    db_path: str
+    db_path: str  # Type annotation for instance variable
 
     def __init__(self, db_path: Optional[str] = None):
         """Initialize SQLite persistence.

src/crewai/knowledge/knowledge.py

@@ -1,18 +1,11 @@
 import os
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 
 from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
 from crewai.knowledge.storage.knowledge_storage import KnowledgeStorage
 
-try:
-    from crewai.knowledge.storage.elasticsearch_knowledge_storage import (
-        ElasticsearchKnowledgeStorage,
-    )
-except ImportError:
-    ElasticsearchKnowledgeStorage = None
-
 os.environ["TOKENIZERS_PARALLELISM"] = "false"  # removes logging from fastembed
 
 
@@ -37,34 +30,20 @@ class Knowledge(BaseModel):
         sources: List[BaseKnowledgeSource],
         embedder: Optional[Dict[str, Any]] = None,
         storage: Optional[KnowledgeStorage] = None,
-        storage_provider: str = "chromadb",
         **data,
     ):
         super().__init__(**data)
         if storage:
             self.storage = storage
         else:
-            if storage_provider == "elasticsearch":
-                try:
-                    self.storage = cast(KnowledgeStorage, self._create_elasticsearch_storage(
-                        embedder, collection_name
-                    ))
-                except ImportError:
-                    raise ImportError(
-                        "Elasticsearch is not installed. Please install it with `pip install elasticsearch`."
-                    )
-            else:
-                self.storage = KnowledgeStorage(
-                    embedder=embedder, collection_name=collection_name
-                )
+            self.storage = KnowledgeStorage(
+                embedder=embedder, collection_name=collection_name
+            )
         self.sources = sources
-        if self.storage is not None:
-            self.storage.initialize_knowledge_storage()
+        self.storage.initialize_knowledge_storage()
         self._add_sources()
 
-    def query(
-        self, query: List[str], results_limit: int = 3, score_threshold: float = 0.35
-    ) -> List[Dict[str, Any]]:
+    def query(self, query: List[str], limit: int = 3) -> List[Dict[str, Any]]:
         """
         Query across all knowledge sources to find the most relevant information.
         Returns the top_k most relevant chunks.
@@ -77,8 +56,7 @@ class Knowledge(BaseModel):
 
         results = self.storage.search(
             query,
-            limit=results_limit,
-            score_threshold=score_threshold,
+            limit,
         )
         return results
 
@@ -90,16 +68,6 @@ class Knowledge(BaseModel):
         except Exception as e:
             raise e
 
-    def _create_elasticsearch_storage(self, embedder, collection_name):
-        """Create an Elasticsearch storage instance."""
-        if ElasticsearchKnowledgeStorage is None:
-            raise ImportError(
-                "Elasticsearch is not installed. Please install it with `pip install elasticsearch`."
-            )
-        return ElasticsearchKnowledgeStorage(
-            embedder_config=embedder, collection_name=collection_name
-        )
-
     def reset(self) -> None:
         if self.storage:
             self.storage.reset()

src/crewai/knowledge/knowledge_config.py

@@ -1,16 +0,0 @@
-from pydantic import BaseModel, Field
-
-
-class KnowledgeConfig(BaseModel):
-    """Configuration for knowledge retrieval.
-
-    Args:
-        results_limit (int): The number of relevant documents to return.
-        score_threshold (float): The minimum score for a document to be considered relevant.
-    """
-
-    results_limit: int = Field(default=3, description="The number of results to return")
-    score_threshold: float = Field(
-        default=0.35,
-        description="The minimum score for a result to be considered relevant",
-    )

src/crewai/knowledge/storage/elasticsearch_knowledge_storage.py

@@ -1,268 +0,0 @@
-import contextlib
-import hashlib
-import io
-import logging
-import os
-from typing import Any, Dict, List, Optional, Union, cast
-
-from crewai.knowledge.storage.base_knowledge_storage import BaseKnowledgeStorage
-from crewai.utilities import EmbeddingConfigurator
-from crewai.utilities.logger import Logger
-from crewai.utilities.paths import db_storage_path
-
-
-@contextlib.contextmanager
-def suppress_logging(logger_name="elasticsearch", 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 ElasticsearchKnowledgeStorage(BaseKnowledgeStorage):
-    """
-    Extends BaseKnowledgeStorage to use Elasticsearch for storing embeddings
-    and improving search efficiency.
-    """
-
-    app: Any = None
-    collection_name: Optional[str] = "knowledge"
-
-    def __init__(
-        self,
-        embedder_config: Optional[Dict[str, Any]] = None,
-        collection_name: Optional[str] = None,
-        host: str = "localhost",
-        port: int = 9200,
-        username: Optional[str] = None,
-        password: Optional[str] = None,
-        **kwargs: Any
-    ):
-        self.collection_name = collection_name
-        self._set_embedder_config(embedder_config)
-        
-        self.host = host
-        self.port = port
-        self.username = username
-        self.password = password
-        self.index_name = f"crewai_knowledge_{collection_name if collection_name else 'default'}".lower()
-        self.additional_config = kwargs
-
-    def search(
-        self,
-        query: List[str],
-        limit: int = 3,
-        filter: Optional[dict] = None,
-        score_threshold: float = 0.35,
-    ) -> List[Dict[str, Any]]:
-        if not self.app:
-            self.initialize_knowledge_storage()
-            
-        try:
-            embedding = self._get_embedding_for_text(query[0])
-            
-            search_query: Dict[str, Any] = {
-                "size": limit,
-                "query": {
-                    "script_score": {
-                        "query": {"match_all": {}},
-                        "script": {
-                            "source": "cosineSimilarity(params.query_vector, 'embedding') + 1.0",
-                            "params": {"query_vector": embedding}
-                        }
-                    }
-                }
-            }
-            
-            if filter:
-                query_obj = search_query.get("query", {})
-                if isinstance(query_obj, dict):
-                    script_score_obj = query_obj.get("script_score", {})
-                    if isinstance(script_score_obj, dict):
-                        query_part = script_score_obj.get("query", {})
-                        if isinstance(query_part, dict):
-                            for key, value in filter.items():
-                                new_query = {
-                                    "bool": {
-                                        "must": [
-                                            query_part,
-                                            {"match": {f"metadata.{key}": value}}
-                                        ]
-                                    }
-                                }
-                                if isinstance(script_score_obj, dict):
-                                    script_score_obj["query"] = new_query
-            
-            with suppress_logging():
-                if self.app is not None and hasattr(self.app, "search") and callable(getattr(self.app, "search")):
-                    response = self.app.search(
-                        index=self.index_name,
-                        body=search_query
-                    )
-                
-                    results = []
-                    for hit in response["hits"]["hits"]:
-                        adjusted_score = (hit["_score"] - 1.0)
-                        
-                        if adjusted_score >= score_threshold:
-                            results.append({
-                                "id": hit["_id"],
-                                "metadata": hit["_source"]["metadata"],
-                                "context": hit["_source"]["text"],
-                                "score": adjusted_score,
-                            })
-                        
-                    return results
-                else:
-                    Logger(verbose=True).log("error", "Elasticsearch client is not initialized", "red")
-                    return []
-        except Exception as e:
-            Logger(verbose=True).log("error", f"Search error: {e}", "red")
-            raise Exception(f"Error during knowledge search: {str(e)}")
-
-    def initialize_knowledge_storage(self):
-        try:
-            from elasticsearch import Elasticsearch
-            
-            es_auth = {}
-            if self.username and self.password:
-                es_auth = {"basic_auth": (self.username, self.password)}
-                
-            self.app = Elasticsearch(
-                [f"http://{self.host}:{self.port}"], 
-                **es_auth,
-                **self.additional_config
-            )
-            
-            if not self.app.indices.exists(index=self.index_name):
-                self.app.indices.create(
-                    index=self.index_name,
-                    body={
-                        "mappings": {
-                            "properties": {
-                                "text": {"type": "text"},
-                                "embedding": {
-                                    "type": "dense_vector",
-                                    "dims": 1536,  # Default for OpenAI embeddings
-                                    "index": True,
-                                    "similarity": "cosine"
-                                },
-                                "metadata": {"type": "object"}
-                            }
-                        }
-                    }
-                )
-                
-        except ImportError:
-            raise ImportError(
-                "Elasticsearch is not installed. Please install it with `pip install elasticsearch`."
-            )
-        except Exception as e:
-            Logger(verbose=True).log(
-                "error", 
-                f"Error initializing Elasticsearch: {str(e)}", 
-                "red"
-            )
-            raise Exception(f"Error initializing Elasticsearch: {str(e)}")
-
-    def reset(self) -> None:
-        try:
-            if self.app is not None:
-                if self.app.indices.exists(index=self.index_name):
-                    self.app.indices.delete(index=self.index_name)
-                
-                self.initialize_knowledge_storage()
-        except Exception as e:
-            raise Exception(
-                f"An error occurred while resetting the knowledge storage: {e}"
-            )
-               
-    def save(
-        self,
-        documents: List[str],
-        metadata: Optional[Union[Dict[str, Any], List[Dict[str, Any]]]] = None,
-    ) -> None:
-        if not self.app:
-            self.initialize_knowledge_storage()
-
-        try:
-            unique_docs = {}
-
-            for idx, doc in enumerate(documents):
-                doc_id = hashlib.sha256(doc.encode("utf-8")).hexdigest()
-                doc_metadata = None
-                if metadata is not None:
-                    if isinstance(metadata, list):
-                        doc_metadata = metadata[idx]
-                    else:
-                        doc_metadata = metadata
-                unique_docs[doc_id] = (doc, doc_metadata)
-
-            for doc_id, (doc, meta) in unique_docs.items():
-                embedding = self._get_embedding_for_text(doc)
-                
-                doc_body = {
-                    "text": doc,
-                    "embedding": embedding,
-                    "metadata": meta or {},
-                }
-                
-                if self.app is not None and hasattr(self.app, "index") and callable(getattr(self.app, "index")):
-                    index_func = getattr(self.app, "index")
-                    index_func(
-                        index=self.index_name,
-                        id=doc_id,
-                        document=doc_body,
-                        refresh=True  # Make the document immediately available for search
-                    )
-                else:
-                    Logger(verbose=True).log("error", "Elasticsearch client is not initialized", "red")
-                
-        except Exception as e:
-            Logger(verbose=True).log("error", f"Save error: {e}", "red")
-            raise Exception(f"Error during knowledge save: {str(e)}")
-
-    def _get_embedding_for_text(self, text: str) -> List[float]:
-        """Get embedding for text using the configured embedder."""
-        if self.embedder_config is None:
-            raise ValueError("Embedder configuration is not set")
-            
-        embedder = self.embedder_config
-        if hasattr(embedder, "embed_documents") and callable(getattr(embedder, "embed_documents")):
-            embed_func = getattr(embedder, "embed_documents")
-            return embed_func([text])[0]
-        elif hasattr(embedder, "embed") and callable(getattr(embedder, "embed")):
-            embed_func = getattr(embedder, "embed")
-            return embed_func(text)
-        else:
-            raise ValueError("Invalid embedding function configuration")
-
-    def _create_default_embedding_function(self):
-        from chromadb.utils.embedding_functions.openai_embedding_function import (
-            OpenAIEmbeddingFunction,
-        )
-
-        return OpenAIEmbeddingFunction(
-            api_key=os.getenv("OPENAI_API_KEY"), model_name="text-embedding-3-small"
-        )
-
-    def _set_embedder_config(
-        self, embedder: Optional[Dict[str, Any]] = None
-    ) -> None:
-        """Set the embedding configuration for the knowledge storage.
-
-        Args:
-            embedder (Optional[Dict[str, Any]]): Configuration dictionary for the embedder.
-                If None or empty, defaults to the default embedding function.
-        """
-        self.embedder_config = (
-            EmbeddingConfigurator().configure_embedder(embedder)
-            if embedder
-            else self._create_default_embedding_function()
-        )

src/crewai/knowledge/storage/knowledge_storage.py

@@ -4,7 +4,7 @@ import io
 import logging
 import os
 import shutil
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union, cast
 
 import chromadb
 import chromadb.errors

src/crewai/lite_agent.py

@@ -1,4 +1,6 @@
 import asyncio
+import json
+import re
 import uuid
 from datetime import datetime
 from typing import Any, Callable, Dict, List, Optional, Type, Union, cast
@@ -47,6 +49,11 @@ from crewai.utilities.events.llm_events import (
     LLMCallStartedEvent,
     LLMCallType,
 )
+from crewai.utilities.events.tool_usage_events import (
+    ToolUsageErrorEvent,
+    ToolUsageFinishedEvent,
+    ToolUsageStartedEvent,
+)
 from crewai.utilities.llm_utils import create_llm
 from crewai.utilities.printer import Printer
 from crewai.utilities.token_counter_callback import TokenCalcHandler
@@ -150,10 +157,6 @@ class LiteAgent(BaseModel):
         default=[], description="Results of the tools used by the agent."
     )
 
-    # Reference of Agent
-    original_agent: Optional[BaseAgent] = Field(
-        default=None, description="Reference to the agent that created this LiteAgent"
-    )
     # Private Attributes
     _parsed_tools: List[CrewStructuredTool] = PrivateAttr(default_factory=list)
     _token_process: TokenProcess = PrivateAttr(default_factory=TokenProcess)
@@ -162,7 +165,7 @@ class LiteAgent(BaseModel):
     _messages: List[Dict[str, str]] = PrivateAttr(default_factory=list)
     _iterations: int = PrivateAttr(default=0)
     _printer: Printer = PrivateAttr(default_factory=Printer)
-    
+
     @model_validator(mode="after")
     def setup_llm(self):
         """Set up the LLM and other components after initialization."""
@@ -411,6 +414,18 @@ class LiteAgent(BaseModel):
                 formatted_answer = process_llm_response(answer, self.use_stop_words)
 
                 if isinstance(formatted_answer, AgentAction):
+                    # Emit tool usage started event
+                    crewai_event_bus.emit(
+                        self,
+                        event=ToolUsageStartedEvent(
+                            agent_key=self.key,
+                            agent_role=self.role,
+                            tool_name=formatted_answer.tool,
+                            tool_args=formatted_answer.tool_input,
+                            tool_class=formatted_answer.tool,
+                        ),
+                    )
+
                     try:
                         tool_result = execute_tool_and_check_finality(
                             agent_action=formatted_answer,
@@ -418,9 +433,34 @@ class LiteAgent(BaseModel):
                             i18n=self.i18n,
                             agent_key=self.key,
                             agent_role=self.role,
-                            agent=self.original_agent,
+                        )
+                        # Emit tool usage finished event
+                        crewai_event_bus.emit(
+                            self,
+                            event=ToolUsageFinishedEvent(
+                                agent_key=self.key,
+                                agent_role=self.role,
+                                tool_name=formatted_answer.tool,
+                                tool_args=formatted_answer.tool_input,
+                                tool_class=formatted_answer.tool,
+                                started_at=datetime.now(),
+                                finished_at=datetime.now(),
+                                output=tool_result.result,
+                            ),
                         )
                     except Exception as e:
+                        # Emit tool usage error event
+                        crewai_event_bus.emit(
+                            self,
+                            event=ToolUsageErrorEvent(
+                                agent_key=self.key,
+                                agent_role=self.role,
+                                tool_name=formatted_answer.tool,
+                                tool_args=formatted_answer.tool_input,
+                                tool_class=formatted_answer.tool,
+                                error=str(e),
+                            ),
+                        )
                         raise e
 
                     formatted_answer = handle_agent_action_core(

src/crewai/llm.py

@@ -4,12 +4,9 @@ import os
 import sys
 import threading
 import warnings
-from collections import defaultdict
 from contextlib import contextmanager
-from types import SimpleNamespace
 from typing import (
     Any,
-    DefaultDict,
     Dict,
     List,
     Literal,
@@ -21,8 +18,7 @@ from typing import (
 )
 
 from dotenv import load_dotenv
-from litellm.types.utils import ChatCompletionDeltaToolCall
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 from crewai.utilities.events.llm_events import (
     LLMCallCompletedEvent,
@@ -223,15 +219,6 @@ class StreamingChoices(TypedDict):
     finish_reason: Optional[str]
 
 
-class FunctionArgs(BaseModel):
-    name: str = ""
-    arguments: str = ""
-
-
-class AccumulatedToolArgs(BaseModel):
-    function: FunctionArgs = Field(default_factory=FunctionArgs)
-
-
 class LLM(BaseLLM):
     def __init__(
         self,
@@ -384,11 +371,6 @@ class LLM(BaseLLM):
         last_chunk = None
         chunk_count = 0
         usage_info = None
-        tool_calls = None
-
-        accumulated_tool_args: DefaultDict[int, AccumulatedToolArgs] = defaultdict(
-            AccumulatedToolArgs
-        )
 
         # --- 2) Make sure stream is set to True and include usage metrics
         params["stream"] = True
@@ -446,20 +428,6 @@ class LLM(BaseLLM):
                             if chunk_content is None and isinstance(delta, dict):
                                 # Some models might send empty content chunks
                                 chunk_content = ""
-
-                            # Enable tool calls using streaming
-                            if "tool_calls" in delta:
-                                tool_calls = delta["tool_calls"]
-
-                                if tool_calls:
-                                    result = self._handle_streaming_tool_calls(
-                                        tool_calls=tool_calls,
-                                        accumulated_tool_args=accumulated_tool_args,
-                                        available_functions=available_functions,
-                                    )
-                                    if result is not None:
-                                        chunk_content = result
-
                 except Exception as e:
                     logging.debug(f"Error extracting content from chunk: {e}")
                     logging.debug(f"Chunk format: {type(chunk)}, content: {chunk}")
@@ -474,6 +442,7 @@ class LLM(BaseLLM):
                         self,
                         event=LLMStreamChunkEvent(chunk=chunk_content),
                     )
+
             # --- 4) Fallback to non-streaming if no content received
             if not full_response.strip() and chunk_count == 0:
                 logging.warning(
@@ -532,7 +501,7 @@ class LLM(BaseLLM):
                         )
 
             # --- 6) If still empty, raise an error instead of using a default response
-            if not full_response.strip() and len(accumulated_tool_args) == 0:
+            if not full_response.strip():
                 raise Exception(
                     "No content received from streaming response. Received empty chunks or failed to extract content."
                 )
@@ -564,8 +533,8 @@ class LLM(BaseLLM):
                                 tool_calls = getattr(message, "tool_calls")
             except Exception as e:
                 logging.debug(f"Error checking for tool calls: {e}")
-            # --- 8) If no tool calls or no available functions, return the text response directly
 
+            # --- 8) If no tool calls or no available functions, return the text response directly
             if not tool_calls or not available_functions:
                 # Log token usage if available in streaming mode
                 self._handle_streaming_callbacks(callbacks, usage_info, last_chunk)
@@ -599,47 +568,6 @@ class LLM(BaseLLM):
             )
             raise Exception(f"Failed to get streaming response: {str(e)}")
 
-    def _handle_streaming_tool_calls(
-        self,
-        tool_calls: List[ChatCompletionDeltaToolCall],
-        accumulated_tool_args: DefaultDict[int, AccumulatedToolArgs],
-        available_functions: Optional[Dict[str, Any]] = None,
-    ) -> None | str:
-        for tool_call in tool_calls:
-            current_tool_accumulator = accumulated_tool_args[tool_call.index]
-
-            if tool_call.function.name:
-                current_tool_accumulator.function.name = tool_call.function.name
-
-            if tool_call.function.arguments:
-                current_tool_accumulator.function.arguments += (
-                    tool_call.function.arguments
-                )
-
-            crewai_event_bus.emit(
-                self,
-                event=LLMStreamChunkEvent(
-                    tool_call=tool_call.to_dict(),
-                    chunk=tool_call.function.arguments,
-                ),
-            )
-
-            if (
-                current_tool_accumulator.function.name
-                and current_tool_accumulator.function.arguments
-                and available_functions
-            ):
-                try:
-                    json.loads(current_tool_accumulator.function.arguments)
-
-                    return self._handle_tool_call(
-                        [current_tool_accumulator],
-                        available_functions,
-                    )
-                except json.JSONDecodeError:
-                    continue
-        return None
-
     def _handle_streaming_callbacks(
         self,
         callbacks: Optional[List[Any]],
@@ -779,6 +707,15 @@ class LLM(BaseLLM):
                     function_name, lambda: None
                 )  # Ensure fn is always a callable
                 logging.error(f"Error executing function '{function_name}': {e}")
+                crewai_event_bus.emit(
+                    self,
+                    event=ToolExecutionErrorEvent(
+                        tool_name=function_name,
+                        tool_args=function_args,
+                        tool_class=fn,
+                        error=str(e),
+                    ),
+                )
                 crewai_event_bus.emit(
                     self,
                     event=LLMCallFailedEvent(error=f"Tool execution error: {str(e)}"),

src/crewai/memory/__init__.py

@@ -2,12 +2,5 @@ from .entity.entity_memory import EntityMemory
 from .long_term.long_term_memory import LongTermMemory
 from .short_term.short_term_memory import ShortTermMemory
 from .user.user_memory import UserMemory
-from .external.external_memory import ExternalMemory
 
-__all__ = [
-    "UserMemory",
-    "EntityMemory",
-    "LongTermMemory",
-    "ShortTermMemory",
-    "ExternalMemory",
-]
+__all__ = ["UserMemory", "EntityMemory", "LongTermMemory", "ShortTermMemory"]

src/crewai/memory/contextual/contextual_memory.py

@@ -1,12 +1,6 @@
 from typing import Any, Dict, Optional
 
-from crewai.memory import (
-    EntityMemory,
-    ExternalMemory,
-    LongTermMemory,
-    ShortTermMemory,
-    UserMemory,
-)
+from crewai.memory import EntityMemory, LongTermMemory, ShortTermMemory, UserMemory
 
 
 class ContextualMemory:
@@ -17,7 +11,6 @@ class ContextualMemory:
         ltm: LongTermMemory,
         em: EntityMemory,
         um: UserMemory,
-        exm: ExternalMemory,
     ):
         if memory_config is not None:
             self.memory_provider = memory_config.get("provider")
@@ -27,7 +20,6 @@ class ContextualMemory:
         self.ltm = ltm
         self.em = em
         self.um = um
-        self.exm = exm
 
     def build_context_for_task(self, task, context) -> str:
         """
@@ -43,7 +35,6 @@ class ContextualMemory:
         context.append(self._fetch_ltm_context(task.description))
         context.append(self._fetch_stm_context(query))
         context.append(self._fetch_entity_context(query))
-        context.append(self._fetch_external_context(query))
         if self.memory_provider == "mem0":
             context.append(self._fetch_user_context(query))
         return "\n".join(filter(None, context))
@@ -53,10 +44,6 @@ class ContextualMemory:
         Fetches recent relevant insights from STM related to the task's description and expected_output,
         formatted as bullet points.
         """
-
-        if self.stm is None:
-            return ""
-
         stm_results = self.stm.search(query)
         formatted_results = "\n".join(
             [
@@ -71,10 +58,6 @@ class ContextualMemory:
         Fetches historical data or insights from LTM that are relevant to the task's description and expected_output,
         formatted as bullet points.
         """
-
-        if self.ltm is None:
-            return ""
-
         ltm_results = self.ltm.search(task, latest_n=2)
         if not ltm_results:
             return None
@@ -94,9 +77,6 @@ class ContextualMemory:
         Fetches relevant entity information from Entity Memory related to the task's description and expected_output,
         formatted as bullet points.
         """
-        if self.em is None:
-            return ""
-
         em_results = self.em.search(query)
         formatted_results = "\n".join(
             [
@@ -126,24 +106,3 @@ class ContextualMemory:
             f"- {result['memory']}" for result in user_memories
         )
         return f"User memories/preferences:\n{formatted_memories}"
-
-    def _fetch_external_context(self, query: str) -> str:
-        """
-        Fetches and formats relevant information from External Memory.
-        Args:
-            query (str): The search query to find relevant information.
-        Returns:
-            str: Formatted information as bullet points, or an empty string if none found.
-        """
-        if self.exm is None:
-            return ""
-
-        external_memories = self.exm.search(query)
-
-        if not external_memories:
-            return ""
-
-        formatted_memories = "\n".join(
-            f"- {result['memory']}" for result in external_memories
-        )
-        return f"External memories:\n{formatted_memories}"

src/crewai/memory/entity/entity_memory.py

@@ -22,9 +22,7 @@ class EntityMemory(Memory):
         else:
             memory_provider = None
 
-        if storage:
-            pass
-        elif memory_provider == "mem0":
+        if memory_provider == "mem0":
             try:
                 from crewai.memory.storage.mem0_storage import Mem0Storage
             except ImportError:
@@ -32,26 +30,17 @@ class EntityMemory(Memory):
                     "Mem0 is not installed. Please install it with `pip install mem0ai`."
                 )
             storage = Mem0Storage(type="entities", crew=crew)
-        elif memory_provider == "elasticsearch":
-            try:
-                storage = self._create_elasticsearch_storage(
+        else:
+            storage = (
+                storage
+                if storage
+                else RAGStorage(
                     type="entities",
                     allow_reset=True,
                     embedder_config=embedder_config,
                     crew=crew,
                     path=path,
                 )
-            except ImportError:
-                raise ImportError(
-                    "Elasticsearch is not installed. Please install it with `pip install elasticsearch`."
-                )
-        else:
-            storage = RAGStorage(
-                type="entities",
-                allow_reset=True,
-                embedder_config=embedder_config,
-                crew=crew,
-                path=path,
             )
 
         super().__init__(storage=storage)
@@ -70,11 +59,6 @@ class EntityMemory(Memory):
             data = f"{item.name}({item.type}): {item.description}"
         super().save(data, item.metadata)
 
-    def _create_elasticsearch_storage(self, **kwargs):
-        """Create an Elasticsearch storage instance."""
-        from crewai.memory.storage.elasticsearch_storage import ElasticsearchStorage
-        return ElasticsearchStorage(**kwargs)
-
     def reset(self) -> None:
         try:
             self.storage.reset()

src/crewai/memory/external/external_memory.py

@@ -1,61 +0,0 @@
-from typing import TYPE_CHECKING, Any, Dict, Optional
-
-from crewai.memory.external.external_memory_item import ExternalMemoryItem
-from crewai.memory.memory import Memory
-from crewai.memory.storage.interface import Storage
-
-if TYPE_CHECKING:
-    from crewai.memory.storage.mem0_storage import Mem0Storage
-
-
-class ExternalMemory(Memory):
-    def __init__(self, storage: Optional[Storage] = None, **data: Any):
-        super().__init__(storage=storage, **data)
-
-    @staticmethod
-    def _configure_mem0(crew: Any, config: Dict[str, Any]) -> "Mem0Storage":
-        from crewai.memory.storage.mem0_storage import Mem0Storage
-
-        return Mem0Storage(type="external", crew=crew, config=config)
-
-    @staticmethod
-    def external_supported_storages() -> Dict[str, Any]:
-        return {
-            "mem0": ExternalMemory._configure_mem0,
-        }
-
-    @staticmethod
-    def create_storage(crew: Any, embedder_config: Optional[Dict[str, Any]]) -> Storage:
-        if not embedder_config:
-            raise ValueError("embedder_config is required")
-
-        if "provider" not in embedder_config:
-            raise ValueError("embedder_config must include a 'provider' key")
-
-        provider = embedder_config["provider"]
-        supported_storages = ExternalMemory.external_supported_storages()
-        if provider not in supported_storages:
-            raise ValueError(f"Provider {provider} not supported")
-
-        return supported_storages[provider](crew, embedder_config.get("config", {}))
-
-    def save(
-        self,
-        value: Any,
-        metadata: Optional[Dict[str, Any]] = None,
-        agent: Optional[str] = None,
-    ) -> None:
-        """Saves a value into the external storage."""
-        item = ExternalMemoryItem(value=value, metadata=metadata, agent=agent)
-        super().save(value=item.value, metadata=item.metadata, agent=item.agent)
-
-    def reset(self) -> None:
-        self.storage.reset()
-
-    def set_crew(self, crew: Any) -> "ExternalMemory":
-        super().set_crew(crew)
-
-        if not self.storage:
-            self.storage = self.create_storage(crew, self.embedder_config)
-
-        return self

src/crewai/memory/external/external_memory_item.py

@@ -1,13 +0,0 @@
-from typing import Any, Dict, Optional
-
-
-class ExternalMemoryItem:
-    def __init__(
-        self,
-        value: Any,
-        metadata: Optional[Dict[str, Any]] = None,
-        agent: Optional[str] = None,
-    ):
-        self.value = value
-        self.metadata = metadata
-        self.agent = agent

src/crewai/memory/memory.py

@@ -9,7 +9,6 @@ class Memory(BaseModel):
     """
 
     embedder_config: Optional[Dict[str, Any]] = None
-    crew: Optional[Any] = None
 
     storage: Any
 
@@ -37,7 +36,3 @@ class Memory(BaseModel):
         return self.storage.search(
             query=query, limit=limit, score_threshold=score_threshold
         )
-
-    def set_crew(self, crew: Any) -> "Memory":
-        self.crew = crew
-        return self

src/crewai/memory/short_term/short_term_memory.py

@@ -24,9 +24,7 @@ class ShortTermMemory(Memory):
         else:
             memory_provider = None
 
-        if storage:
-            pass
-        elif memory_provider == "mem0":
+        if memory_provider == "mem0":
             try:
                 from crewai.memory.storage.mem0_storage import Mem0Storage
             except ImportError:
@@ -34,24 +32,16 @@ class ShortTermMemory(Memory):
                     "Mem0 is not installed. Please install it with `pip install mem0ai`."
                 )
             storage = Mem0Storage(type="short_term", crew=crew)
-        elif memory_provider == "elasticsearch":
-            try:
-                storage = self._create_elasticsearch_storage(
+        else:
+            storage = (
+                storage
+                if storage
+                else RAGStorage(
                     type="short_term",
                     embedder_config=embedder_config,
                     crew=crew,
                     path=path,
                 )
-            except ImportError:
-                raise ImportError(
-                    "Elasticsearch is not installed. Please install it with `pip install elasticsearch`."
-                )
-        else:
-            storage = RAGStorage(
-                type="short_term",
-                embedder_config=embedder_config,
-                crew=crew,
-                path=path,
             )
         super().__init__(storage=storage)
         self._memory_provider = memory_provider
@@ -78,11 +68,6 @@ class ShortTermMemory(Memory):
             query=query, limit=limit, score_threshold=score_threshold
         )  # type: ignore # BUG? The reference is to the parent class, but the parent class does not have this parameters
 
-    def _create_elasticsearch_storage(self, **kwargs):
-        """Create an Elasticsearch storage instance."""
-        from crewai.memory.storage.elasticsearch_storage import ElasticsearchStorage
-        return ElasticsearchStorage(**kwargs)
-
     def reset(self) -> None:
         try:
             self.storage.reset()

src/crewai/memory/storage/elasticsearch_storage.py

@@ -1,275 +0,0 @@
-import contextlib
-import io
-import logging
-import os
-import uuid
-from typing import Any, Dict, List, Optional, cast
-
-from crewai.memory.storage.base_rag_storage import BaseRAGStorage
-from crewai.utilities import EmbeddingConfigurator
-from crewai.utilities.constants import MAX_FILE_NAME_LENGTH
-from crewai.utilities.logger import Logger
-from crewai.utilities.paths import db_storage_path
-
-
-@contextlib.contextmanager
-def suppress_logging(logger_name="elasticsearch", 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 ElasticsearchStorage(BaseRAGStorage):
-    """
-    Extends BaseRAGStorage to use Elasticsearch for storing embeddings
-    and improving search efficiency.
-    """
-
-    app: Any = None
-
-    def __init__(
-        self, 
-        type: str, 
-        allow_reset: bool = True, 
-        embedder_config: Any = None, 
-        crew: Any = None, 
-        path: Optional[str] = None,
-        host: str = "localhost",
-        port: int = 9200,
-        username: Optional[str] = None,
-        password: Optional[str] = None,
-        **kwargs: Any
-    ):
-        super().__init__(type, allow_reset, embedder_config, crew)
-        agents = crew.agents if crew else []
-        agents = [self._sanitize_role(agent.role) for agent in agents]
-        agents = "_".join(agents)
-        self.agents = agents
-        self.storage_file_name = self._build_storage_file_name(type, agents)
-        
-        self.type = type
-        self.allow_reset = allow_reset
-        self.path = path
-        
-        self.host = host
-        self.port = port
-        self.username = username
-        self.password = password
-        self.index_name = f"crewai_{type}".lower()
-        self.additional_config = kwargs
-        
-        self._initialize_app()
-
-    def _sanitize_role(self, role: str) -> str:
-        """
-        Sanitizes agent roles to ensure valid directory and index names.
-        """
-        return role.replace("\n", "").replace(" ", "_").replace("/", "_")
-
-    def _build_storage_file_name(self, type: str, file_name: str) -> str:
-        """
-        Ensures file name does not exceed max allowed by OS
-        """
-        base_path = f"{db_storage_path()}/{type}"
-
-        if len(file_name) > MAX_FILE_NAME_LENGTH:
-            logging.warning(
-                f"Trimming file name from {len(file_name)} to {MAX_FILE_NAME_LENGTH} characters."
-            )
-            file_name = file_name[:MAX_FILE_NAME_LENGTH]
-
-        return f"{base_path}/{file_name}"
-
-    def _set_embedder_config(self):
-        configurator = EmbeddingConfigurator()
-        self.embedder_config = configurator.configure_embedder(self.embedder_config)
-
-    def _initialize_app(self):
-        try:
-            from elasticsearch import Elasticsearch
-            
-            self._set_embedder_config()
-            
-            es_auth = {}
-            if self.username and self.password:
-                es_auth = {"basic_auth": (self.username, self.password)}
-                
-            self.app = Elasticsearch(
-                [f"http://{self.host}:{self.port}"], 
-                **es_auth,
-                **self.additional_config
-            )
-            
-            if not self.app.indices.exists(index=self.index_name):
-                self.app.indices.create(
-                    index=self.index_name,
-                    body={
-                        "mappings": {
-                            "properties": {
-                                "text": {"type": "text"},
-                                "embedding": {
-                                    "type": "dense_vector",
-                                    "dims": 1536,  # Default for OpenAI embeddings
-                                    "index": True,
-                                    "similarity": "cosine"
-                                },
-                                "metadata": {"type": "object"}
-                            }
-                        }
-                    }
-                )
-                
-        except ImportError:
-            raise ImportError(
-                "Elasticsearch is not installed. Please install it with `pip install elasticsearch`."
-            )
-        except Exception as e:
-            Logger(verbose=True).log(
-                "error", 
-                f"Error initializing Elasticsearch: {str(e)}", 
-                "red"
-            )
-            raise Exception(f"Error initializing Elasticsearch: {str(e)}")
-
-    def save(self, value: Any, metadata: Dict[str, Any]) -> None:
-        if not hasattr(self, "app"):
-            self._initialize_app()
-            
-        try:
-            self._generate_embedding(value, metadata)
-        except Exception as e:
-            logging.error(f"Error during {self.type} save: {str(e)}")
-
-    def search(
-        self,
-        query: str,
-        limit: int = 3,
-        filter: Optional[dict] = None,
-        score_threshold: float = 0.35,
-    ) -> List[Any]:
-        if not hasattr(self, "app") or self.app is None:
-            self._initialize_app()
-
-        try:
-            embedding = self._get_embedding_for_text(query)
-            
-            search_query: Dict[str, Any] = {
-                "size": limit,
-                "query": {
-                    "script_score": {
-                        "query": {"match_all": {}},
-                        "script": {
-                            "source": "cosineSimilarity(params.query_vector, 'embedding') + 1.0",
-                            "params": {"query_vector": embedding}
-                        }
-                    }
-                }
-            }
-            
-            if filter:
-                query_obj = search_query.get("query", {})
-                if isinstance(query_obj, dict):
-                    script_score_obj = query_obj.get("script_score", {})
-                    if isinstance(script_score_obj, dict):
-                        query_part = script_score_obj.get("query", {})
-                        if isinstance(query_part, dict):
-                            for key, value in filter.items():
-                                new_query = {
-                                    "bool": {
-                                        "must": [
-                                            query_part,
-                                            {"match": {f"metadata.{key}": value}}
-                                        ]
-                                    }
-                                }
-                                if isinstance(script_score_obj, dict):
-                                    script_score_obj["query"] = new_query
-            
-            with suppress_logging():
-                if self.app is not None and hasattr(self.app, "search") and callable(getattr(self.app, "search")):
-                    search_func = getattr(self.app, "search")
-                    response = search_func(
-                        index=self.index_name,
-                        body=search_query
-                    )
-                    
-                    results = []
-                    for hit in response["hits"]["hits"]:
-                        adjusted_score = (hit["_score"] - 1.0)
-                        
-                        if adjusted_score >= score_threshold:
-                            results.append({
-                                "id": hit["_id"],
-                                "metadata": hit["_source"]["metadata"],
-                                "context": hit["_source"]["text"],
-                                "score": adjusted_score,
-                            })
-                        
-                    return results
-                else:
-                    logging.error("Elasticsearch client is not initialized")
-                    return []
-        except Exception as e:
-            logging.error(f"Error during {self.type} search: {str(e)}")
-            return []
-
-    def _get_embedding_for_text(self, text: str) -> List[float]:
-        """Get embedding for text using the configured embedder."""
-        if self.embedder_config is None:
-            raise ValueError("Embedder configuration is not set")
-            
-        embedder = self.embedder_config
-        if hasattr(embedder, "embed_documents") and callable(getattr(embedder, "embed_documents")):
-            embed_func = getattr(embedder, "embed_documents")
-            return embed_func([text])[0]
-        elif hasattr(embedder, "embed") and callable(getattr(embedder, "embed")):
-            embed_func = getattr(embedder, "embed")
-            return embed_func(text)
-        else:
-            raise ValueError("Invalid embedding function configuration")
-
-    def _generate_embedding(self, text: str, metadata: Optional[Dict[str, Any]] = None) -> Any:
-        """Generate embedding for text and save to Elasticsearch.
-        
-        This method overrides the BaseRAGStorage method to use Elasticsearch.
-        """
-        if not hasattr(self, "app") or self.app is None:
-            self._initialize_app()
-
-        embedding = self._get_embedding_for_text(text)
-        
-        doc = {
-            "text": text,
-            "embedding": embedding,
-            "metadata": metadata or {},
-        }
-        
-        if self.app is not None and hasattr(self.app, "index") and callable(getattr(self.app, "index")):
-            index_func = getattr(self.app, "index")
-            result = index_func(
-                index=self.index_name,
-                id=str(uuid.uuid4()),
-                document=doc,
-                refresh=True  # Make the document immediately available for search
-            )
-            return result
-        return None
-
-    def reset(self) -> None:
-        try:
-            if self.app is not None:
-                if self.app.indices.exists(index=self.index_name):
-                    self.app.indices.delete(index=self.index_name)
-                
-                self._initialize_app()
-        except Exception as e:
-            raise Exception(
-                f"An error occurred while resetting the {self.type} memory: {e}"
-            )

src/crewai/memory/storage/mem0_storage.py

@@ -11,20 +11,15 @@ class Mem0Storage(Storage):
     Extends Storage to handle embedding and searching across entities using Mem0.
     """
 
-    def __init__(self, type, crew=None, config=None):
+    def __init__(self, type, crew=None):
         super().__init__()
-        supported_types = ["user", "short_term", "long_term", "entities", "external"]
-        if type not in supported_types:
-            raise ValueError(
-                f"Invalid type '{type}' for Mem0Storage. Must be one of: "
-                + ", ".join(supported_types)
-            )
+
+        if type not in ["user", "short_term", "long_term", "entities"]:
+            raise ValueError("Invalid type for Mem0Storage. Must be 'user' or 'agent'.")
 
         self.memory_type = type
         self.crew = crew
-        self.config = config or {}
-        # TODO: Memory config will be removed in the future the config will be passed as a parameter
-        self.memory_config = self.config or getattr(crew, "memory_config", {}) or {}
+        self.memory_config = crew.memory_config
 
         # User ID is required for user memory type "user" since it's used as a unique identifier for the user.
         user_id = self._get_user_id()
@@ -32,7 +27,7 @@ class Mem0Storage(Storage):
             raise ValueError("User ID is required for user memory type")
 
         # API key in memory config overrides the environment variable
-        config = self._get_config()
+        config = self.memory_config.get("config", {})
         mem0_api_key = config.get("api_key") or os.getenv("MEM0_API_KEY")
         mem0_org_id = config.get("org_id")
         mem0_project_id = config.get("project_id")
@@ -48,7 +43,7 @@ class Mem0Storage(Storage):
                 self.memory = MemoryClient(api_key=mem0_api_key)
         else:
             if mem0_local_config and len(mem0_local_config):
-                self.memory = Memory.from_config(mem0_local_config)
+                self.memory = Memory.from_config(config)
             else:
                 self.memory = Memory()
 
@@ -61,34 +56,26 @@ class Mem0Storage(Storage):
     def save(self, value: Any, metadata: Dict[str, Any]) -> None:
         user_id = self._get_user_id()
         agent_name = self._get_agent_name()
-        params = None
-        if self.memory_type == "short_term":
-            params = {
-                "agent_id": agent_name,
-                "infer": False,
-                "metadata": {"type": "short_term", **metadata},
-            }
+        if self.memory_type == "user":
+            self.memory.add(value, user_id=user_id, metadata={**metadata})
+        elif self.memory_type == "short_term":
+            agent_name = self._get_agent_name()
+            self.memory.add(
+                value, agent_id=agent_name, metadata={"type": "short_term", **metadata}
+            )
         elif self.memory_type == "long_term":
-            params = {
-                "agent_id": agent_name,
-                "infer": False,
-                "metadata": {"type": "long_term", **metadata},
-            }
+            agent_name = self._get_agent_name()
+            self.memory.add(
+                value,
+                agent_id=agent_name,
+                infer=False,
+                metadata={"type": "long_term", **metadata},
+            )
         elif self.memory_type == "entities":
-            params = {
-                "agent_id": agent_name,
-                "infer": False,
-                "metadata": {"type": "entity", **metadata},
-            }
-        elif self.memory_type == "external":
-            params = {
-                "user_id": user_id,
-                "agent_id": agent_name,
-                "metadata": {"type": "external", **metadata},
-            }
-
-        if params:
-            self.memory.add(value, **params | {"output_format": "v1.1"})
+            entity_name = self._get_agent_name()
+            self.memory.add(
+                value, user_id=entity_name, metadata={"type": "entity", **metadata}
+            )
 
     def search(
         self,
@@ -97,43 +84,41 @@ class Mem0Storage(Storage):
         score_threshold: float = 0.35,
     ) -> List[Any]:
         params = {"query": query, "limit": limit}
-        if user_id := self._get_user_id():
+        if self.memory_type == "user":
+            user_id = self._get_user_id()
             params["user_id"] = user_id
-
-        agent_name = self._get_agent_name()
-        if self.memory_type == "short_term":
+        elif self.memory_type == "short_term":
+            agent_name = self._get_agent_name()
             params["agent_id"] = agent_name
             params["metadata"] = {"type": "short_term"}
         elif self.memory_type == "long_term":
+            agent_name = self._get_agent_name()
             params["agent_id"] = agent_name
             params["metadata"] = {"type": "long_term"}
         elif self.memory_type == "entities":
+            agent_name = self._get_agent_name()
             params["agent_id"] = agent_name
             params["metadata"] = {"type": "entity"}
-        elif self.memory_type == "external":
-            params["agent_id"] = agent_name
-            params["metadata"] = {"type": "external"}
 
         # Discard the filters for now since we create the filters
         # automatically when the crew is created.
         results = self.memory.search(**params)
         return [r for r in results if r["score"] >= score_threshold]
 
-    def _get_user_id(self) -> str:
-        return self._get_config().get("user_id", "")
+    def _get_user_id(self):
+        if self.memory_type == "user":
+            if hasattr(self, "memory_config") and self.memory_config is not None:
+                return self.memory_config.get("config", {}).get("user_id")
+            else:
+                return None
+        return None
 
-    def _get_agent_name(self) -> str:
-        if not self.crew:
-            return ""
-
-        agents = self.crew.agents
+    def _get_agent_name(self):
+        agents = self.crew.agents if self.crew else []
         agents = [self._sanitize_role(agent.role) for agent in agents]
         agents = "_".join(agents)
         return agents
 
-    def _get_config(self) -> Dict[str, Any]:
-        return self.config or getattr(self, "memory_config", {}).get("config", {}) or {}
-
     def reset(self):
         if self.memory:
             self.memory.reset()

src/crewai/memory/storage/storage_factory.py

@@ -1,81 +0,0 @@
-from typing import Any, Dict, Optional, Type, cast
-
-from crewai.memory.storage.base_rag_storage import BaseRAGStorage
-from crewai.memory.storage.rag_storage import RAGStorage
-from crewai.utilities.logger import Logger
-
-try:
-    from crewai.memory.storage.elasticsearch_storage import ElasticsearchStorage
-except ImportError:
-    ElasticsearchStorage = None
-
-try:
-    from crewai.memory.storage.mem0_storage import Mem0Storage
-except ImportError:
-    Mem0Storage = None
-
-
-class StorageFactory:
-    """Factory for creating storage instances based on provider type."""
-
-    @classmethod
-    def create_storage(
-        cls,
-        provider: str,
-        type: str,
-        allow_reset: bool = True,
-        embedder_config: Optional[Any] = None,
-        crew: Any = None,
-        path: Optional[str] = None,
-        **kwargs,
-    ) -> BaseRAGStorage:
-        """Create a storage instance based on the provider type.
-
-        Args:
-            provider: Type of storage provider ("chromadb", "elasticsearch", "mem0").
-            type: Type of memory storage (e.g., "short_term", "entity").
-            allow_reset: Whether to allow resetting the storage.
-            embedder_config: Configuration for the embedder.
-            crew: Crew instance.
-            path: Path to the storage.
-            **kwargs: Additional arguments.
-
-        Returns:
-            Storage instance.
-        """
-        if provider == "elasticsearch":
-            if ElasticsearchStorage is None:
-                Logger(verbose=True).log(
-                    "error",
-                    "Elasticsearch is not installed. Please install it with `pip install elasticsearch`.",
-                    "red",
-                )
-                raise ImportError(
-                    "Elasticsearch is not installed. Please install it with `pip install elasticsearch`."
-                )
-            return ElasticsearchStorage(
-                type=type,
-                allow_reset=allow_reset,
-                embedder_config=embedder_config,
-                crew=crew,
-                path=path,
-                **kwargs,
-            )
-        elif provider == "mem0":
-            if Mem0Storage is None:
-                Logger(verbose=True).log(
-                    "error",
-                    "Mem0 is not installed. Please install it with `pip install mem0ai`.",
-                    "red",
-                )
-                raise ImportError(
-                    "Mem0 is not installed. Please install it with `pip install mem0ai`."
-                )
-            return cast(BaseRAGStorage, Mem0Storage(type=type, crew=crew))
-        return RAGStorage(
-            type=type,
-            allow_reset=allow_reset,
-            embedder_config=embedder_config,
-            crew=crew,
-            path=path,
-        )

src/crewai/memory/user/user_memory.py

@@ -1,4 +1,3 @@
-import warnings
 from typing import Any, Dict, Optional
 
 from crewai.memory.memory import Memory
@@ -13,12 +12,6 @@ class UserMemory(Memory):
     """
 
     def __init__(self, crew=None):
-        warnings.warn(
-            "UserMemory is deprecated and will be removed in a future version. "
-            "Please use ExternalMemory instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
         try:
             from crewai.memory.storage.mem0_storage import Mem0Storage
         except ImportError:
@@ -55,4 +48,6 @@ class UserMemory(Memory):
         try:
             self.storage.reset()
         except Exception as e:
-            raise Exception(f"An error occurred while resetting the user memory: {e}")
+            raise Exception(
+                f"An error occurred while resetting the user memory: {e}"
+            )

src/crewai/project/crew_base.py

@@ -137,11 +137,13 @@ def CrewBase(cls: T) -> T:
                 all_functions, "is_cache_handler"
             )
             callbacks = self._filter_functions(all_functions, "is_callback")
+            agents = self._filter_functions(all_functions, "is_agent")
 
             for agent_name, agent_info in self.agents_config.items():
                 self._map_agent_variables(
                     agent_name,
                     agent_info,
+                    agents,
                     llms,
                     tool_functions,
                     cache_handler_functions,
@@ -152,6 +154,7 @@ def CrewBase(cls: T) -> T:
             self,
             agent_name: str,
             agent_info: Dict[str, Any],
+            agents: Dict[str, Callable],
             llms: Dict[str, Callable],
             tool_functions: Dict[str, Callable],
             cache_handler_functions: Dict[str, Callable],
@@ -169,10 +172,9 @@ def CrewBase(cls: T) -> T:
                 ]
 
             if function_calling_llm := agent_info.get("function_calling_llm"):
-                try:
-                    self.agents_config[agent_name]["function_calling_llm"] = llms[function_calling_llm]()
-                except KeyError:
-                    self.agents_config[agent_name]["function_calling_llm"] = function_calling_llm
+                self.agents_config[agent_name]["function_calling_llm"] = agents[
+                    function_calling_llm
+                ]()
 
             if step_callback := agent_info.get("step_callback"):
                 self.agents_config[agent_name]["step_callback"] = callbacks[

src/crewai/telemetry/constants.py

@@ -1,2 +0,0 @@
-CREWAI_TELEMETRY_BASE_URL: str = "https://telemetry.crewai.com:4319"
-CREWAI_TELEMETRY_SERVICE_NAME: str = "crewAI-telemetry"

src/crewai/telemetry/telemetry.py

@@ -9,11 +9,6 @@ from contextlib import contextmanager
 from importlib.metadata import version
 from typing import TYPE_CHECKING, Any, Optional
 
-from crewai.telemetry.constants import (
-    CREWAI_TELEMETRY_BASE_URL,
-    CREWAI_TELEMETRY_SERVICE_NAME,
-)
-
 
 @contextmanager
 def suppress_warnings():
@@ -50,22 +45,23 @@ class Telemetry:
     """
 
     def __init__(self):
-        self.ready: bool = False
-        self.trace_set: bool = False
+        self.ready = False
+        self.trace_set = False
 
-        if self._is_telemetry_disabled():
+        if os.getenv("OTEL_SDK_DISABLED", "false").lower() == "true":
             return
 
         try:
+            telemetry_endpoint = "https://telemetry.crewai.com:4319"
             self.resource = Resource(
-                attributes={SERVICE_NAME: CREWAI_TELEMETRY_SERVICE_NAME},
+                attributes={SERVICE_NAME: "crewAI-telemetry"},
             )
             with suppress_warnings():
                 self.provider = TracerProvider(resource=self.resource)
 
             processor = BatchSpanProcessor(
                 OTLPSpanExporter(
-                    endpoint=f"{CREWAI_TELEMETRY_BASE_URL}/v1/traces",
+                    endpoint=f"{telemetry_endpoint}/v1/traces",
                     timeout=30,
                 )
             )
@@ -80,13 +76,6 @@ class Telemetry:
                 raise  # Re-raise the exception to not interfere with system signals
             self.ready = False
 
-    def _is_telemetry_disabled(self) -> bool:
-        """Check if telemetry should be disabled based on environment variables."""
-        return (
-            os.getenv("OTEL_SDK_DISABLED", "false").lower() == "true"
-            or os.getenv("CREWAI_DISABLE_TELEMETRY", "false").lower() == "true"
-        )
-
     def set_tracer(self):
         if self.ready and not self.trace_set:
             try:

src/crewai/tools/base_tool.py

@@ -1,4 +1,3 @@
-import asyncio
 import warnings
 from abc import ABC, abstractmethod
 from inspect import signature
@@ -66,13 +65,7 @@ class BaseTool(BaseModel, ABC):
         **kwargs: Any,
     ) -> Any:
         print(f"Using Tool: {self.name}")
-        result = self._run(*args, **kwargs)
-
-        # If _run is async, we safely run it
-        if asyncio.iscoroutine(result):
-            return asyncio.run(result)
-
-        return result
+        return self._run(*args, **kwargs)
 
     @abstractmethod
     def _run(
@@ -251,13 +244,9 @@ def to_langchain(
     return [t.to_structured_tool() if isinstance(t, BaseTool) else t for t in tools]
 
 
-def tool(*args, result_as_answer=False):
+def tool(*args):
     """
     Decorator to create a tool from a function.
-    
-    Args:
-        *args: Positional arguments, either the function to decorate or the tool name.
-        result_as_answer: Flag to indicate if the tool result should be used as the final agent answer.
     """
 
     def _make_with_name(tool_name: str) -> Callable:
@@ -283,7 +272,6 @@ def tool(*args, result_as_answer=False):
                 description=f.__doc__,
                 func=f,
                 args_schema=args_schema,
-                result_as_answer=result_as_answer,
             )
 
         return _make_tool

src/crewai/tools/tool_usage.py

@@ -2,6 +2,7 @@ import ast
 import datetime
 import json
 import time
+from dataclasses import dataclass
 from difflib import SequenceMatcher
 from json import JSONDecodeError
 from textwrap import dedent
@@ -25,7 +26,6 @@ from crewai.utilities.events.tool_usage_events import (
     ToolSelectionErrorEvent,
     ToolUsageErrorEvent,
     ToolUsageFinishedEvent,
-    ToolUsageStartedEvent,
     ToolValidateInputErrorEvent,
 )
 
@@ -166,21 +166,6 @@ class ToolUsage:
                 if self.task:
                     self.task.increment_tools_errors()
 
-        if self.agent:
-            event_data = {
-                "agent_key": self.agent.key,
-                "agent_role": self.agent.role,
-                "tool_name": self.action.tool,
-                "tool_args": self.action.tool_input,
-                "tool_class": self.action.tool,
-                "agent": self.agent,
-            }
-
-            if self.agent.fingerprint:
-                event_data.update(self.agent.fingerprint)
-
-            crewai_event_bus.emit(self,ToolUsageStartedEvent(**event_data))
-            
         started_at = time.time()
         from_cache = False
         result = None  # type: ignore

src/crewai/utilities/agent_utils.py

@@ -16,6 +16,7 @@ from crewai.tools.base_tool import BaseTool
 from crewai.tools.structured_tool import CrewStructuredTool
 from crewai.tools.tool_types import ToolResult
 from crewai.utilities import I18N, Printer
+from crewai.utilities.events.tool_usage_events import ToolUsageStartedEvent
 from crewai.utilities.exceptions.context_window_exceeding_exception import (
     LLMContextLengthExceededException,
 )

src/crewai/utilities/converter.py

@@ -216,7 +216,7 @@ def convert_with_instructions(
 
 def get_conversion_instructions(model: Type[BaseModel], llm: Any) -> str:
     instructions = "Please convert the following text into valid JSON."
-    if llm and not isinstance(llm, str) and llm.supports_function_calling():
+    if llm.supports_function_calling():
         model_schema = PydanticSchemaParser(model=model).get_schema()
         instructions += (
             f"\n\nOutput ONLY the valid JSON and nothing else.\n\n"

src/crewai/utilities/events/llm_events.py

@@ -1,8 +1,6 @@
 from enum import Enum
 from typing import Any, Dict, List, Optional, Union
 
-from pydantic import BaseModel
-
 from crewai.utilities.events.base_events import BaseEvent
 
 
@@ -43,21 +41,8 @@ class LLMCallFailedEvent(BaseEvent):
     type: str = "llm_call_failed"
 
 
-class FunctionCall(BaseModel):
-    arguments: str
-    name: Optional[str] = None
-
-
-class ToolCall(BaseModel):
-    id: Optional[str] = None
-    function: FunctionCall
-    type: Optional[str] = None
-    index: int
-
-
 class LLMStreamChunkEvent(BaseEvent):
     """Event emitted when a streaming chunk is received"""
 
     type: str = "llm_stream_chunk"
     chunk: str
-    tool_call: Optional[ToolCall] = None

src/crewai/utilities/tool_utils.py

@@ -5,6 +5,11 @@ from crewai.security import Fingerprint
 from crewai.tools.structured_tool import CrewStructuredTool
 from crewai.tools.tool_types import ToolResult
 from crewai.tools.tool_usage import ToolUsage, ToolUsageErrorException
+from crewai.utilities.events import crewai_event_bus
+from crewai.utilities.events.tool_usage_events import (
+    ToolUsageErrorEvent,
+    ToolUsageStartedEvent,
+)
 from crewai.utilities.i18n import I18N
 
 
@@ -37,8 +42,10 @@ def execute_tool_and_check_finality(
         ToolResult containing the execution result and whether it should be treated as a final answer
     """
     try:
+        # Create tool name to tool map
         tool_name_to_tool_map = {tool.name: tool for tool in tools}
 
+        # Emit tool usage event if agent info is available
         if agent_key and agent_role and agent:
             fingerprint_context = fingerprint_context or {}
             if agent:
@@ -52,6 +59,22 @@ def execute_tool_and_check_finality(
                         except Exception as e:
                             raise ValueError(f"Failed to set fingerprint: {e}")
 
+            event_data = {
+                "agent_key": agent_key,
+                "agent_role": agent_role,
+                "tool_name": agent_action.tool,
+                "tool_args": agent_action.tool_input,
+                "tool_class": agent_action.tool,
+                "agent": agent,
+            }
+            event_data.update(fingerprint_context)
+            crewai_event_bus.emit(
+                agent,
+                event=ToolUsageStartedEvent(
+                    **event_data,
+                ),
+            )
+
         # Create tool usage instance
         tool_usage = ToolUsage(
             tools_handler=tools_handler,
@@ -87,4 +110,17 @@ def execute_tool_and_check_finality(
         return ToolResult(tool_result, False)
 
     except Exception as e:
+        # Emit error event if agent info is available
+        if agent_key and agent_role and agent:
+            crewai_event_bus.emit(
+                agent,
+                event=ToolUsageErrorEvent(
+                    agent_key=agent_key,
+                    agent_role=agent_role,
+                    tool_name=agent_action.tool,
+                    tool_args=agent_action.tool_input,
+                    tool_class=agent_action.tool,
+                    error=str(e),
+                ),
+            )
         raise e

tests/agent_test.py

@@ -10,8 +10,6 @@ from crewai import Agent, Crew, Task
 from crewai.agents.cache import CacheHandler
 from crewai.agents.crew_agent_executor import AgentFinish, CrewAgentExecutor
 from crewai.agents.parser import CrewAgentParser, OutputParserException
-from crewai.knowledge.knowledge import Knowledge
-from crewai.knowledge.knowledge_config import KnowledgeConfig
 from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
 from crewai.knowledge.source.string_knowledge_source import StringKnowledgeSource
 from crewai.llm import LLM
@@ -261,9 +259,7 @@ def test_cache_hitting():
     def handle_tool_end(source, event):
         received_events.append(event)
 
-    with (
-        patch.object(CacheHandler, "read") as read,
-    ):
+    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, you must use the tool.",
@@ -1615,78 +1611,6 @@ def test_agent_with_knowledge_sources():
         assert "red" in result.raw.lower()
 
 
-@pytest.mark.vcr(filter_headers=["authorization"])
-def test_agent_with_knowledge_sources_with_query_limit_and_score_threshold():
-    content = "Brandon's favorite color is red and he likes Mexican food."
-    string_source = StringKnowledgeSource(content=content)
-    knowledge_config = KnowledgeConfig(results_limit=10, score_threshold=0.5)
-    with patch(
-        "crewai.knowledge.storage.knowledge_storage.KnowledgeStorage"
-    ) as MockKnowledge:
-        mock_knowledge_instance = MockKnowledge.return_value
-        mock_knowledge_instance.sources = [string_source]
-        mock_knowledge_instance.query.return_value = [{"content": content}]
-        with patch.object(Knowledge, "query") as mock_knowledge_query:
-            agent = Agent(
-                role="Information Agent",
-                goal="Provide information based on knowledge sources",
-                backstory="You have access to specific knowledge sources.",
-                llm=LLM(model="gpt-4o-mini"),
-                knowledge_sources=[string_source],
-                knowledge_config=knowledge_config,
-            )
-            task = Task(
-                description="What is Brandon's favorite color?",
-                expected_output="Brandon's favorite color.",
-                agent=agent,
-            )
-            crew = Crew(agents=[agent], tasks=[task])
-            crew.kickoff()
-
-            assert agent.knowledge is not None
-            mock_knowledge_query.assert_called_once_with(
-                [task.prompt()],
-                **knowledge_config.model_dump(),
-            )
-
-
-@pytest.mark.vcr(filter_headers=["authorization"])
-def test_agent_with_knowledge_sources_with_query_limit_and_score_threshold_default():
-    content = "Brandon's favorite color is red and he likes Mexican food."
-    string_source = StringKnowledgeSource(content=content)
-    knowledge_config = KnowledgeConfig()
-    with patch(
-        "crewai.knowledge.storage.knowledge_storage.KnowledgeStorage"
-    ) as MockKnowledge:
-        mock_knowledge_instance = MockKnowledge.return_value
-        mock_knowledge_instance.sources = [string_source]
-        mock_knowledge_instance.query.return_value = [{"content": content}]
-        with patch.object(Knowledge, "query") as mock_knowledge_query:
-            string_source = StringKnowledgeSource(content=content)
-            knowledge_config = KnowledgeConfig()
-            agent = Agent(
-                role="Information Agent",
-                goal="Provide information based on knowledge sources",
-                backstory="You have access to specific knowledge sources.",
-                llm=LLM(model="gpt-4o-mini"),
-                knowledge_sources=[string_source],
-                knowledge_config=knowledge_config,
-            )
-            task = Task(
-                description="What is Brandon's favorite color?",
-                expected_output="Brandon's favorite color.",
-                agent=agent,
-            )
-            crew = Crew(agents=[agent], tasks=[task])
-            crew.kickoff()
-
-            assert agent.knowledge is not None
-            mock_knowledge_query.assert_called_once_with(
-                [task.prompt()],
-                **knowledge_config.model_dump(),
-            )
-
-
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_agent_with_knowledge_sources_extensive_role():
     content = "Brandon's favorite color is red and he likes Mexican food."

tests/agents/agent_adapters/test_base_agent_adapter.py

@@ -1,113 +0,0 @@
-from typing import Any, Dict, List, Optional
-
-import pytest
-from pydantic import BaseModel
-
-from crewai.agent import BaseAgent
-from crewai.agents.agent_adapters.base_agent_adapter import BaseAgentAdapter
-from crewai.tools import BaseTool
-from crewai.utilities.token_counter_callback import TokenProcess
-
-
-# Concrete implementation for testing
-class ConcreteAgentAdapter(BaseAgentAdapter):
-    def configure_tools(
-        self, tools: Optional[List[BaseTool]] = None, **kwargs: Any
-    ) -> None:
-        # Simple implementation for testing
-        self.tools = tools or []
-
-    def execute_task(
-        self,
-        task: Any,
-        context: Optional[str] = None,
-        tools: Optional[List[Any]] = None,
-    ) -> str:
-        # Dummy implementation needed due to BaseAgent inheritance
-        return "Task executed"
-
-    def create_agent_executor(self, tools: Optional[List[BaseTool]] = None) -> Any:
-        # Dummy implementation
-        return None
-
-    def get_delegation_tools(
-        self, tools: List[BaseTool], tool_map: Optional[Dict[str, BaseTool]]
-    ) -> List[BaseTool]:
-        # Dummy implementation
-        return []
-
-    def _parse_output(self, agent_output: Any, token_process: TokenProcess):
-        # Dummy implementation
-        pass
-
-    def get_output_converter(self, tools: Optional[List[BaseTool]] = None) -> Any:
-        # Dummy implementation
-        return None
-
-
-def test_base_agent_adapter_initialization():
-    """Test initialization of the concrete agent adapter."""
-    adapter = ConcreteAgentAdapter(
-        role="test role", goal="test goal", backstory="test backstory"
-    )
-    assert isinstance(adapter, BaseAgent)
-    assert isinstance(adapter, BaseAgentAdapter)
-    assert adapter.role == "test role"
-    assert adapter._agent_config is None
-    assert adapter.adapted_structured_output is False
-
-
-def test_base_agent_adapter_initialization_with_config():
-    """Test initialization with agent_config."""
-    config = {"model": "gpt-4"}
-    adapter = ConcreteAgentAdapter(
-        agent_config=config,
-        role="test role",
-        goal="test goal",
-        backstory="test backstory",
-    )
-    assert adapter._agent_config == config
-
-
-def test_configure_tools_method_exists():
-    """Test that configure_tools method exists and can be called."""
-    adapter = ConcreteAgentAdapter(
-        role="test role", goal="test goal", backstory="test backstory"
-    )
-    # Create dummy tools if needed, or pass None
-    tools = []
-    adapter.configure_tools(tools)
-    assert hasattr(adapter, "tools")
-    assert adapter.tools == tools
-
-
-def test_configure_structured_output_method_exists():
-    """Test that configure_structured_output method exists and can be called."""
-    adapter = ConcreteAgentAdapter(
-        role="test role", goal="test goal", backstory="test backstory"
-    )
-
-    # Define a dummy structure or pass None/Any
-    class DummyOutput(BaseModel):
-        data: str
-
-    structured_output = DummyOutput
-    adapter.configure_structured_output(structured_output)
-    # Add assertions here if configure_structured_output modifies state
-    # For now, just ensuring it runs without error is sufficient
-    pass
-
-
-def test_base_agent_adapter_inherits_base_agent():
-    """Test that BaseAgentAdapter inherits from BaseAgent."""
-    assert issubclass(BaseAgentAdapter, BaseAgent)
-
-
-class ConcreteAgentAdapterWithoutRequiredMethods(BaseAgentAdapter):
-    pass
-
-
-def test_base_agent_adapter_fails_without_required_methods():
-    """Test that BaseAgentAdapter fails without required methods."""
-    with pytest.raises(TypeError):
-        ConcreteAgentAdapterWithoutRequiredMethods()  # type: ignore

tests/agents/agent_adapters/test_base_tool_adapter.py

@@ -1,94 +0,0 @@
-from typing import Any, List
-from unittest.mock import Mock
-
-import pytest
-
-from crewai.agents.agent_adapters.base_tool_adapter import BaseToolAdapter
-from crewai.tools.base_tool import BaseTool
-
-
-class ConcreteToolAdapter(BaseToolAdapter):
-    def configure_tools(self, tools: List[BaseTool]) -> None:
-        self.converted_tools = [f"converted_{tool.name}" for tool in tools]
-
-
-@pytest.fixture
-def mock_tool_1():
-    tool = Mock(spec=BaseTool)
-    tool.name = "Mock Tool 1"
-    return tool
-
-
-@pytest.fixture
-def mock_tool_2():
-    tool = Mock(spec=BaseTool)
-    tool.name = "MockTool2"
-    return tool
-
-
-@pytest.fixture
-def tools_list(mock_tool_1, mock_tool_2):
-    return [mock_tool_1, mock_tool_2]
-
-
-def test_initialization_with_tools(tools_list):
-    adapter = ConcreteToolAdapter(tools=tools_list)
-    assert adapter.original_tools == tools_list
-    assert adapter.converted_tools == []  # Conversion happens in configure_tools
-
-
-def test_initialization_without_tools():
-    adapter = ConcreteToolAdapter()
-    assert adapter.original_tools == []
-    assert adapter.converted_tools == []
-
-
-def test_configure_tools(tools_list):
-    adapter = ConcreteToolAdapter()
-    adapter.configure_tools(tools_list)
-    assert adapter.converted_tools == ["converted_Mock Tool 1", "converted_MockTool2"]
-    assert adapter.original_tools == []  # original_tools is only set in init
-
-    adapter_with_init_tools = ConcreteToolAdapter(tools=tools_list)
-    adapter_with_init_tools.configure_tools(tools_list)
-    assert adapter_with_init_tools.converted_tools == [
-        "converted_Mock Tool 1",
-        "converted_MockTool2",
-    ]
-    assert adapter_with_init_tools.original_tools == tools_list
-
-
-def test_tools_method(tools_list):
-    adapter = ConcreteToolAdapter()
-    adapter.configure_tools(tools_list)
-    assert adapter.tools() == ["converted_Mock Tool 1", "converted_MockTool2"]
-
-
-def test_tools_method_empty():
-    adapter = ConcreteToolAdapter()
-    assert adapter.tools() == []
-
-
-def test_sanitize_tool_name_with_spaces():
-    adapter = ConcreteToolAdapter()
-    assert adapter.sanitize_tool_name("Tool With Spaces") == "Tool_With_Spaces"
-
-
-def test_sanitize_tool_name_without_spaces():
-    adapter = ConcreteToolAdapter()
-    assert adapter.sanitize_tool_name("ToolWithoutSpaces") == "ToolWithoutSpaces"
-
-
-def test_sanitize_tool_name_empty():
-    adapter = ConcreteToolAdapter()
-    assert adapter.sanitize_tool_name("") == ""
-
-
-class ConcreteToolAdapterWithoutRequiredMethods(BaseToolAdapter):
-    pass
-
-
-def test_tool_adapted_fails_without_required_methods():
-    """Test that BaseToolAdapter fails without required methods."""
-    with pytest.raises(TypeError):
-        ConcreteToolAdapterWithoutRequiredMethods()  # type: ignore

tests/agents/agent_builder/base_agent_test.py

@@ -18,6 +18,9 @@ class MockAgent(BaseAgent):
 
     def create_agent_executor(self, tools=None) -> None: ...
 
+    def _parse_tools(self, tools: List[BaseTool]) -> List[BaseTool]:
+        return []
+
     def get_delegation_tools(self, agents: List["BaseAgent"]): ...
 
     def get_output_converter(

tests/cassettes/test_agent_with_knowledge_sources_with_query_limit_and_score_threshold.yaml

@@ -1,330 +0,0 @@
-interactions:
-- request:
-    body: '{"input": ["Brandon''s favorite color is red and he likes Mexican food."],
-      "model": "text-embedding-3-small", "encoding_format": "base64"}'
-    headers:
-      accept:
-      - application/json
-      accept-encoding:
-      - gzip, deflate, zstd
-      connection:
-      - keep-alive
-      content-length:
-      - '137'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      user-agent:
-      - OpenAI/Python 1.68.2
-      x-stainless-arch:
-      - arm64
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - MacOS
-      x-stainless-package-version:
-      - 1.68.2
-      x-stainless-read-timeout:
-      - '600'
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.12.9
-    method: POST
-    uri: https://api.openai.com/v1/embeddings
-  response:
-    body:
-      string: !!binary |
-        H4sIAAAAAAAAA1SaWw+yPtfmz59Pced/yrwR2bV9zhAQ2UkRFHEymYAiOxHZtEDfvN99ovdkNicm
-        YiNpu1bXdf1W//Nff/7802V1fp/++feff17VOP3z377PHumU/vPvP//9X3/+/Pnzn7/P/29k3mb5
-        41G9i9/w34/V+5Ev//z7D/9/nvzfQf/+889JZZQeb+UOCJHjaQqtRQfv1mXUaf0OTfTuHjx+CvAU
-        CWC/KEik3pNeZScAwr5Zzkgne4Gqd6jX2+oDW3BxGx8nMkfrxaq0GM2PNaV5G6QZM0P1joRJl32W
-        BVuXtTPPo02jZhRX8gjWdj7MgDz2D+wRexhoUHsaTN9P0RfLw5itFrmbCgzCHVFOdx/wQte1qJvK
-        FxH556YeT0pqoJ0RTNhqPwiskhTe0T7qIpzrwS4arGS24D4uc6y90d4VpMq+wy7hntS8mG297p2B
-        QNrwZ5pV1p4RZ6vPEHEPDtuWVA0L/w451CylgPUZBhFvXaQWWqXwwKobdNmavrcCyvDk4aRDezby
-        2c5Hym33obtXgLKlioYGKUfZovrOBtkSu6cOQbHw6POcJoyE+vmMxtegUst+HNh2ZImhpFTNsJ4V
-        73p1XlWO8NsSscGvH7asThqCqtoe6anKt+6SsI0K91Ef0UtGS5dIB8DD3QV2vtwaybB8lksCj5K7
-        pTjWccSrU5igG+hfVOuSRl+4sPGhtJ4Qtfr4w4g0EQcaRfCgnrKxXVFD8hnSZ6jTk5PN9ax4JxU5
-        T/5MsnTwskU6ARNOHnCJYHpsoPbgFfDzsRYaLe9dPbfLoiDTls800h+6vjruXYDSGiGs3fJFXw5Z
-        2APLfh+ok3y2YDvrfQvLm3/x5fPervlV0QUUF5c33aFAzQRua0JwHeCKb5/FGITQVzsgc1KIg6vA
-        Mmo+Xg5CiY/80LSf2UqSFwdOKDHoMVyBvk6jq0DzTRTs1uUHLFui9ciAyYGq8fHOhDqzzoCpgkE9
-        Ta/q9aW/VnRO/IR6zaVjs8DvQ9Q/byvOji+YzUV7ztGHji4+b4t7LZqHuwO9+NRR9aZ0YFFWKQF8
-        oXu+5D2rgfee2RlmG3/CO+mFXbq0SgJ35cGm+JxKjEnnY6vsjlOI9+aSsPUqdSNMj3FBD3qdMHHA
-        UgCXpjj46xaeI6GBnAZtrfZJOLMKLKg6VrDCz5jaF6K6/LjWGpwt36FHS430JTwlHtrvYIL3q03d
-        JUkWDWVaEtKLvglq9sj4HiRDHtFo3yjuyGe2D/nPY8ER4xwmtq/AQtvoptF7rdiAX9jdgRtn7+Bn
-        tJEZJc2GgD4yNZz3YBjWu3ziAaFrhXenYwImk8wNpOrj/M13t+Y7wz/D3/57Lz0b2K1kHixsVceP
-        ztUy8VYyH90e/AbvXU+sGZ8aDnKhc6LWu9nVPJp3CYqztfBbYCn6DDf9CG16+VBf9VswK6seI7h7
-        nqirt5POrDOr4LC/ExoMssgmx6EzlCfv+s2fnS5e3vIM9VeX0YDfaUxs04EHhXb/4KPzJoC1ac2j
-        jeltac5xgc5gd++B3PYI22Bmw1g9KgFZx+cdGynQMv7ilz7yDuFKkP351LMfTiYsJQCpLhIpWguN
-        76FsiVd6cLRJX4LU5qEFOUQdt3OBGCfJHX7PD/x7H+9L1xThHJQYF+HiUrWYe6DvogzvTlKvM6OP
-        EijuT5i01wcF7Pg6QvgK4pZ6vlzo82dzCmBAD4zuU7MfFvypHbRLREZku91ma5+PBfjGjz8e7mbN
-        sFByKDkcInrs5Iv+oVDhoTppJTYI17LVHD4qvBBo4NB9lmyRDuYMt0bqkQWbJZteYsaBUpZNvFf7
-        Su+cVQ5gr6YI+7u3A0Sev83KJowLXyzuwGV7N5jR68Zc6iWPoB71O63gwiqEtU9sR3wq2yG0nPZE
-        ja7fuKuzmQ10PnUctriPysROHCtogQ3D+JPs3O1a1AGULo+SauHJ0XlpX8ZI350yeqCtmjFn4T0w
-        SHyDz/xqg+2xnU3UZWJP7VURXHaDlgBHg8P00NhvfTy2rgqPRM1pvKIjmPwodNDU8neq2ydTZ2O7
-        C1F5qFKKX8PFHRZvXGFV81eaBMou4wcOjzLwbk/qpxe1/uyMoEAmCc4Yl4GQrZzstsgq+Qe9D4cZ
-        LFkbJCg6NjG9Wy8pWzj/3cBY7VSaymuf0eK2jnBXmRE+bZkJlqdp+NAf6gFbh9saPQ/d7Q6siTtg
-        HG1ubDtLnA8/1fuK/TpfXVbO7gijGR7pQ3e2EVPA2qJ170v+FosWWEPf6iBRgI6dku7Z0ianM2Jl
-        scWq4R/Z9qkd2l98YU3isD7z7UuBtw4V9Hbef+pZu2wEEE/3DCdFdXDF6j7NMOmftg99uXDFME1T
-        MCX6SA/OvAGTcm4tlJ1uFoHzsdQZvxHu8BQ+eurtkiXrcuobMLzW2Tf+TCZka+8or+FpYqypDhBU
-        5eahY3a54ftLBzULDTuF0f3t4X2N7+4QGrsUifHG8We0fdXzbCoOQHjzJlwbKFk/umYDMQsqmunt
-        0RUDj2ko+/QP6ofSW19xoDVQUHHuw289YJf3MiM+vwQ+f5Xf9Xw3OwIT3eNwcu59sDruWUBjOQ/f
-        /FPd+V0FDZKlWPrG71Nf1UJvYOyh2R+rUxQxL88D0KnUoeq8sfTV3+cBME6Pid5uPnDXZBOk6Fyf
-        ZRxe02wQd6LdweOknzHu4zYj42WV0P5QddSbjzv3qydMEMutia3sHgOmk0CDnZ5gjO1HEwm9kUsg
-        7R47cu6j7bBWwVlDfsy9sNHXls5jXV+R6sYt3hdSyJZQdAo4dvGeWtHJGeYUpzEUkpzhg3UT6l5c
-        +hVAw4rxJeUfmejpQYAe7+6CdUM4ZGPt2wW4RvRBTtK2rCdD9yE8lUGK3fdJjNa++ljoKDsbsnkN
-        F53pZyeF72U806h3OnfVpwqiOx8+fbEH2F1lv65QNhUrPp6FYGChsUuQ44QG+XyWpu72qOHhmi4W
-        tqSLrI8lfOXwu/4EWcF+WPwK3OHNF2y8++UP90gq6LuCgdXyqkXisl5N+DS3D38cDjOb2LrpQYap
-        R+1XvGckOz8lKB7gGVtNyA9MLeYO1uSe/I1/sm/kM4Q0FPAh4LfR3JwXH+7ulYbNfa6yZdqPBZyK
-        k0b4Q5zrM4hUAscBB/7mUXRgtsU2hJvLcaDhV691b0uDCJ2G2lcS2YqEX/1Q93NMFi0wIuZTJYQf
-        73yhd1Tm7Lee8Fffn2G0YyR5OTMEiiz81cNzNXkWKOjJwLio9IHXmm6Gh06JCVceLPbyo9BCttTY
-        9EGHhz562zGGhnn1iOQLA1jj65BCw5NaelNnkTGzLGcknMDNp+c0ASztKgWN+mZPeLtvXbYTdx0q
-        J5Zh4/OqgNhc5xWl92tMHca9I4L7xEPcqzDopdvfwGLnxxGQ15nhOMWSPj60xoROc8uwNRhwWC9Z
-        pwFXwzufhMctYKdJilFrhyN1JbQOS+ExCV5KMaA4JUUtkkYkcHekId1J23KYPlc8Q6F+nbHpiAYT
-        /H0cgqbY7nF2/SzDeidTAcXus6exvKsznvVVBWzcaVitLu+azP2OQ3nQ3vFR35rDSuswAN/zi6bc
-        0XZnTnvwEOXrlSyXThyW4v7wIS5eDwJvAj98/VGOXpVWUvVkDBnLrZhAr4MTTQ63NXv1JTThZz8D
-        ejZOlc7sgFNgs9SCr4xwBMOK3AQw8bDHTnhQ3fmcOxVQRVvyW+cdZrNw23RQTsuQXvdvEnXCTezg
-        V/9jXyyFYU7eUwC+649x0A/Z2F6bEH52UovvrviKmGQ0AZQjJPn0W8+WROs0eNPGJ/7uV0ZO4baH
-        7MnLOEorLZtruvGgbGw0uie3sl5W89Er6fFc0KvCDpHYEHuGj6zoaWC/FzDSOMqha60ZvcX3ldEw
-        TRN48Z83ImSSP7ztfeijDzftyLwXm2hpa0GFtVFb1Lrtp3q2XC+AN5+38a1Gu2HN1spCfpC5fu1F
-        Klubq05A9zIdvFPfE2P35xIgpQptvAOew8b+Up1RoEUJWVq31L/+xwKdOjk+SIcxG7/+BT6FmMM7
-        3f/UyzbaqlAe8RG7toOG1RtTC87BpyXKc5gzej51K5DTOiTrz3+MrtlC7Xzf0MygOViFneEgTWMG
-        EU/PdqDQxyr4xruvnP2rK1YCSGDPVkbk1dOjNS83IXynuUV2TjYPrBJYgooP4b/1XAbjwB0IspIX
-        wvjrJxfjcW+g/RjI3/zeEsG1ABUqTNAeopppx5CgQx2bRA53Z33xo9SCX/9CQ6fh9NkQtg5U+qnx
-        pcVadfbYvVV4lOwtdV3dHOayuvLwr5442DAah3uoAilsYuqm2Y0xv0g4aDTWilWeXob+5yerbRHS
-        3OMXtvRjl8DoNu588P0/oVlOZyTprMWHT5jUc1xsW8QB80z3NYb6Kk2tBQzz4vmgrZuaeGNooe/+
-        4Hs7hvo69zsICkuT8eGCz7qwSS0Ic1F442P08CIWJ0n+mx/OT3iumXB8KNAk4Zna25HLuqYJKyV/
-        uRXWb29uIHxnqYg7jDmOv/p5xYHTgs/HWbB52PYubV2nAr1xCjEOoxIsFSYQds1B9cEwCvqH65Cn
-        tLkAqblbeMZW2ZxBe3R3hKvzVV/VxvLh6SjVON9fpYg8thcffuOF7le+yJazUUL4He+DMDjWq9AK
-        Ofz6bep/kBmtgfoJwM+P//QSAcPowcpUF2oNZ6zz2+nSwmePI+p847G/eKIJvzzG59zsOKzFsYOQ
-        K7dbrOW2Fq3skRH48rueujh/RYufcwJMQ2nxV0n9AJ7TLgI8vh8G9oZr/eUxZwOs9v74t77MQWMb
-        cFrhAf/4AlnDdwJrkifY9rpZnwu1smBwMix6KRxVF+JFVmFgCasv3MpXtBYPJ4Bf/uR/84P1nlZ7
-        sDrZIba//n972BYB7ByXYrtGZT13ecYB4zNp1N33VT3xaOBgkjCf2l//skRPysHPTmmpcxzLaN4e
-        hgA+5DjA9qrE7rLDyAdAgwrWpdsH9N94Adc0EPGVxRMYXwKRBN1PMVXdwIrGSpzv6PIIbGorh4e+
-        3MP1DrlPevOVIi7ZOp24EH6su4rdp+nqc7o1eoBs74AzdXPK1s/q3OGzmAm9G45c08tbXuGrkUey
-        kblRX81LoMIg2kRkMa4gm8N+nuFq+hrWw/RabzNPWxEHjDPeqWKRfeshgXypxv6WB9eMNRFvIWJ0
-        2pff2GB94EpBT7uoaGRvJDAE6NSDn5/An6TUZ/JZUmgZqkj9n59Mt0YHvTeqMW5QFTFOnnv0KE3g
-        S9JFdsku6EOIL3dINet4ZswwPsbPj1Kz6gX2V/898tsWm5F20lnwVjsISTQS5uAh+/kLkBi+hfeL
-        a4P1Jdkqsh8f8ounaO2yJYeeax+wh5ZTti2ESoDILDVqA61gLdjLCrw/1AjnXaNFQmqqFpJkofzq
-        rXMtPLJDAwf7qpNNGJVs1Squh0shSr5eTWRgnZYoP/5Hf/V9eegnBzk93JJlSSx3+3EH86/+TJxs
-        0sePw2k/v4F97TW7rDrZBuTX8UT98HgBf+P9wlcXapy2a0Q9PQhhnM0FtnxhYKstqykiUS8RepR0
-        ff6ej+jnv9WrEGWdwB9D+OODNnu9o+X1MM8wf9kVVu3rJluaUuNQuz1wVP2spfv14xU0p8ih2lfv
-        j/1pGuH7cYmw7WIXTOZ+10FWVlsif/VmZa3JqHz1IE6Q2mdTzXcK+PmPmzpfmdjbaovW07mmh1sf
-        slwB+wKi+pLjQ35p3JHgYYXvQr3R5+x8shliwwBBWkzU6U6gZkpshYB1Jv7LE8lbEO+wjo869SWv
-        05dVkRQYO+aLajei12xrEg+ixEM07tddLcZJkENjy084v6V3MJfVk4dKTxu6S/U4E19GKoDlnYXY
-        GODodibRq59/95tOWQZi9887hMcW+BsBnrKuv1Qxep42nE8bpGX0OSUdsvqT9NX7N3196dMK3jGT
-        8Y8v0vvF4+DcKcDnC/rK2NVYC9gmUYXNuW3qsTnLPuT4QvnL36gZWjkgVnHF8VDw0ZJ06Rn89OXh
-        y5/nYotm8KwH2R+Ss66z80hWeLZvnb9aj0O09pJigVbYW2TzfG/qL//t4fvVfDCWudFlfc8F4Fuv
-        /RmUj+FvfP/48zGTXH3eo0aA3SFofHFNunruPlao6PcbwCY7qpFgrQGBJ0f18cXakujzOy/uZPTp
-        MVVeTOQbKf/xJh8Yu1GfnFtC/uphR65EMCpVpaLwg2O6D8I3G7n7cIfh5xhT9cu/tk2pwb/n704o
-        5ZrlUOb++m9POIvscxpzD/C6N/scM69s9kdlhPFbcrGfjL07J+uphfkwQiIAS3HZrAQxOoXPHtuq
-        ttdZ6ZxS2NCtgs3XfaOz1H+EEE/jiUZZsNX71wOkcHFaAWP+1X39b5LA5elCbHCtNyyf10xgfUQT
-        tsL2FgkuYHf441Xu+3TNVuUSeSDMjS3+zg9M9ypa4Tk71PjohoW7dNtUhd4hWKm1nwFgr7zI4U9f
-        eN/6Roqu5cBV0yvy+vLHJXx/PAhvpMV6L6VsNHZlBcUYOfiIPM9d3pakKi+xWagfd+eBedIgKXUV
-        E+zue60WY1LeUX1fH4Trmiqa72OmAtDGM7WGjZqtvixX8DQQ++cHojZLzhWyLmSlh52oAvLVI1Ai
-        RPXnznZqwQTOGZJBOn737wAYy9UZXomI/K6Sg4wqh2sMPvsV+Eyyxay5pHsJSmEb00MPqD5yZnqH
-        h13n+gVYAp0gq+GQ8nzr2KrkOXsqr7KFocZdsEfXSm+8/XGEsekH2NIClQnNoUrhV/9hz8nL7Dt/
-        Dfn87OIo0P1sCuaUh6Of8Pi51FM04scpgYdOinE4LZa7ts1gQOsyrth5C3B4r9E5h29gyT48qaK+
-        wh0KfvoIm6P7AsupWCowjKNMjU451bM1cw388lYfda4W8T//8tO3qL40NZ3C4QzltkMkXa5DvV7e
-        xgjD7WVHrbCVo/Vz5Xl4dYMdPnz546/fBNVrfiLsNDZsLTTY/+XBzlu418365DyABK32pQDPOuOC
-        HUGPdRWwffOBvn75E7D3fuRvP2TOft+V3/ltPOOdvrinZw7H10elKh7e+qwr8vyXJ+jLuxx+fAea
-        B9X20bc/Jy7r0wT1W+KoSUI4rHC3DWBQrTr2PmQEM51LE3KPgFDHPmn1ll7VCpW9EhDu64f7Je16
-        CPJDSv/y09/+QXIa8U14V+53fh3gdq5B/Uxn2boeNPJ3v3+8aL7HjgbsVvH9zVqGNVPNWkWFC3yM
-        maeDWZ3SBB57y8YPN1RdsT4ad3iuY5kweZ3YlHnajMjj8PDrxlwZKVgWKN/8JLydsmGcH64FvvyG
-        2l7yqIXJPDXw16+5uJ445C03E7Sl1egPYVHojNJGQy3sK7LVYkVfvL0yg/FWX+h+cT9gDo6z+ePZ
-        1PsQD/A7fbgrWtH09FLWjT7LmRKD24frCT9fB33clpICnVug4PjC37J5rG0Cw3MXUHVBU0buZKqg
-        9pAbIn/95dZpUAKNIvz2x6gwEJl/8Art04akzwyB1VkOFij8JvKRKZbRXDMmwFLv9vj2kMdo2Vyu
-        IXwKZw5rEoEDO5eage7lOyVojsmwGn53/ulzwmXRC3Q/fbbi7o3d8fqu57MUWCiWGxMb57cyrPHE
-        J3Cjdi+q7kUjEz+N3/x4Az7qzjZjiHox9Iz3RL/nq1v20tGAuXUx8SGWnJpwsttA8VE1VK0uh0E0
-        9WsFke0fiJArn+jbLwgB7qwdVvFwcLfpLr//rV93NfV0QZ96CF3zEGMHZCoQxtkq4MtZL1g7GLo7
-        f/UUcJos80EkGy7jnrWKmizkCbt4G7AU94uHCpBSAvNyD2axGTiYB82dgAFag6iatQY3jZZh/Cgs
-        9u0H8gicu+2X56g1PxmbHF6r4ogvQjOBbhaDFZqmusEnutHB+uuH3o2Vo4ar9+58wKqCEsOzsMtX
-        jM03q+pQrfYMHxVniZaW0zuknfPNr75m7CxGBrSLM4+vn2pwl3Qrj8BiRYKdahrc6ZhgCwqaUmNL
-        /zRg+PYf//qLxxBw0fzrXzqiUdCQShyjXz+tpM6QUe/L9+kkXToI1nuGL1qc6uu9VgVk1G6HHRO/
-        f/mz/vgNdpX247L+eWrR1WogVpOyAV9+3EKBozw2/L0BmKy+O0iiTsJJHL0yui0YD6XLsyTAdh71
-        Mj9mH/7zuxXwX//68+d//G4YtN0jf30vBkz5Mv3H/7kq8B/if4xt+nr9vYZAxrTI//n3/76B8M9n
-        6NrP9D+nrsnf4z///rMV/t41+GfqpvT1/z7/1/dV//Wv/wUAAP//AwBcfFVx4CAAAA==
-    headers:
-      CF-RAY:
-      - 931fcf607c16eb34-SJC
-      Connection:
-      - keep-alive
-      Content-Encoding:
-      - gzip
-      Content-Type:
-      - application/json
-      Date:
-      - Thu, 17 Apr 2025 23:47:53 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - __cf_bm=CncSMPCav.9EJL3emmM0sTqugx5GN6_Oy8JPFBssVho-1744933673-1.0.1.1-Q1XMvHbQdrfEWkkCYeeNHwFdZ1NpjAGJ_0jOUYIk_APelFe7nCanjW_xlOj12b3JQql9.iWQDiHvCeYJDTWkdxnNiMQOEiFMYHX5YZXUuJs;
-        path=/; expires=Fri, 18-Apr-25 00:17:53 GMT; domain=.api.openai.com; HttpOnly;
-        Secure; SameSite=None
-      - _cfuvid=unfPTYCpF5COtm5PuZDuaJqlhefP0iibfjsXHc9lKq0-1744933673515-0.0.1.1-604800000;
-        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - nosniff
-      access-control-allow-origin:
-      - '*'
-      access-control-expose-headers:
-      - X-Request-ID
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-model:
-      - text-embedding-3-small
-      openai-organization:
-      - crewai-iuxna1
-      openai-processing-ms:
-      - '75'
-      openai-version:
-      - '2020-10-01'
-      strict-transport-security:
-      - max-age=31536000; includeSubDomains; preload
-      via:
-      - envoy-router-8687b6cbdb-4qpmr
-      x-envoy-upstream-service-time:
-      - '46'
-      x-ratelimit-limit-requests:
-      - '10000'
-      x-ratelimit-limit-tokens:
-      - '10000000'
-      x-ratelimit-remaining-requests:
-      - '9999'
-      x-ratelimit-remaining-tokens:
-      - '9999986'
-      x-ratelimit-reset-requests:
-      - 6ms
-      x-ratelimit-reset-tokens:
-      - 0s
-      x-request-id:
-      - req_b8c884a7fe2bd4732903ecbdc632576d
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages": [{"role": "system", "content": "You are Information Agent.
-      You have access to specific knowledge sources.\nYour personal goal is: Provide
-      information based on knowledge sources\nTo give my best complete final answer
-      to the task respond using the exact following format:\n\nThought: I now can
-      give a great answer\nFinal Answer: Your 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!"}, {"role": "user", "content": "\nCurrent Task:
-      What is Brandon''s favorite color?\n\nThis is the expected criteria for your
-      final answer: Brandon''s favorite color.\nyou 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:"}], "model": "gpt-4o-mini", "stop": ["\nObservation:"]}'
-    headers:
-      accept:
-      - application/json
-      accept-encoding:
-      - gzip, deflate, zstd
-      connection:
-      - keep-alive
-      content-length:
-      - '926'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      user-agent:
-      - OpenAI/Python 1.68.2
-      x-stainless-arch:
-      - arm64
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - MacOS
-      x-stainless-package-version:
-      - 1.68.2
-      x-stainless-raw-response:
-      - 'true'
-      x-stainless-read-timeout:
-      - '600.0'
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.12.9
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: !!binary |
-        H4sIAAAAAAAAAwAAAP//jJNNi9swEIbv+RWDLr0ki/NBvm5NYUsplFK29NAuZiKNnWlkjVaSk02X
-        /PdiJxtn2y30YrCeecfvvCM/9QAUG7UEpTeYdOXtYPXp7vbLw7evm4ePmObvt/jrsVgVn9/5dbhj
-        1W8Usv5JOj2rbrRU3lJicSesA2GiputwNpksxuPpbNyCSgzZRlb6NJjIoGLHg1E2mgyy2WA4P6s3
-        wpqiWsL3HgDAU/tsfDpDj2oJWf/5pKIYsSS1vBQBqCC2OVEYI8eELql+B7W4RK61/gGc7EGjg5J3
-        BAhlYxvQxT0FgB/ulh1aeNu+L2EV0BlxbyIUuJPAiUCLlQAcwUkCX68ta3sAI7quyCUywA72bMge
-        AHfIFteWYOtkb8mUBFHqoCneXPsLVNQRm4xcbe0VQOckYZNxm8z9mRwvWVgpfZB1/EOqCnYcN3kg
-        jOKauWMSr1p67AHct5nXL2JUPkjlU55kS+3nhtP5qZ/qVt3R0fQMkyS0V6rFpP9Kv9xQQrbxamtK
-        o96Q6aTdirE2LFegdzX1325e632anF35P+07oDX5RCb3gQzrlxN3ZYGaP+FfZZeUW8MqUtixpjwx
-        hWYThgqs7el+qniIiaq8YFdS8IFPl7TweTZejOajUbbIVO/Y+w0AAP//AwA4a1/QsgMAAA==
-    headers:
-      CF-RAY:
-      - 931fcf649bdbed40-SJC
-      Connection:
-      - keep-alive
-      Content-Encoding:
-      - gzip
-      Content-Type:
-      - application/json
-      Date:
-      - Thu, 17 Apr 2025 23:47:54 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - __cf_bm=8vySwO0xqpm0u93_1_rXQwTeEIWa2ei3_CD5sAdoo3o-1744933674-1.0.1.1-iqZDpH5poOUp4Rcnhfrb0N2Z0c2662RBiPEcx_gefNW.m3tBA3qyFa8tmFv7PitH8u9vyYK7jxUwy4lPiSi830QWNbTMgCMTbrJ7iaUV7hY;
-        path=/; expires=Fri, 18-Apr-25 00:17:54 GMT; domain=.api.openai.com; HttpOnly;
-        Secure; SameSite=None
-      - _cfuvid=IXAyT8eWpFERM53ngcYNmaqhocfGbOHWSoe7SFNdoGI-1744933674288-0.0.1.1-604800000;
-        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - nosniff
-      access-control-expose-headers:
-      - X-Request-ID
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - crewai-iuxna1
-      openai-processing-ms:
-      - '489'
-      openai-version:
-      - '2020-10-01'
-      strict-transport-security:
-      - max-age=31536000; includeSubDomains; preload
-      x-ratelimit-limit-requests:
-      - '30000'
-      x-ratelimit-limit-tokens:
-      - '150000000'
-      x-ratelimit-remaining-requests:
-      - '29999'
-      x-ratelimit-remaining-tokens:
-      - '149999801'
-      x-ratelimit-reset-requests:
-      - 2ms
-      x-ratelimit-reset-tokens:
-      - 0s
-      x-request-id:
-      - req_151f9d0b786f2022f249ee20ea108b43
-    status:
-      code: 200
-      message: OK
-version: 1

tests/cassettes/test_agent_with_knowledge_sources_with_query_limit_and_score_threshold_default.yaml

@@ -1,330 +0,0 @@
-interactions:
-- request:
-    body: '{"input": ["Brandon''s favorite color is red and he likes Mexican food."],
-      "model": "text-embedding-3-small", "encoding_format": "base64"}'
-    headers:
-      accept:
-      - application/json
-      accept-encoding:
-      - gzip, deflate, zstd
-      connection:
-      - keep-alive
-      content-length:
-      - '137'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      user-agent:
-      - OpenAI/Python 1.68.2
-      x-stainless-arch:
-      - arm64
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - MacOS
-      x-stainless-package-version:
-      - 1.68.2
-      x-stainless-read-timeout:
-      - '600'
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.12.9
-    method: POST
-    uri: https://api.openai.com/v1/embeddings
-  response:
-    body:
-      string: !!binary |
-        H4sIAAAAAAAAA1SaWw+yPtfmz59Pced/yrwR2bV9zhAQ2UkRFHEymYAiOxHZtEDfvN99ovdkNicm
-        YiNpu1bXdf1W//Nff/7802V1fp/++feff17VOP3z377PHumU/vPvP//9X3/+/Pnzn7/P/29k3mb5
-        41G9i9/w34/V+5Ev//z7D/9/nvzfQf/+889JZZQeb+UOCJHjaQqtRQfv1mXUaf0OTfTuHjx+CvAU
-        CWC/KEik3pNeZScAwr5Zzkgne4Gqd6jX2+oDW3BxGx8nMkfrxaq0GM2PNaV5G6QZM0P1joRJl32W
-        BVuXtTPPo02jZhRX8gjWdj7MgDz2D+wRexhoUHsaTN9P0RfLw5itFrmbCgzCHVFOdx/wQte1qJvK
-        FxH556YeT0pqoJ0RTNhqPwiskhTe0T7qIpzrwS4arGS24D4uc6y90d4VpMq+wy7hntS8mG297p2B
-        QNrwZ5pV1p4RZ6vPEHEPDtuWVA0L/w451CylgPUZBhFvXaQWWqXwwKobdNmavrcCyvDk4aRDezby
-        2c5Hym33obtXgLKlioYGKUfZovrOBtkSu6cOQbHw6POcJoyE+vmMxtegUst+HNh2ZImhpFTNsJ4V
-        73p1XlWO8NsSscGvH7asThqCqtoe6anKt+6SsI0K91Ef0UtGS5dIB8DD3QV2vtwaybB8lksCj5K7
-        pTjWccSrU5igG+hfVOuSRl+4sPGhtJ4Qtfr4w4g0EQcaRfCgnrKxXVFD8hnSZ6jTk5PN9ax4JxU5
-        T/5MsnTwskU6ARNOHnCJYHpsoPbgFfDzsRYaLe9dPbfLoiDTls800h+6vjruXYDSGiGs3fJFXw5Z
-        2APLfh+ok3y2YDvrfQvLm3/x5fPervlV0QUUF5c33aFAzQRua0JwHeCKb5/FGITQVzsgc1KIg6vA
-        Mmo+Xg5CiY/80LSf2UqSFwdOKDHoMVyBvk6jq0DzTRTs1uUHLFui9ciAyYGq8fHOhDqzzoCpgkE9
-        Ta/q9aW/VnRO/IR6zaVjs8DvQ9Q/byvOji+YzUV7ztGHji4+b4t7LZqHuwO9+NRR9aZ0YFFWKQF8
-        oXu+5D2rgfee2RlmG3/CO+mFXbq0SgJ35cGm+JxKjEnnY6vsjlOI9+aSsPUqdSNMj3FBD3qdMHHA
-        UgCXpjj46xaeI6GBnAZtrfZJOLMKLKg6VrDCz5jaF6K6/LjWGpwt36FHS430JTwlHtrvYIL3q03d
-        JUkWDWVaEtKLvglq9sj4HiRDHtFo3yjuyGe2D/nPY8ER4xwmtq/AQtvoptF7rdiAX9jdgRtn7+Bn
-        tJEZJc2GgD4yNZz3YBjWu3ziAaFrhXenYwImk8wNpOrj/M13t+Y7wz/D3/57Lz0b2K1kHixsVceP
-        ztUy8VYyH90e/AbvXU+sGZ8aDnKhc6LWu9nVPJp3CYqztfBbYCn6DDf9CG16+VBf9VswK6seI7h7
-        nqirt5POrDOr4LC/ExoMssgmx6EzlCfv+s2fnS5e3vIM9VeX0YDfaUxs04EHhXb/4KPzJoC1ac2j
-        jeltac5xgc5gd++B3PYI22Bmw1g9KgFZx+cdGynQMv7ilz7yDuFKkP351LMfTiYsJQCpLhIpWguN
-        76FsiVd6cLRJX4LU5qEFOUQdt3OBGCfJHX7PD/x7H+9L1xThHJQYF+HiUrWYe6DvogzvTlKvM6OP
-        EijuT5i01wcF7Pg6QvgK4pZ6vlzo82dzCmBAD4zuU7MfFvypHbRLREZku91ma5+PBfjGjz8e7mbN
-        sFByKDkcInrs5Iv+oVDhoTppJTYI17LVHD4qvBBo4NB9lmyRDuYMt0bqkQWbJZteYsaBUpZNvFf7
-        Su+cVQ5gr6YI+7u3A0Sev83KJowLXyzuwGV7N5jR68Zc6iWPoB71O63gwiqEtU9sR3wq2yG0nPZE
-        ja7fuKuzmQ10PnUctriPysROHCtogQ3D+JPs3O1a1AGULo+SauHJ0XlpX8ZI350yeqCtmjFn4T0w
-        SHyDz/xqg+2xnU3UZWJP7VURXHaDlgBHg8P00NhvfTy2rgqPRM1pvKIjmPwodNDU8neq2ydTZ2O7
-        C1F5qFKKX8PFHRZvXGFV81eaBMou4wcOjzLwbk/qpxe1/uyMoEAmCc4Yl4GQrZzstsgq+Qe9D4cZ
-        LFkbJCg6NjG9Wy8pWzj/3cBY7VSaymuf0eK2jnBXmRE+bZkJlqdp+NAf6gFbh9saPQ/d7Q6siTtg
-        HG1ubDtLnA8/1fuK/TpfXVbO7gijGR7pQ3e2EVPA2qJ170v+FosWWEPf6iBRgI6dku7Z0ianM2Jl
-        scWq4R/Z9qkd2l98YU3isD7z7UuBtw4V9Hbef+pZu2wEEE/3DCdFdXDF6j7NMOmftg99uXDFME1T
-        MCX6SA/OvAGTcm4tlJ1uFoHzsdQZvxHu8BQ+eurtkiXrcuobMLzW2Tf+TCZka+8or+FpYqypDhBU
-        5eahY3a54ftLBzULDTuF0f3t4X2N7+4QGrsUifHG8We0fdXzbCoOQHjzJlwbKFk/umYDMQsqmunt
-        0RUDj2ko+/QP6ofSW19xoDVQUHHuw289YJf3MiM+vwQ+f5Xf9Xw3OwIT3eNwcu59sDruWUBjOQ/f
-        /FPd+V0FDZKlWPrG71Nf1UJvYOyh2R+rUxQxL88D0KnUoeq8sfTV3+cBME6Pid5uPnDXZBOk6Fyf
-        ZRxe02wQd6LdweOknzHu4zYj42WV0P5QddSbjzv3qydMEMutia3sHgOmk0CDnZ5gjO1HEwm9kUsg
-        7R47cu6j7bBWwVlDfsy9sNHXls5jXV+R6sYt3hdSyJZQdAo4dvGeWtHJGeYUpzEUkpzhg3UT6l5c
-        +hVAw4rxJeUfmejpQYAe7+6CdUM4ZGPt2wW4RvRBTtK2rCdD9yE8lUGK3fdJjNa++ljoKDsbsnkN
-        F53pZyeF72U806h3OnfVpwqiOx8+fbEH2F1lv65QNhUrPp6FYGChsUuQ44QG+XyWpu72qOHhmi4W
-        tqSLrI8lfOXwu/4EWcF+WPwK3OHNF2y8++UP90gq6LuCgdXyqkXisl5N+DS3D38cDjOb2LrpQYap
-        R+1XvGckOz8lKB7gGVtNyA9MLeYO1uSe/I1/sm/kM4Q0FPAh4LfR3JwXH+7ulYbNfa6yZdqPBZyK
-        k0b4Q5zrM4hUAscBB/7mUXRgtsU2hJvLcaDhV691b0uDCJ2G2lcS2YqEX/1Q93NMFi0wIuZTJYQf
-        73yhd1Tm7Lee8Fffn2G0YyR5OTMEiiz81cNzNXkWKOjJwLio9IHXmm6Gh06JCVceLPbyo9BCttTY
-        9EGHhz562zGGhnn1iOQLA1jj65BCw5NaelNnkTGzLGcknMDNp+c0ASztKgWN+mZPeLtvXbYTdx0q
-        J5Zh4/OqgNhc5xWl92tMHca9I4L7xEPcqzDopdvfwGLnxxGQ15nhOMWSPj60xoROc8uwNRhwWC9Z
-        pwFXwzufhMctYKdJilFrhyN1JbQOS+ExCV5KMaA4JUUtkkYkcHekId1J23KYPlc8Q6F+nbHpiAYT
-        /H0cgqbY7nF2/SzDeidTAcXus6exvKsznvVVBWzcaVitLu+azP2OQ3nQ3vFR35rDSuswAN/zi6bc
-        0XZnTnvwEOXrlSyXThyW4v7wIS5eDwJvAj98/VGOXpVWUvVkDBnLrZhAr4MTTQ63NXv1JTThZz8D
-        ejZOlc7sgFNgs9SCr4xwBMOK3AQw8bDHTnhQ3fmcOxVQRVvyW+cdZrNw23RQTsuQXvdvEnXCTezg
-        V/9jXyyFYU7eUwC+649x0A/Z2F6bEH52UovvrviKmGQ0AZQjJPn0W8+WROs0eNPGJ/7uV0ZO4baH
-        7MnLOEorLZtruvGgbGw0uie3sl5W89Er6fFc0KvCDpHYEHuGj6zoaWC/FzDSOMqha60ZvcX3ldEw
-        TRN48Z83ImSSP7ztfeijDzftyLwXm2hpa0GFtVFb1Lrtp3q2XC+AN5+38a1Gu2HN1spCfpC5fu1F
-        Klubq05A9zIdvFPfE2P35xIgpQptvAOew8b+Up1RoEUJWVq31L/+xwKdOjk+SIcxG7/+BT6FmMM7
-        3f/UyzbaqlAe8RG7toOG1RtTC87BpyXKc5gzej51K5DTOiTrz3+MrtlC7Xzf0MygOViFneEgTWMG
-        EU/PdqDQxyr4xruvnP2rK1YCSGDPVkbk1dOjNS83IXynuUV2TjYPrBJYgooP4b/1XAbjwB0IspIX
-        wvjrJxfjcW+g/RjI3/zeEsG1ABUqTNAeopppx5CgQx2bRA53Z33xo9SCX/9CQ6fh9NkQtg5U+qnx
-        pcVadfbYvVV4lOwtdV3dHOayuvLwr5442DAah3uoAilsYuqm2Y0xv0g4aDTWilWeXob+5yerbRHS
-        3OMXtvRjl8DoNu588P0/oVlOZyTprMWHT5jUc1xsW8QB80z3NYb6Kk2tBQzz4vmgrZuaeGNooe/+
-        4Hs7hvo69zsICkuT8eGCz7qwSS0Ic1F442P08CIWJ0n+mx/OT3iumXB8KNAk4Zna25HLuqYJKyV/
-        uRXWb29uIHxnqYg7jDmOv/p5xYHTgs/HWbB52PYubV2nAr1xCjEOoxIsFSYQds1B9cEwCvqH65Cn
-        tLkAqblbeMZW2ZxBe3R3hKvzVV/VxvLh6SjVON9fpYg8thcffuOF7le+yJazUUL4He+DMDjWq9AK
-        Ofz6bep/kBmtgfoJwM+P//QSAcPowcpUF2oNZ6zz2+nSwmePI+p847G/eKIJvzzG59zsOKzFsYOQ
-        K7dbrOW2Fq3skRH48rueujh/RYufcwJMQ2nxV0n9AJ7TLgI8vh8G9oZr/eUxZwOs9v74t77MQWMb
-        cFrhAf/4AlnDdwJrkifY9rpZnwu1smBwMix6KRxVF+JFVmFgCasv3MpXtBYPJ4Bf/uR/84P1nlZ7
-        sDrZIba//n972BYB7ByXYrtGZT13ecYB4zNp1N33VT3xaOBgkjCf2l//skRPysHPTmmpcxzLaN4e
-        hgA+5DjA9qrE7rLDyAdAgwrWpdsH9N94Adc0EPGVxRMYXwKRBN1PMVXdwIrGSpzv6PIIbGorh4e+
-        3MP1DrlPevOVIi7ZOp24EH6su4rdp+nqc7o1eoBs74AzdXPK1s/q3OGzmAm9G45c08tbXuGrkUey
-        kblRX81LoMIg2kRkMa4gm8N+nuFq+hrWw/RabzNPWxEHjDPeqWKRfeshgXypxv6WB9eMNRFvIWJ0
-        2pff2GB94EpBT7uoaGRvJDAE6NSDn5/An6TUZ/JZUmgZqkj9n59Mt0YHvTeqMW5QFTFOnnv0KE3g
-        S9JFdsku6EOIL3dINet4ZswwPsbPj1Kz6gX2V/898tsWm5F20lnwVjsISTQS5uAh+/kLkBi+hfeL
-        a4P1Jdkqsh8f8ounaO2yJYeeax+wh5ZTti2ESoDILDVqA61gLdjLCrw/1AjnXaNFQmqqFpJkofzq
-        rXMtPLJDAwf7qpNNGJVs1Squh0shSr5eTWRgnZYoP/5Hf/V9eegnBzk93JJlSSx3+3EH86/+TJxs
-        0sePw2k/v4F97TW7rDrZBuTX8UT98HgBf+P9wlcXapy2a0Q9PQhhnM0FtnxhYKstqykiUS8RepR0
-        ff6ej+jnv9WrEGWdwB9D+OODNnu9o+X1MM8wf9kVVu3rJluaUuNQuz1wVP2spfv14xU0p8ih2lfv
-        j/1pGuH7cYmw7WIXTOZ+10FWVlsif/VmZa3JqHz1IE6Q2mdTzXcK+PmPmzpfmdjbaovW07mmh1sf
-        slwB+wKi+pLjQ35p3JHgYYXvQr3R5+x8shliwwBBWkzU6U6gZkpshYB1Jv7LE8lbEO+wjo869SWv
-        05dVkRQYO+aLajei12xrEg+ixEM07tddLcZJkENjy084v6V3MJfVk4dKTxu6S/U4E19GKoDlnYXY
-        GODodibRq59/95tOWQZi9887hMcW+BsBnrKuv1Qxep42nE8bpGX0OSUdsvqT9NX7N3196dMK3jGT
-        8Y8v0vvF4+DcKcDnC/rK2NVYC9gmUYXNuW3qsTnLPuT4QvnL36gZWjkgVnHF8VDw0ZJ06Rn89OXh
-        y5/nYotm8KwH2R+Ss66z80hWeLZvnb9aj0O09pJigVbYW2TzfG/qL//t4fvVfDCWudFlfc8F4Fuv
-        /RmUj+FvfP/48zGTXH3eo0aA3SFofHFNunruPlao6PcbwCY7qpFgrQGBJ0f18cXakujzOy/uZPTp
-        MVVeTOQbKf/xJh8Yu1GfnFtC/uphR65EMCpVpaLwg2O6D8I3G7n7cIfh5xhT9cu/tk2pwb/n704o
-        5ZrlUOb++m9POIvscxpzD/C6N/scM69s9kdlhPFbcrGfjL07J+uphfkwQiIAS3HZrAQxOoXPHtuq
-        ttdZ6ZxS2NCtgs3XfaOz1H+EEE/jiUZZsNX71wOkcHFaAWP+1X39b5LA5elCbHCtNyyf10xgfUQT
-        tsL2FgkuYHf441Xu+3TNVuUSeSDMjS3+zg9M9ypa4Tk71PjohoW7dNtUhd4hWKm1nwFgr7zI4U9f
-        eN/6Roqu5cBV0yvy+vLHJXx/PAhvpMV6L6VsNHZlBcUYOfiIPM9d3pakKi+xWagfd+eBedIgKXUV
-        E+zue60WY1LeUX1fH4Trmiqa72OmAtDGM7WGjZqtvixX8DQQ++cHojZLzhWyLmSlh52oAvLVI1Ai
-        RPXnznZqwQTOGZJBOn737wAYy9UZXomI/K6Sg4wqh2sMPvsV+Eyyxay5pHsJSmEb00MPqD5yZnqH
-        h13n+gVYAp0gq+GQ8nzr2KrkOXsqr7KFocZdsEfXSm+8/XGEsekH2NIClQnNoUrhV/9hz8nL7Dt/
-        Dfn87OIo0P1sCuaUh6Of8Pi51FM04scpgYdOinE4LZa7ts1gQOsyrth5C3B4r9E5h29gyT48qaK+
-        wh0KfvoIm6P7AsupWCowjKNMjU451bM1cw388lYfda4W8T//8tO3qL40NZ3C4QzltkMkXa5DvV7e
-        xgjD7WVHrbCVo/Vz5Xl4dYMdPnz546/fBNVrfiLsNDZsLTTY/+XBzlu418365DyABK32pQDPOuOC
-        HUGPdRWwffOBvn75E7D3fuRvP2TOft+V3/ltPOOdvrinZw7H10elKh7e+qwr8vyXJ+jLuxx+fAea
-        B9X20bc/Jy7r0wT1W+KoSUI4rHC3DWBQrTr2PmQEM51LE3KPgFDHPmn1ll7VCpW9EhDu64f7Je16
-        CPJDSv/y09/+QXIa8U14V+53fh3gdq5B/Uxn2boeNPJ3v3+8aL7HjgbsVvH9zVqGNVPNWkWFC3yM
-        maeDWZ3SBB57y8YPN1RdsT4ad3iuY5kweZ3YlHnajMjj8PDrxlwZKVgWKN/8JLydsmGcH64FvvyG
-        2l7yqIXJPDXw16+5uJ445C03E7Sl1egPYVHojNJGQy3sK7LVYkVfvL0yg/FWX+h+cT9gDo6z+ePZ
-        1PsQD/A7fbgrWtH09FLWjT7LmRKD24frCT9fB33clpICnVug4PjC37J5rG0Cw3MXUHVBU0buZKqg
-        9pAbIn/95dZpUAKNIvz2x6gwEJl/8Art04akzwyB1VkOFij8JvKRKZbRXDMmwFLv9vj2kMdo2Vyu
-        IXwKZw5rEoEDO5eage7lOyVojsmwGn53/ulzwmXRC3Q/fbbi7o3d8fqu57MUWCiWGxMb57cyrPHE
-        J3Cjdi+q7kUjEz+N3/x4Az7qzjZjiHox9Iz3RL/nq1v20tGAuXUx8SGWnJpwsttA8VE1VK0uh0E0
-        9WsFke0fiJArn+jbLwgB7qwdVvFwcLfpLr//rV93NfV0QZ96CF3zEGMHZCoQxtkq4MtZL1g7GLo7
-        f/UUcJos80EkGy7jnrWKmizkCbt4G7AU94uHCpBSAvNyD2axGTiYB82dgAFag6iatQY3jZZh/Cgs
-        9u0H8gicu+2X56g1PxmbHF6r4ogvQjOBbhaDFZqmusEnutHB+uuH3o2Vo4ar9+58wKqCEsOzsMtX
-        jM03q+pQrfYMHxVniZaW0zuknfPNr75m7CxGBrSLM4+vn2pwl3Qrj8BiRYKdahrc6ZhgCwqaUmNL
-        /zRg+PYf//qLxxBw0fzrXzqiUdCQShyjXz+tpM6QUe/L9+kkXToI1nuGL1qc6uu9VgVk1G6HHRO/
-        f/mz/vgNdpX247L+eWrR1WogVpOyAV9+3EKBozw2/L0BmKy+O0iiTsJJHL0yui0YD6XLsyTAdh71
-        Mj9mH/7zuxXwX//68+d//G4YtN0jf30vBkz5Mv3H/7kq8B/if4xt+nr9vYZAxrTI//n3/76B8M9n
-        6NrP9D+nrsnf4z///rMV/t41+GfqpvT1/z7/1/dV//Wv/wUAAP//AwBcfFVx4CAAAA==
-    headers:
-      CF-RAY:
-      - 931fceef786ded38-SJC
-      Connection:
-      - keep-alive
-      Content-Encoding:
-      - gzip
-      Content-Type:
-      - application/json
-      Date:
-      - Thu, 17 Apr 2025 23:47:35 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - __cf_bm=fj4RMXSXRDQjE2CFC6CGC3dVcJ8cl2Cbu8alijwMHA8-1744933655-1.0.1.1-M3c3AI4XQa.0GJoanNACuOm2aEL4xjqHR1grxIP3olFvq3e0eFHwQTvCF20YwR_OLiMJUH87eNUwgziawMccsxjR9OVZyDr5._5Wts6CrqA;
-        path=/; expires=Fri, 18-Apr-25 00:17:35 GMT; domain=.api.openai.com; HttpOnly;
-        Secure; SameSite=None
-      - _cfuvid=MSkpJsQZtdyIGvrl2mIwy0a_We8H6CIrS7etFgRBl2Y-1744933655703-0.0.1.1-604800000;
-        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - nosniff
-      access-control-allow-origin:
-      - '*'
-      access-control-expose-headers:
-      - X-Request-ID
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-model:
-      - text-embedding-3-small
-      openai-organization:
-      - crewai-iuxna1
-      openai-processing-ms:
-      - '140'
-      openai-version:
-      - '2020-10-01'
-      strict-transport-security:
-      - max-age=31536000; includeSubDomains; preload
-      via:
-      - envoy-router-84959bbcd5-rzqvq
-      x-envoy-upstream-service-time:
-      - '110'
-      x-ratelimit-limit-requests:
-      - '10000'
-      x-ratelimit-limit-tokens:
-      - '10000000'
-      x-ratelimit-remaining-requests:
-      - '9999'
-      x-ratelimit-remaining-tokens:
-      - '9999986'
-      x-ratelimit-reset-requests:
-      - 6ms
-      x-ratelimit-reset-tokens:
-      - 0s
-      x-request-id:
-      - req_dd3ef61c4765b46ed7db80ddfe261f41
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages": [{"role": "system", "content": "You are Information Agent.
-      You have access to specific knowledge sources.\nYour personal goal is: Provide
-      information based on knowledge sources\nTo give my best complete final answer
-      to the task respond using the exact following format:\n\nThought: I now can
-      give a great answer\nFinal Answer: Your 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!"}, {"role": "user", "content": "\nCurrent Task:
-      What is Brandon''s favorite color?\n\nThis is the expected criteria for your
-      final answer: Brandon''s favorite color.\nyou 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:"}], "model": "gpt-4o-mini", "stop": ["\nObservation:"]}'
-    headers:
-      accept:
-      - application/json
-      accept-encoding:
-      - gzip, deflate, zstd
-      connection:
-      - keep-alive
-      content-length:
-      - '926'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      user-agent:
-      - OpenAI/Python 1.68.2
-      x-stainless-arch:
-      - arm64
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - MacOS
-      x-stainless-package-version:
-      - 1.68.2
-      x-stainless-raw-response:
-      - 'true'
-      x-stainless-read-timeout:
-      - '600.0'
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.12.9
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: !!binary |
-        H4sIAAAAAAAAAwAAAP//jFLBbtswDL37KwhdeokLx0mbOLd2WIAC63YZdthWGIpMO9xkUZDkpEWR
-        fx/kpLG7dUAvBszHR733yOcEQFAlViDUVgbVWp3efv66LvKPRd7Q/f57vtaf7m6ePjze774sv23E
-        JDJ48wtVeGFdKm6txkBsjrByKAPGqdPFfF7MZtdXVz3QcoU60hob0jmnLRlK8yyfp9kinS5P7C2T
-        Qi9W8CMBAHjuv1GnqfBRrCCbvFRa9F42KFbnJgDhWMeKkN6TD9IEMRlAxSag6aXfgeE9KGmgoR2C
-        hCbKBmn8Hh3AT7MmIzXc9P8ruHXSVGwuPNRyx44CgmLNDsjDRnd4OX7GYd15Ga2aTusRII3hIGNU
-        vcGHE3I4W9LcWMcb/xdV1GTIb0uH0rOJ8n1gK3r0kAA89NF1r9IQ1nFrQxn4N/bPTa+Xx3li2NgI
-        LU5g4CD1qL5cTN6YV1YYJGk/Cl8oqbZYDdRhU7KriEdAMnL9r5q3Zh+dk2neM34AlEIbsCqtw4rU
-        a8dDm8N40P9rO6fcCxYe3Y4UloHQxU1UWMtOH89M+CcfsC1rMg066+h4a7Uts1mRL/M8KzKRHJI/
-        AAAA//8DALRhJdF5AwAA
-    headers:
-      CF-Cache-Status:
-      - DYNAMIC
-      CF-RAY:
-      - 931fcef51a67f947-SJC
-      Connection:
-      - keep-alive
-      Content-Encoding:
-      - gzip
-      Content-Type:
-      - application/json
-      Date:
-      - Thu, 17 Apr 2025 23:47:36 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - __cf_bm=7agwu5JV1OJvEFNhvfvqdgWf.HoMyIni9D85soRl3WE-1744933656-1.0.1.1-dKUwAZnjjuuiswFKWGsxpwHNBJUpjhYlZvfZpyNQIejxEJrXMCppgPvtQ9wa4SKezLmKqftvn_H.bAx_AEFJD2EWm5V6R_uK8.odneErR6A;
-        path=/; expires=Fri, 18-Apr-25 00:17:36 GMT; domain=.api.openai.com; HttpOnly;
-        Secure; SameSite=None
-      - _cfuvid=LdTrzwZYrB6ZyQLY7NdaaHVpDVFvIjYm3arSpNy87wU-1744933656504-0.0.1.1-604800000;
-        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - nosniff
-      access-control-expose-headers:
-      - X-Request-ID
-      alt-svc:
-      - h3=":443"; ma=86400
-      openai-organization:
-      - crewai-iuxna1
-      openai-processing-ms:
-      - '540'
-      openai-version:
-      - '2020-10-01'
-      strict-transport-security:
-      - max-age=31536000; includeSubDomains; preload
-      x-ratelimit-limit-requests:
-      - '30000'
-      x-ratelimit-limit-tokens:
-      - '150000000'
-      x-ratelimit-remaining-requests:
-      - '29999'
-      x-ratelimit-remaining-tokens:
-      - '149999802'
-      x-ratelimit-reset-requests:
-      - 2ms
-      x-ratelimit-reset-tokens:
-      - 0s
-      x-request-id:
-      - req_8837be6510731522fd5ac4b75c11d486
-    status:
-      code: 200
-      message: OK
-version: 1

tests/cassettes/test_crew_external_memory_save_using_crew_without_memory_flag[save].yaml

@@ -1,182 +0,0 @@
-interactions:
-- request:
-    body: !!binary |
-      Ct8MCiQKIgoMc2VydmljZS5uYW1lEhIKEGNyZXdBSS10ZWxlbWV0cnkStgwKEgoQY3Jld2FpLnRl
-      bGVtZXRyeRKcCAoQfm0pqVSMD2d8x7Z0oecKIRIIgWppMg8y3GoqDENyZXcgQ3JlYXRlZDABORAN
-      KtAWrDUYQagXMtAWrDUYShsKDmNyZXdhaV92ZXJzaW9uEgkKBzAuMTE0LjBKGgoOcHl0aG9uX3Zl
-      cnNpb24SCAoGMy4xMi45Si4KCGNyZXdfa2V5EiIKIDA3YTcxNzY4Y2M0YzkzZWFiM2IzMWUzYzhk
-      MjgzMmM2SjEKB2NyZXdfaWQSJgokNGY1NjNkN2MtYmYyOC00ZWM2LTgzNzQtMDZlMjZiYzA1NWU0
-      ShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFsShEKC2NyZXdfbWVtb3J5EgIQAEoaChRjcmV3
-      X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19udW1iZXJfb2ZfYWdlbnRzEgIYAUo6ChBjcmV3
-      X2ZpbmdlcnByaW50EiYKJGU4MGY4MDFmLWViZmQtNDlkOS1iNTEwLTM0NmVjN2VlNzAzZko7Chtj
-      cmV3X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0xMlQxNzoyNzoyNC42NTU4NzhK
-      0AIKC2NyZXdfYWdlbnRzEsACCr0CW3sia2V5IjogIjAyZGYxM2UzNjcxMmFiZjUxZDIzOGZlZWJh
-      YjFjYTI2IiwgImlkIjogIjg5MjdlNzQ1LWNkNWQtNDJkMy1hMjA2LTEyYTUxOWRlMDY1OCIsICJy
-      b2xlIjogIlJlc2VhcmNoZXIiLCAidmVyYm9zZT8iOiB0cnVlLCAibWF4X2l0ZXIiOiAyNSwgIm1h
-      eF9ycG0iOiBudWxsLCAiZnVuY3Rpb25fY2FsbGluZ19sbG0iOiAiIiwgImxsbSI6ICJncHQtNG8t
-      bWluaSIsICJkZWxlZ2F0aW9uX2VuYWJsZWQ/IjogZmFsc2UsICJhbGxvd19jb2RlX2V4ZWN1dGlv
-      bj8iOiBmYWxzZSwgIm1heF9yZXRyeV9saW1pdCI6IDIsICJ0b29sc19uYW1lcyI6IFtdfV1K/wEK
-      CmNyZXdfdGFza3MS8AEK7QFbeyJrZXkiOiAiN2I0MmRmM2MzYzc0YzIxYzg5NDgwZTBjMDcwNTM4
-      NWYiLCAiaWQiOiAiNDM0MDgzNDYtMjA5OC00M2I1LWE0NWUtMmU2MWY4ZmYxZTliIiwgImFzeW5j
-      X2V4ZWN1dGlvbj8iOiBmYWxzZSwgImh1bWFuX2lucHV0PyI6IGZhbHNlLCAiYWdlbnRfcm9sZSI6
-      ICJSZXNlYXJjaGVyIiwgImFnZW50X2tleSI6ICIwMmRmMTNlMzY3MTJhYmY1MWQyMzhmZWViYWIx
-      Y2EyNiIsICJ0b29sc19uYW1lcyI6IFtdfV16AhgBhQEAAQAAEoAEChDv1iM8ejIY7tezTF4KBssA
-      Eghn2bJnw2f60SoMVGFzayBDcmVhdGVkMAE58LFA0BasNRhB4AdB0BasNRhKLgoIY3Jld19rZXkS
-      IgogMDdhNzE3NjhjYzRjOTNlYWIzYjMxZTNjOGQyODMyYzZKMQoHY3Jld19pZBImCiQ0ZjU2M2Q3
-      Yy1iZjI4LTRlYzYtODM3NC0wNmUyNmJjMDU1ZTRKLgoIdGFza19rZXkSIgogN2I0MmRmM2MzYzc0
-      YzIxYzg5NDgwZTBjMDcwNTM4NWZKMQoHdGFza19pZBImCiQ0MzQwODM0Ni0yMDk4LTQzYjUtYTQ1
-      ZS0yZTYxZjhmZjFlOWJKOgoQY3Jld19maW5nZXJwcmludBImCiRlODBmODAxZi1lYmZkLTQ5ZDkt
-      YjUxMC0zNDZlYzdlZTcwM2ZKOgoQdGFza19maW5nZXJwcmludBImCiQ2YjgzODVkYS0yYWJjLTRm
-      NWEtOTk3NC0xNjhiMzVhNDBlOTlKOwobdGFza19maW5nZXJwcmludF9jcmVhdGVkX2F0EhwKGjIw
-      MjUtMDQtMTJUMTc6Mjc6MjQuNjU1ODQ4SjsKEWFnZW50X2ZpbmdlcnByaW50EiYKJDIyNTI4NDRl
-      LWNlMTYtNDYyZi04NDI4LTYwYzZmMWYyNGE3N3oCGAGFAQABAAA=
-    headers:
-      Accept:
-      - '*/*'
-      Accept-Encoding:
-      - gzip, deflate
-      Connection:
-      - keep-alive
-      Content-Length:
-      - '1634'
-      Content-Type:
-      - application/x-protobuf
-      User-Agent:
-      - OTel-OTLP-Exporter-Python/1.31.1
-    method: POST
-    uri: https://telemetry.crewai.com:4319/v1/traces
-  response:
-    body:
-      string: "\n\0"
-    headers:
-      Content-Length:
-      - '2'
-      Content-Type:
-      - application/x-protobuf
-      Date:
-      - Sat, 12 Apr 2025 20:27:26 GMT
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages": [{"role": "system", "content": "You are Researcher. You are
-      a researcher at a leading tech think tank.\nYour personal goal is: Search relevant
-      data and provide results\nTo give my best complete final answer to the task
-      respond using the exact following format:\n\nThought: I now can give a great
-      answer\nFinal Answer: Your 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!"}, {"role": "user", "content": "\nCurrent Task: Perform a search
-      on specific topics.\n\nThis is the expected criteria for your final answer:
-      A list of relevant URLs based on the search query.\nyou MUST return the actual
-      complete content as the final answer, not a summary.\n\n# Useful context: \nExternal
-      memories:\n\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:"}], "model":
-      "gpt-4o-mini", "stop": ["\nObservation:"]}'
-    headers:
-      accept:
-      - application/json
-      accept-encoding:
-      - gzip, deflate
-      connection:
-      - keep-alive
-      content-length:
-      - '989'
-      content-type:
-      - application/json
-      cookie:
-      - __cf_bm=nSje5Zn_Lk69BDG85XIauC2hrZjGl0pR2sel9__KWGw-1744489610-1.0.1.1-CPlAgcgTAE30uWrbi_2wiCWrbRDRWiaa.YuQMgST42DLDVg_wdNlJMDQT3Lsqk.g.BO68A66TTirWA0blQaQw.9xdBbPwKO609_ftjdwi5U;
-        _cfuvid=XLC52GLAWCOeWn2vI379CnSGKjPa7f.qr2vSAQ_R66M-1744489610542-0.0.1.1-604800000
-      host:
-      - api.openai.com
-      user-agent:
-      - OpenAI/Python 1.68.2
-      x-stainless-arch:
-      - arm64
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - MacOS
-      x-stainless-package-version:
-      - 1.68.2
-      x-stainless-raw-response:
-      - 'true'
-      x-stainless-read-timeout:
-      - '600.0'
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.12.9
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    content: "{\n  \"id\": \"chatcmpl-BLbjg0OfADWdrLsZxrjKHEeVVbWle\",\n  \"object\":
-      \"chat.completion\",\n  \"created\": 1744489644,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-      \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-      \"assistant\",\n        \"content\": \"I now can give a great answer  \\nFinal
-      Answer: Here is a list of relevant URLs based on the specified search query:
-      \ \\n\\n1. https://www.forbes.com/technology/  \\n2. https://www.sciencedirect.com/
-      \ \\n3. https://www.techcrunch.com/  \\n4. https://www.wired.com/  \\n5. https://www.researchgate.net/
-      \ \\n6. https://www.springer.com/  \\n7. https://www.jstor.org/  \\n8. https://www.statista.com/
-      \ \\n9. https://www.pwc.com/gx/en/services/consulting/technology.html  \\n10.
-      https://www.gartner.com/en/information-technology  \\n\\nThese URLs provide
-      access to a wealth of information on various technology-related topics, including
-      articles, research papers, and analytics.\",\n        \"refusal\": null,\n        \"annotations\":
-      []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
-      \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 185,\n    \"completion_tokens\":
-      169,\n    \"total_tokens\": 354,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
-      0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n
-      \     \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
-      0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
-      \"default\",\n  \"system_fingerprint\": \"fp_80cf447eee\"\n}\n"
-    headers:
-      CF-RAY:
-      - 92f576d83a447e05-GRU
-      Connection:
-      - keep-alive
-      Content-Encoding:
-      - gzip
-      Content-Type:
-      - application/json
-      Date:
-      - Sat, 12 Apr 2025 20:27:27 GMT
-      Server:
-      - cloudflare
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - nosniff
-      access-control-expose-headers:
-      - X-Request-ID
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - crewai-iuxna1
-      openai-processing-ms:
-      - '2273'
-      openai-version:
-      - '2020-10-01'
-      strict-transport-security:
-      - max-age=31536000; includeSubDomains; preload
-      x-ratelimit-limit-requests:
-      - '30000'
-      x-ratelimit-limit-tokens:
-      - '150000000'
-      x-ratelimit-remaining-requests:
-      - '29999'
-      x-ratelimit-remaining-tokens:
-      - '149999788'
-      x-ratelimit-reset-requests:
-      - 2ms
-      x-ratelimit-reset-tokens:
-      - 0s
-      x-request-id:
-      - req_38f6879956c29e6c61c844d1906fa2e8
-    http_version: HTTP/1.1
-    status_code: 200
-version: 1

tests/cassettes/test_crew_external_memory_save_using_crew_without_memory_flag[search].yaml

@@ -1,190 +0,0 @@
-interactions:
-- request:
-    body: !!binary |
-      Ct8MCiQKIgoMc2VydmljZS5uYW1lEhIKEGNyZXdBSS10ZWxlbWV0cnkStgwKEgoQY3Jld2FpLnRl
-      bGVtZXRyeRKcCAoQjin/Su47zAwLq3Hv6yv8GhIImRMfAPs+FOMqDENyZXcgQ3JlYXRlZDABOYCY
-      xbgUrDUYQVie07gUrDUYShsKDmNyZXdhaV92ZXJzaW9uEgkKBzAuMTE0LjBKGgoOcHl0aG9uX3Zl
-      cnNpb24SCAoGMy4xMi45Si4KCGNyZXdfa2V5EiIKIDA3YTcxNzY4Y2M0YzkzZWFiM2IzMWUzYzhk
-      MjgzMmM2SjEKB2NyZXdfaWQSJgokY2UyMGFlNWYtZmMyNy00YWJhLWExYWMtNzUwY2ZhZmMwMTE4
-      ShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFsShEKC2NyZXdfbWVtb3J5EgIQAEoaChRjcmV3
-      X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19udW1iZXJfb2ZfYWdlbnRzEgIYAUo6ChBjcmV3
-      X2ZpbmdlcnByaW50EiYKJDQ4NGFmZDhjLTczMmEtNGM1Ni1hZjk2LTU2MzkwMjNmYjhjOUo7Chtj
-      cmV3X2ZpbmdlcnByaW50X2NyZWF0ZWRfYXQSHAoaMjAyNS0wNC0xMlQxNzoyNzoxNS42NzMyMjNK
-      0AIKC2NyZXdfYWdlbnRzEsACCr0CW3sia2V5IjogIjAyZGYxM2UzNjcxMmFiZjUxZDIzOGZlZWJh
-      YjFjYTI2IiwgImlkIjogImYyYjZkYTU1LTNiMGItNDZiNy05Mzk5LWE5NDJmYjQ4YzU2OSIsICJy
-      b2xlIjogIlJlc2VhcmNoZXIiLCAidmVyYm9zZT8iOiB0cnVlLCAibWF4X2l0ZXIiOiAyNSwgIm1h
-      eF9ycG0iOiBudWxsLCAiZnVuY3Rpb25fY2FsbGluZ19sbG0iOiAiIiwgImxsbSI6ICJncHQtNG8t
-      bWluaSIsICJkZWxlZ2F0aW9uX2VuYWJsZWQ/IjogZmFsc2UsICJhbGxvd19jb2RlX2V4ZWN1dGlv
-      bj8iOiBmYWxzZSwgIm1heF9yZXRyeV9saW1pdCI6IDIsICJ0b29sc19uYW1lcyI6IFtdfV1K/wEK
-      CmNyZXdfdGFza3MS8AEK7QFbeyJrZXkiOiAiN2I0MmRmM2MzYzc0YzIxYzg5NDgwZTBjMDcwNTM4
-      NWYiLCAiaWQiOiAiYmE1MjFjNDgtYzcwNS00MDRlLWE5MDktMjkwZGM0NTlkOThkIiwgImFzeW5j
-      X2V4ZWN1dGlvbj8iOiBmYWxzZSwgImh1bWFuX2lucHV0PyI6IGZhbHNlLCAiYWdlbnRfcm9sZSI6
-      ICJSZXNlYXJjaGVyIiwgImFnZW50X2tleSI6ICIwMmRmMTNlMzY3MTJhYmY1MWQyMzhmZWViYWIx
-      Y2EyNiIsICJ0b29sc19uYW1lcyI6IFtdfV16AhgBhQEAAQAAEoAEChAmCOpHN6fX3l0shQvTLjrB
-      EgjLTyt4A1p7wyoMVGFzayBDcmVhdGVkMAE5gN7juBSsNRhBmFfkuBSsNRhKLgoIY3Jld19rZXkS
-      IgogMDdhNzE3NjhjYzRjOTNlYWIzYjMxZTNjOGQyODMyYzZKMQoHY3Jld19pZBImCiRjZTIwYWU1
-      Zi1mYzI3LTRhYmEtYTFhYy03NTBjZmFmYzAxMThKLgoIdGFza19rZXkSIgogN2I0MmRmM2MzYzc0
-      YzIxYzg5NDgwZTBjMDcwNTM4NWZKMQoHdGFza19pZBImCiRiYTUyMWM0OC1jNzA1LTQwNGUtYTkw
-      OS0yOTBkYzQ1OWQ5OGRKOgoQY3Jld19maW5nZXJwcmludBImCiQ0ODRhZmQ4Yy03MzJhLTRjNTYt
-      YWY5Ni01NjM5MDIzZmI4YzlKOgoQdGFza19maW5nZXJwcmludBImCiRhMDcyNjgwNC05ZjIwLTQw
-      ODgtYWFmOC1iNzhkYTUyNmM3NjlKOwobdGFza19maW5nZXJwcmludF9jcmVhdGVkX2F0EhwKGjIw
-      MjUtMDQtMTJUMTc6Mjc6MTUuNjczMTgxSjsKEWFnZW50X2ZpbmdlcnByaW50EiYKJDNiZDE2MmNm
-      LWNmMWQtNGUwZi04ZmIzLTk3MDljMDkyNmM4ZHoCGAGFAQABAAA=
-    headers:
-      Accept:
-      - '*/*'
-      Accept-Encoding:
-      - gzip, deflate
-      Connection:
-      - keep-alive
-      Content-Length:
-      - '1634'
-      Content-Type:
-      - application/x-protobuf
-      User-Agent:
-      - OTel-OTLP-Exporter-Python/1.31.1
-    method: POST
-    uri: https://telemetry.crewai.com:4319/v1/traces
-  response:
-    body:
-      string: "\n\0"
-    headers:
-      Content-Length:
-      - '2'
-      Content-Type:
-      - application/x-protobuf
-      Date:
-      - Sat, 12 Apr 2025 20:27:16 GMT
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"messages": [{"role": "system", "content": "You are Researcher. You are
-      a researcher at a leading tech think tank.\nYour personal goal is: Search relevant
-      data and provide results\nTo give my best complete final answer to the task
-      respond using the exact following format:\n\nThought: I now can give a great
-      answer\nFinal Answer: Your 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!"}, {"role": "user", "content": "\nCurrent Task: Perform a search
-      on specific topics.\n\nThis is the expected criteria for your final answer:
-      A list of relevant URLs based on the search query.\nyou MUST return the actual
-      complete content as the final answer, not a summary.\n\n# Useful context: \nExternal
-      memories:\n\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:"}], "model":
-      "gpt-4o-mini", "stop": ["\nObservation:"]}'
-    headers:
-      accept:
-      - application/json
-      accept-encoding:
-      - gzip, deflate
-      connection:
-      - keep-alive
-      content-length:
-      - '989'
-      content-type:
-      - application/json
-      cookie:
-      - __cf_bm=nSje5Zn_Lk69BDG85XIauC2hrZjGl0pR2sel9__KWGw-1744489610-1.0.1.1-CPlAgcgTAE30uWrbi_2wiCWrbRDRWiaa.YuQMgST42DLDVg_wdNlJMDQT3Lsqk.g.BO68A66TTirWA0blQaQw.9xdBbPwKO609_ftjdwi5U;
-        _cfuvid=XLC52GLAWCOeWn2vI379CnSGKjPa7f.qr2vSAQ_R66M-1744489610542-0.0.1.1-604800000
-      host:
-      - api.openai.com
-      user-agent:
-      - OpenAI/Python 1.68.2
-      x-stainless-arch:
-      - arm64
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - MacOS
-      x-stainless-package-version:
-      - 1.68.2
-      x-stainless-raw-response:
-      - 'true'
-      x-stainless-read-timeout:
-      - '600.0'
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.12.9
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    content: "{\n  \"id\": \"chatcmpl-BLbjXyMvmR8ctf0sqhp7F1ePskveM\",\n  \"object\":
-      \"chat.completion\",\n  \"created\": 1744489635,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-      \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-      \"assistant\",\n        \"content\": \"I now can give a great answer  \\nFinal
-      Answer: Here is a list of relevant URLs based on the search query:\\n\\n1. **Artificial
-      Intelligence in Healthcare**\\n   - https://www.healthit.gov/topic/scientific-initiatives/ai-healthcare\\n
-      \  - https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7317789/\\n   - https://www.forbes.com/sites/bernardmarr/2021/10/18/the-top-5-ways-ai-is-being-used-in-healthcare/?sh=3edf5df51c9c\\n\\n2.
-      **Blockchain Technology in Supply Chain Management**\\n   - https://www.ibm.com/blockchain/supply-chain\\n
-      \  - https://www.gartner.com/en/newsroom/press-releases/2021-06-23-gartner-says-three-use-cases-for-blockchain-in-supply-chain-are-scaling\\n
-      \  - https://www2.deloitte.com/us/en/insights/industry/retail-distribution/blockchain-in-supply-chain.html\\n\\n3.
-      **Renewable Energy Innovations**\\n   - https://www.irena.org/publications/2020/Sep/Renewable-Power-Generation-Costs-in-2020\\n
-      \  - https://www.nrel.gov/docs/fy20osti/77021.pdf\\n   - https://www.cnbc.com/2021/11/03/renewable-energy-could-get-its-first-taste-of-markets-in-2021.html\\n\\n4.
-      **7G Technology Developments**\\n   - https://www.sciencedirect.com/science/article/pii/S1389128619308189\\n
-      \  - https://www.forbes.com/sites/bernardmarr/2021/11/01/what-is-7g-technology-a-beginners-guide-to-the-future-of-mobile-communications/?sh=51b8a7e1464a\\n
-      \  - https://www.ericsson.com/en/reports-and-research/reports/7g-networks-a-powerful-future-for-connected-society\\n\\n5.
-      **Impact of Quantum Computing on Cybersecurity**\\n   - https://www.ibm.com/blogs/research/2021/09/quantum-computing-cybersecurity/\\n
-      \  - https://www.sciencedirect.com/science/article/pii/S0167739X21000072\\n
-      \  - https://www.techrepublic.com/article/how-quantum-computing-will-change-cybersecurity/\\n\\nThese
-      URLs should provide comprehensive information on the topics searched, providing
-      valuable insights and data for your research needs.\",\n        \"refusal\":
-      null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\":
-      \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 185,\n    \"completion_tokens\":
-      534,\n    \"total_tokens\": 719,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
-      0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n
-      \     \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
-      0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
-      \"default\",\n  \"system_fingerprint\": \"fp_80cf447eee\"\n}\n"
-    headers:
-      CF-RAY:
-      - 92f576a01d3b7e05-GRU
-      Connection:
-      - keep-alive
-      Content-Encoding:
-      - gzip
-      Content-Type:
-      - application/json
-      Date:
-      - Sat, 12 Apr 2025 20:27:24 GMT
-      Server:
-      - cloudflare
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - nosniff
-      access-control-expose-headers:
-      - X-Request-ID
-      alt-svc:
-      - h3=":443"; ma=86400
-      cf-cache-status:
-      - DYNAMIC
-      openai-organization:
-      - crewai-iuxna1
-      openai-processing-ms:
-      - '8805'
-      openai-version:
-      - '2020-10-01'
-      strict-transport-security:
-      - max-age=31536000; includeSubDomains; preload
-      x-ratelimit-limit-requests:
-      - '30000'
-      x-ratelimit-limit-tokens:
-      - '150000000'
-      x-ratelimit-remaining-requests:
-      - '29999'
-      x-ratelimit-remaining-tokens:
-      - '149999788'
-      x-ratelimit-reset-requests:
-      - 2ms
-      x-ratelimit-reset-tokens:
-      - 0s
-      x-request-id:
-      - req_7c2d313d0b5997e903553a782b2afa25
-    http_version: HTTP/1.1
-    status_code: 200
-version: 1