chore: bump version to 0.119.0 and update dependencies (#2778)

This commit updates the project version to 0.119.0 and modifies the required version of the `crewai-tools` dependency to 0.44.0 across various configuration files. Additionally, the version number is reflected in the `__init__.py` file and the CLI templates for crew, flow, and tool projects.

.github/workflows/notify-downstream.yml

@@ -0,0 +1,33 @@
+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,6 +12,9 @@ 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
@@ -21,12 +24,11 @@ jobs:
         with:
           enable-cache: true
 
-
-      - name: Set up Python
-        run: uv python install 3.12.8
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
 
       - name: Install the project
         run: uv sync --dev --all-extras
 
       - name: Run tests
-        run: uv run pytest tests -vv
+        run: uv run pytest --block-network --timeout=60 -vv

.gitignore

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

README.md

@@ -257,10 +257,14 @@ 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:
@@ -401,11 +405,16 @@ You can test different real life examples of AI crews in the [CrewAI-examples re
 
 ### Using Crews and Flows Together
 
-CrewAI's power truly shines when combining Crews with Flows to create sophisticated automation pipelines. Here's how you can orchestrate multiple Crews within a Flow:
+CrewAI's power truly shines when combining Crews with Flows to create sophisticated automation pipelines.
+CrewAI flows support logical operators like `or_` and `and_` to combine multiple conditions. This can be used with `@start`, `@listen`, or `@router` decorators to create complex triggering conditions.
+- `or_`: Triggers when any of the specified conditions are met. 
+- `and_`Triggers when all of the specified conditions are met.
+
+Here's how you can orchestrate multiple Crews within a Flow:
 
 ```python
-from crewai.flow.flow import Flow, listen, start, router
-from crewai import Crew, Agent, Task
+from crewai.flow.flow import Flow, listen, start, router, or_
+from crewai import Crew, Agent, Task, Process
 from pydantic import BaseModel
 
 # Define structured state for precise control
@@ -479,7 +488,7 @@ class AdvancedAnalysisFlow(Flow[MarketState]):
         )
         return strategy_crew.kickoff()
 
-    @listen("medium_confidence", "low_confidence")
+    @listen(or_("medium_confidence", "low_confidence"))
     def request_additional_analysis(self):
         self.state.recommendations.append("Gather more data")
         return "Additional analysis required"
@@ -495,7 +504,7 @@ This example demonstrates how to:
 
 CrewAI supports using various LLMs through a variety of connection options. By default your agents will use the OpenAI API when querying the model. However, there are several other ways to allow your agents to connect to models. For example, you can configure your agents to use a local model via the Ollama tool.
 
-Please refer to the [Connect CrewAI to LLMs](https://docs.crewai.com/how-to/LLM-Connections/) page for details on configuring you agents' connections to models.
+Please refer to the [Connect CrewAI to LLMs](https://docs.crewai.com/how-to/LLM-Connections/) page for details on configuring your agents' connections to models.
 
 ## How CrewAI Compares
 

docs/changelog.mdx

@@ -4,8 +4,104 @@ description: View the latest updates and changes to CrewAI
 icon: timeline
 ---
 
+<Update label="2025-04-30" description="v0.117.1">
+  ## Release Highlights
+  <Frame>
+    <img src="/images/releases/v01171.png" />
+  </Frame>
+  
+  <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
+    <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.117.1">View on GitHub</a>
+  </div>
+
+  **Core Improvements & Fixes**
+  - Upgraded **crewai-tools** to latest version
+  - Upgraded **liteLLM** to latest version
+  - Fixed **Mem0 OSS**
+</Update>
+
+<Update label="2025-04-28" description="v0.117.0">
+  ## Release Highlights
+  <Frame>
+    <img src="/images/releases/v01170.png" />
+  </Frame>
+  
+  <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
+    <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.117.0">View on GitHub</a>
+  </div>
+
+  **New Features & Enhancements**
+  - Added `result_as_answer` parameter support in `@tool` decorator.
+  - Introduced support for new language models: GPT-4.1, Gemini-2.0, and Gemini-2.5 Pro.
+  - Enhanced knowledge management capabilities.
+  - Added Huggingface provider option in CLI.
+  - Improved compatibility and CI support for Python 3.10+.
+
+  **Core Improvements & Fixes**
+  - Fixed issues with incorrect template parameters and missing inputs.
+  - Improved asynchronous flow handling with coroutine condition checks.
+  - Enhanced memory management with isolated configuration and correct memory object copying.
+  - Fixed initialization of lite agents with correct references.
+  - Addressed Python type hint issues and removed redundant imports.
+  - Updated event placement for improved tool usage tracking.
+  - Raised explicit exceptions when flows fail.
+  - Removed unused code and redundant comments from various modules.
+  - Updated GitHub App token action to v2.
+
+  **Documentation & Guides**
+  - Enhanced documentation structure, including enterprise deployment instructions.
+  - Automatically create output folders for documentation generation.
+  - Fixed broken link in WeaviateVectorSearchTool documentation.
+  - Fixed guardrail documentation usage and import paths for JSON search tools.
+  - Updated documentation for CodeInterpreterTool.
+  - Improved SEO, contextual navigation, and error handling for documentation pages.
+</Update>
+
+<Update label="2025-04-07" description="v0.114.0">
+  ## Release Highlights
+  <Frame>
+    <img src="/images/releases/v01140.png" />
+  </Frame>
+
+  <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
+    <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.114.0">View on GitHub</a>
+  </div>
+
+  **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**
+  ## Release Highlights
+  <Frame>
+    <img src="/images/releases/v01080.png" />
+  </Frame>
+
+  <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
+    <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.108.0">View on GitHub</a>
+  </div>
+
+  **New Features & Enhancements**
   - Converted tabs to spaces in `crew.py` template
   - Enhanced LLM Streaming Response Handling and Event System
   - Included `model_name`

docs/concepts/agents.mdx

@@ -18,6 +18,18 @@ 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                                                                                                          |
@@ -106,7 +118,7 @@ class LatestAiDevelopmentCrew():
   @agent
   def researcher(self) -> Agent:
     return Agent(
-      config=self.agents_config['researcher'],
+      config=self.agents_config['researcher'], # type: ignore[index]
       verbose=True,
       tools=[SerperDevTool()]
     )
@@ -114,7 +126,7 @@ class LatestAiDevelopmentCrew():
   @agent
   def reporting_analyst(self) -> Agent:
     return Agent(
-      config=self.agents_config['reporting_analyst'],
+      config=self.agents_config['reporting_analyst'], # type: ignore[index]
       verbose=True
     )
 ```
@@ -233,7 +245,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)
 
@@ -243,7 +255,11 @@ custom_agent = Agent(
 - `response_template`: Formats agent responses
 
 <Note>
-When using custom templates, you can use variables like `{role}`, `{goal}`, and `{input}` in your templates. These will be automatically populated during execution.
+When using custom templates, ensure that both `system_template` and `prompt_template` are defined. The `response_template` is optional but recommended for consistent output formatting.
+</Note>  
+
+<Note>
+When using custom templates, you can use variables like `{role}`, `{goal}`, and `{backstory}` in your templates. These will be automatically populated during execution.
 </Note>
 
 ## Agent Tools

docs/concepts/cli.mdx

@@ -179,7 +179,78 @@ def crew(self) -> Crew:
 ```
 </Note>
 
-### 10. API Keys
+### 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
 
 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,8 +23,7 @@ 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** (`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.                                                                                                                                                  |
+| **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)                                                                                      |
 | **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.                                                                                                                           |
@@ -49,4 +48,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,17 +20,14 @@ 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.                                                                                                      |
-| **Output Log File** _(optional)_      | `output_log_file`      | Set to True to save logs as logs.txt in the current directory or provide a file path. Logs will be in JSON format if the filename ends in .json, otherwise .txt. Defautls to `None`.                                                                      |
+| **Output Log File** _(optional)_      | `output_log_file`      | Set to True to save logs as logs.txt in the current directory or provide a file path. Logs will be in JSON format if the filename ends in .json, otherwise .txt. Defaults to `None`.                                                                      |
 | **Manager Agent** _(optional)_        | `manager_agent`        | `manager` sets a custom agent that will be used as a manager.                                                                                                                                                                                             |
 | **Prompt File** _(optional)_          | `prompt_file`          | Path to the prompt JSON file to be used for the crew.                                                                                                                                                                                                     |
 | **Planning** *(optional)*             | `planning`             | Adds planning ability to the Crew. When activated before each Crew iteration, all Crew data is sent to an AgentPlanner that will plan the tasks and this plan will be added to each task description.                                                     |
@@ -55,12 +52,16 @@ 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
@@ -83,27 +84,27 @@ class YourCrewName:
     @agent
     def agent_one(self) -> Agent:
         return Agent(
-            config=self.agents_config['agent_one'],
+            config=self.agents_config['agent_one'], # type: ignore[index]
             verbose=True
         )
 
     @agent
     def agent_two(self) -> Agent:
         return Agent(
-            config=self.agents_config['agent_two'],
+            config=self.agents_config['agent_two'], # type: ignore[index]
             verbose=True
         )
 
     @task
     def task_one(self) -> Task:
         return Task(
-            config=self.tasks_config['task_one']
+            config=self.tasks_config['task_one'] # type: ignore[index]
         )
 
     @task
     def task_two(self) -> Task:
         return Task(
-            config=self.tasks_config['task_two']
+            config=self.tasks_config['task_two'] # type: ignore[index]
         )
 
     @crew
@@ -245,7 +246,7 @@ print(f"Token Usage: {crew_output.token_usage}")
 You can see real time log of the crew execution, by setting `output_log_file` as a `True(Boolean)` or a `file_name(str)`. Supports logging of events as both `file_name.txt` and `file_name.json`.
 In case of `True(Boolean)` will save as `logs.txt`.
 
-In case of `output_log_file` is set as `False(Booelan)` or `None`, the logs will not be populated.
+In case of `output_log_file` is set as `False(Boolean)` or `None`, the logs will not be populated.
 
 ```python Code
 # Save crew logs

docs/concepts/event-listener.mdx

@@ -13,11 +13,25 @@ CrewAI provides a powerful event system that allows you to listen for and react
 CrewAI uses an event bus architecture to emit events throughout the execution lifecycle. The event system is built on the following components:
 
 1. **CrewAIEventsBus**: A singleton event bus that manages event registration and emission
-2. **CrewEvent**: Base class for all events in the system
+2. **BaseEvent**: Base class for all events in the system
 3. **BaseEventListener**: Abstract base class for creating custom event listeners
 
 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:
@@ -40,17 +54,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")
@@ -83,7 +97,7 @@ my_listener = MyCustomListener()
 
 class MyCustomCrew:
     # Your crew implementation...
-    
+
     def crew(self):
         return Crew(
             agents=[...],
@@ -106,7 +120,7 @@ my_listener = MyCustomListener()
 
 class MyCustomFlow(Flow):
     # Your flow implementation...
-    
+
     @start()
     def first_step(self):
         # ...
@@ -234,7 +248,7 @@ Each event handler receives two parameters:
 1. **source**: The object that emitted the event
 2. **event**: The event instance, containing event-specific data
 
-The structure of the event object depends on the event type, but all events inherit from `CrewEvent` and include:
+The structure of the event object depends on the event type, but all events inherit from `BaseEvent` and include:
 
 - **timestamp**: The time when the event was emitted
 - **type**: A string identifier for the event type
@@ -324,9 +338,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,6 +545,119 @@ 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
+
+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:
+
+```python
+import asyncio
+from typing import Any, Dict, List
+
+from crewai_tools import SerperDevTool
+from pydantic import BaseModel, Field
+
+from crewai.agent import Agent
+from crewai.flow.flow import Flow, listen, start
+
+
+# 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 = None
+
+
+# Create a flow class
+class MarketResearchFlow(Flow[MarketResearchState]):
+    @start()
+    def initialize_research(self) -> Dict[str, Any]:
+        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(
+            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()],
+            verbose=True,
+        )
+
+        # 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 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}
+
+    @listen(analyze_market)
+    def present_results(self, analysis) -> None:
+        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
+
+        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)
+
+
+# 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())
+```
+
+This example demonstrates several key features of using Agents 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.
+
 ## Adding Crews to Flows
 
 Creating a flow with multiple crews in CrewAI is straightforward.

docs/concepts/knowledge.mdx

@@ -42,6 +42,16 @@ 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>
@@ -146,6 +156,26 @@ 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:
@@ -367,6 +397,53 @@ result = crew.kickoff(inputs={"question": "What city does John live in and how o
 John is 30 years old and lives in San Francisco.
 ```
 </CodeGroup>
+
+## Query Rewriting
+
+CrewAI implements an intelligent query rewriting mechanism to optimize knowledge retrieval. When an agent needs to search through knowledge sources, the raw task prompt is automatically transformed into a more effective search query.
+
+### How Query Rewriting Works
+
+1. When an agent executes a task with knowledge sources available, the `_get_knowledge_search_query` method is triggered
+2. The agent's LLM is used to transform the original task prompt into an optimized search query
+3. This optimized query is then used to retrieve relevant information from knowledge sources
+
+### Benefits of Query Rewriting
+
+<CardGroup cols={2}>
+  <Card title="Improved Retrieval Accuracy" icon="bullseye-arrow">
+    By focusing on key concepts and removing irrelevant content, query rewriting helps retrieve more relevant information.
+  </Card>
+  <Card title="Context Awareness" icon="brain">
+    The rewritten queries are designed to be more specific and context-aware for vector database retrieval.
+  </Card>
+</CardGroup>
+
+### Implementation Details
+
+Query rewriting happens transparently using a system prompt that instructs the LLM to:
+
+- Focus on key words of the intended task
+- Make the query more specific and context-aware
+- Remove irrelevant content like output format instructions
+- Generate only the rewritten query without preamble or postamble
+
+<Tip>
+  This mechanism is fully automatic and requires no configuration from users. The agent's LLM is used to perform the query rewriting, so using a more capable LLM can improve the quality of rewritten queries.
+</Tip>
+
+### Example
+
+```python
+# Original task prompt
+task_prompt = "Answer the following questions about the user's favorite movies: What movie did John watch last week? Format your answer in JSON."
+
+# Behind the scenes, this might be rewritten as:
+rewritten_query = "What movies did John watch last week?"
+```
+
+The rewritten query is more focused on the core information need and removes irrelevant instructions about output formatting.
+
 ## Clearing Knowledge
 
 If you need to clear the knowledge stored in CrewAI, you can use the `crewai reset-memories` command with the `--knowledge` option.

docs/concepts/llamaindex-tools.mdx

@@ -1,71 +0,0 @@
----
-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

@@ -27,23 +27,19 @@ Large Language Models (LLMs) are the core intelligence behind CrewAI agents. The
   </Card>
 </CardGroup>
 
-## Setting Up Your LLM
+## Setting up your LLM
 
-There are three ways to configure LLMs in CrewAI. Choose the method that best fits your workflow:
+There are different places in CrewAI code where you can specify the model to use. Once you specify the model you are using, you will need to provide the configuration (like an API key) for each of the model providers you use. See the [provider configuration examples](#provider-configuration-examples) section for your provider.
 
 <Tabs>
   <Tab title="1. Environment Variables">
-    The simplest way to get started. Set these variables in your environment:
+    The simplest way to get started. Set the model in your environment directly, through an `.env` file or in your app code. If you used `crewai create` to bootstrap your project, it will be set already.
 
-    ```bash
-    # Required: Your API key for authentication
-    OPENAI_API_KEY=<your-api-key>
+    ```bash .env
+    MODEL=model-id  # e.g. gpt-4o, gemini-2.0-flash, claude-3-sonnet-...
 
-    # Optional: Default model selection
-    OPENAI_MODEL_NAME=gpt-4o-mini  # Default if not set
-
-    # Optional: Organization ID (if applicable)
-    OPENAI_ORGANIZATION_ID=<your-org-id>
+    # Be sure to set your API keys here too. See the Provider
+    # section below.
     ```
 
     <Warning>
@@ -53,13 +49,13 @@ There are three ways to configure LLMs in CrewAI. Choose the method that best fi
   <Tab title="2. YAML Configuration">
     Create a YAML file to define your agent configurations. This method is great for version control and team collaboration:
 
-    ```yaml
+    ```yaml agents.yaml {6}
     researcher:
         role: Research Specialist
         goal: Conduct comprehensive research and analysis
         backstory: A dedicated research professional with years of experience
         verbose: true
-        llm: openai/gpt-4o-mini # your model here
+        llm: provider/model-id  # e.g. openai/gpt-4o, google/gemini-2.0-flash, anthropic/claude...
         # (see provider configuration examples below for more)
     ```
 
@@ -74,23 +70,23 @@ There are three ways to configure LLMs in CrewAI. Choose the method that best fi
   <Tab title="3. Direct Code">
     For maximum flexibility, configure LLMs directly in your Python code:
 
-    ```python
+    ```python {4,8}
     from crewai import LLM
 
     # Basic configuration
-    llm = LLM(model="gpt-4")
+    llm = LLM(model="model-id-here")  # gpt-4o, gemini-2.0-flash, anthropic/claude...
 
     # Advanced configuration with detailed parameters
     llm = LLM(
-        model="gpt-4o-mini",
+        model="model-id-here",  # gpt-4o, gemini-2.0-flash, anthropic/claude...
         temperature=0.7,        # Higher for more creative outputs
-        timeout=120,           # Seconds to wait for response
-        max_tokens=4000,       # Maximum length of response
-        top_p=0.9,            # Nucleus sampling parameter
-        frequency_penalty=0.1, # Reduce repetition
-        presence_penalty=0.1,  # Encourage topic diversity
+        timeout=120,            # Seconds to wait for response
+        max_tokens=4000,        # Maximum length of response
+        top_p=0.9,              # Nucleus sampling parameter
+        frequency_penalty=0.1 , # Reduce repetition
+        presence_penalty=0.1,   # Encourage topic diversity
         response_format={"type": "json"},  # For structured outputs
-        seed=42               # For reproducible results
+        seed=42                 # For reproducible results
     )
     ```
 
@@ -110,7 +106,6 @@ There are three ways to configure LLMs in CrewAI. Choose the method that best fi
 
 ## Provider Configuration Examples
 
-
 CrewAI supports a multitude of LLM providers, each offering unique features, authentication methods, and model capabilities.
 In this section, you'll find detailed examples that help you select, configure, and optimize the LLM that best fits your project's needs.
 
@@ -383,7 +378,7 @@ In this section, you'll find detailed examples that help you select, configure,
     | microsoft/phi-3-medium-4k-instruct                                  | 4,096 tokens   | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
     | microsoft/phi-3-medium-128k-instruct                                | 128K tokens    | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
     | microsoft/phi-3.5-mini-instruct                                     | 128K tokens    | Lightweight multilingual LLM powering AI applications in latency bound, memory/compute constrained environments |
-    | microsoft/phi-3.5-moe-instruct                                      | 128K tokens    | Advanced LLM based on Mixture of Experts architecure to deliver compute efficient content generation |
+    | microsoft/phi-3.5-moe-instruct                                      | 128K tokens    | Advanced LLM based on Mixture of Experts architecture to deliver compute efficient content generation |
     | microsoft/kosmos-2                                                  | 1,024 tokens   | Groundbreaking multimodal model designed to understand and reason about visual elements in images. |
     | microsoft/phi-3-vision-128k-instruct                               | 128k tokens    | Cutting-edge open multimodal model exceling in high-quality reasoning from images. |
     | microsoft/phi-3.5-vision-instruct                                  | 128k tokens    | Cutting-edge open multimodal model exceling in high-quality reasoning from images. |
@@ -407,19 +402,19 @@ In this section, you'll find detailed examples that help you select, configure,
   </Accordion>
 
   <Accordion title="Local NVIDIA NIM Deployed using WSL2">
-    
-    NVIDIA NIM enables you to run powerful LLMs locally on your Windows machine using WSL2 (Windows Subsystem for Linux). 
-    This approach allows you to leverage your NVIDIA GPU for private, secure, and cost-effective AI inference without relying on cloud services. 
+
+    NVIDIA NIM enables you to run powerful LLMs locally on your Windows machine using WSL2 (Windows Subsystem for Linux).
+    This approach allows you to leverage your NVIDIA GPU for private, secure, and cost-effective AI inference without relying on cloud services.
     Perfect for development, testing, or production scenarios where data privacy or offline capabilities are required.
-    
+
     Here is a step-by-step guide to setting up a local NVIDIA NIM model:
-    
+
     1. Follow installation instructions from [NVIDIA Website](https://docs.nvidia.com/nim/wsl2/latest/getting-started.html)
 
     2. Install the local model. For Llama 3.1-8b follow [instructions](https://build.nvidia.com/meta/llama-3_1-8b-instruct/deploy)
 
     3. Configure your crewai local models:
-  
+
     ```python Code
     from crewai.llm import LLM
 
@@ -438,10 +433,10 @@ 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'],
+                config=self.agents_config['researcher'], # type: ignore[index]
                 llm=local_nvidia_nim_llm
             )
-        
+
         # ...
     ```
   </Accordion>
@@ -535,14 +530,13 @@ 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
-    HUGGINGFACE_API_KEY=<your-api-key>
+    HF_TOKEN=<your-api-key>
     ```
 
     Example usage in your CrewAI project:
     ```python Code
     llm = LLM(
-        model="huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct",
-        base_url="your_api_endpoint"
+        model="huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct"
     )
     ```
   </Accordion>
@@ -638,19 +632,19 @@ CrewAI supports streaming responses from LLMs, allowing your application to rece
 
     When streaming is enabled, responses are delivered in chunks as they're generated, creating a more responsive user experience.
   </Tab>
-  
+
   <Tab title="Event Handling">
     CrewAI emits events for each chunk received during streaming:
-    
+
     ```python
     from crewai import LLM
     from crewai.utilities.events import EventHandler, LLMStreamChunkEvent
-    
+
     class MyEventHandler(EventHandler):
         def on_llm_stream_chunk(self, event: LLMStreamChunkEvent):
             # Process each chunk as it arrives
             print(f"Received chunk: {event.chunk}")
-    
+
     # Register the event handler
     from crewai.utilities.events import crewai_event_bus
     crewai_event_bus.register_handler(MyEventHandler())
@@ -786,7 +780,7 @@ Learn how to get the most out of your LLM configuration:
     <Tip>
       Use larger context models for extensive tasks
     </Tip>
-    
+
     ```python
     # Large context model
     llm = LLM(model="openai/gpt-4o")  # 128K tokens

docs/concepts/memory.mdx

@@ -18,7 +18,8 @@ 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. |
-| **User Memory**      | Stores user-specific information and preferences, enhancing personalization and user experience. |
+| **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. |
 
 ## How Memory Systems Empower Agents
 
@@ -144,6 +145,7 @@ 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
@@ -164,7 +166,10 @@ crew = Crew(
 
 [Mem0](https://mem0.ai/) is a self-improving memory layer for LLM applications, enabling personalized AI experiences. 
 
-To include user-specific memory you can get your API key [here](https://app.mem0.ai/dashboard/api-keys) and refer the [docs](https://docs.mem0.ai/platform/quickstart#4-1-create-memories) for adding user preferences.
+
+### Using Mem0 API platform
+
+To include user-specific memory you can get your API key [here](https://app.mem0.ai/dashboard/api-keys) and refer the [docs](https://docs.mem0.ai/platform/quickstart#4-1-create-memories) for adding user preferences. In this case `user_memory` is set to `MemoryClient` from mem0.
 
 
 ```python Code
@@ -175,18 +180,7 @@ from mem0 import MemoryClient
 # Set environment variables for Mem0
 os.environ["MEM0_API_KEY"] = "m0-xx"
 
-# Step 1: Record preferences based on past conversation or user input
-client = MemoryClient()
-messages = [
-    {"role": "user", "content": "Hi there! I'm planning a vacation and could use some advice."},
-    {"role": "assistant", "content": "Hello! I'd be happy to help with your vacation planning. What kind of destination do you prefer?"},
-    {"role": "user", "content": "I am more of a beach person than a mountain person."},
-    {"role": "assistant", "content": "That's interesting. Do you like hotels or Airbnb?"},
-    {"role": "user", "content": "I like Airbnb more."},
-]
-client.add(messages, user_id="john")
-
-# Step 2: Create a Crew with User Memory
+# Step 1: Create a Crew with User Memory
 
 crew = Crew(
     agents=[...],
@@ -197,11 +191,12 @@ crew = Crew(
     memory_config={
         "provider": "mem0",
         "config": {"user_id": "john"},
+        "user_memory" : {} #Set user_memory explicitly to a dictionary, we are working on this issue.
     },
 )
 ```
 
-## Memory Configuration Options
+#### Additional Memory Configuration Options
 If you want to access a specific organization and project, you can set the `org_id` and `project_id` parameters in the memory configuration.
 
 ```python Code
@@ -215,10 +210,172 @@ crew = Crew(
     memory_config={
         "provider": "mem0",
         "config": {"user_id": "john", "org_id": "my_org_id", "project_id": "my_project_id"},
+        "user_memory" : {} #Set user_memory explicitly to a dictionary, we are working on this issue.
     },
 )
 ```
 
+### Using Local Mem0 memory
+If you want to use local mem0 memory, with a custom configuration, you can set a parameter `local_mem0_config` in the config itself.
+If both os environment key is set and local_mem0_config is given, the API platform takes higher priority over the local configuration.
+Check [this](https://docs.mem0.ai/open-source/python-quickstart#run-mem0-locally) mem0 local configuration docs for more understanding.
+In this case `user_memory` is set to `Memory` from mem0.
+
+
+```python Code
+from crewai import Crew
+
+
+#local mem0 config
+config = {
+    "vector_store": {
+        "provider": "qdrant",
+        "config": {
+            "host": "localhost",
+            "port": 6333
+        }
+    },
+    "llm": {
+        "provider": "openai",
+        "config": {
+            "api_key": "your-api-key",
+            "model": "gpt-4"
+        }
+    },
+    "embedder": {
+        "provider": "openai",
+        "config": {
+            "api_key": "your-api-key",
+            "model": "text-embedding-3-small"
+        }
+    },
+    "graph_store": {
+        "provider": "neo4j",
+        "config": {
+            "url": "neo4j+s://your-instance",
+            "username": "neo4j",
+            "password": "password"
+        }
+    },
+    "history_db_path": "/path/to/history.db",
+    "version": "v1.1",
+    "custom_fact_extraction_prompt": "Optional custom prompt for fact extraction for memory",
+    "custom_update_memory_prompt": "Optional custom prompt for update memory"
+}
+
+crew = Crew(
+    agents=[...],
+    tasks=[...],
+    verbose=True,
+    memory=True,
+    memory_config={
+        "provider": "mem0",
+        "config": {"user_id": "john", 'local_mem0_config': config},
+        "user_memory" : {} #Set user_memory explicitly to a dictionary, we are working on this issue.
+    },
+)
+```
+
+### 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
 
 ### Using OpenAI embeddings (already default)

docs/concepts/tasks.mdx

@@ -12,6 +12,18 @@ 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:
@@ -101,7 +113,7 @@ class LatestAiDevelopmentCrew():
   @agent
   def researcher(self) -> Agent:
     return Agent(
-      config=self.agents_config['researcher'],
+      config=self.agents_config['researcher'], # type: ignore[index]
       verbose=True,
       tools=[SerperDevTool()]
     )
@@ -109,20 +121,20 @@ class LatestAiDevelopmentCrew():
   @agent
   def reporting_analyst(self) -> Agent:
     return Agent(
-      config=self.agents_config['reporting_analyst'],
+      config=self.agents_config['reporting_analyst'], # type: ignore[index]
       verbose=True
     )
 
   @task
   def research_task(self) -> Task:
     return Task(
-      config=self.tasks_config['research_task']
+      config=self.tasks_config['research_task'] # type: ignore[index]
     )
 
   @task
   def reporting_task(self) -> Task:
     return Task(
-      config=self.tasks_config['reporting_task']
+      config=self.tasks_config['reporting_task'] # type: ignore[index]
     )
 
   @crew
@@ -276,26 +288,20 @@ 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: str) -> Tuple[bool, Union[Dict[str, Any], str]]:
+def validate_blog_content(result: TaskOutput) -> Tuple[bool, Any]:
     """Validate blog content meets requirements."""
     try:
         # Check word count
         word_count = len(result.split())
         if word_count > 200:
-            return (False, {
-                "error": "Blog content exceeds 200 words",
-                "code": "WORD_COUNT_ERROR",
-                "context": {"word_count": word_count}
-            })
+            return (False, "Blog content exceeds 200 words")
 
         # Additional validation logic here
         return (True, result.strip())
     except Exception as e:
-        return (False, {
-            "error": "Unexpected error during validation",
-            "code": "SYSTEM_ERROR"
-        })
+        return (False, "Unexpected error during validation")
 
 blog_task = Task(
     description="Write a blog post about AI",
@@ -313,29 +319,28 @@ blog_task = Task(
    - Type hints are recommended but optional
 
 2. **Return Values**:
-   - Success: Return `(True, validated_result)`
-   - Failure: Return `(False, error_details)`
+   - 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")`
+
+### LLMGuardrail
+
+The `LLMGuardrail` class offers a robust mechanism for validating task outputs.
 
 ### Error Handling Best Practices
 
 1. **Structured Error Responses**:
 ```python Code
-def validate_with_context(result: str) -> Tuple[bool, Union[Dict[str, Any], str]]:
+from crewai import TaskOutput
+
+def validate_with_context(result: TaskOutput) -> Tuple[bool, Any]:
     try:
         # Main validation logic
         validated_data = perform_validation(result)
         return (True, validated_data)
     except ValidationError as e:
-        return (False, {
-            "error": str(e),
-            "code": "VALIDATION_ERROR",
-            "context": {"input": result}
-        })
+        return (False, f"VALIDATION_ERROR: {str(e)}")
     except Exception as e:
-        return (False, {
-            "error": "Unexpected error",
-            "code": "SYSTEM_ERROR"
-        })
+        return (False, str(e))
 ```
 
 2. **Error Categories**:
@@ -346,28 +351,25 @@ def validate_with_context(result: str) -> Tuple[bool, Union[Dict[str, Any], str]
 3. **Validation Chain**:
 ```python Code
 from typing import Any, Dict, List, Tuple, Union
+from crewai import TaskOutput
 
-def complex_validation(result: str) -> Tuple[bool, Union[str, Dict[str, Any]]]:
+def complex_validation(result: TaskOutput) -> Tuple[bool, Any]:
     """Chain multiple validation steps."""
     # Step 1: Basic validation
     if not result:
-        return (False, {"error": "Empty result", "code": "EMPTY_INPUT"})
+        return (False, "Empty result")
 
     # Step 2: Content validation
     try:
         validated = validate_content(result)
         if not validated:
-            return (False, {"error": "Invalid content", "code": "CONTENT_ERROR"})
+            return (False, "Invalid content")
 
         # Step 3: Format validation
         formatted = format_output(validated)
         return (True, formatted)
     except Exception as e:
-        return (False, {
-            "error": str(e),
-            "code": "VALIDATION_ERROR",
-            "context": {"step": "content_validation"}
-        })
+        return (False, str(e))
 ```
 
 ### Handling Guardrail Results
@@ -382,19 +384,16 @@ 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: str) -> Tuple[bool, Union[Dict[str, Any], str]]:
+def validate_json_output(result: TaskOutput) -> Tuple[bool, Any]:
     """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, {
-            "error": "Invalid JSON format",
-            "code": "JSON_ERROR",
-            "context": {"line": e.lineno, "column": e.colno}
-        })
+        return (False, "Invalid JSON format")
 
 task = Task(
     description="Generate a JSON report",
@@ -414,7 +413,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
@@ -495,7 +494,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
@@ -755,6 +754,8 @@ Task guardrails provide a powerful way to validate, transform, or filter task ou
 
 ### Basic Usage
 
+#### Define your own logic to validate
+
 ```python Code
 from typing import Tuple, Union
 from crewai import Task
@@ -774,6 +775,57 @@ task = Task(
 )
 ```
 
+#### Leverage a no-code approach for validation
+
+```python Code
+from crewai import Task
+
+task = Task(
+    description="Generate JSON data",
+    expected_output="Valid JSON object",
+    guardrail="Ensure the response is a valid JSON object"
+)
+```
+
+#### Using YAML
+
+```yaml
+research_task:
+  ...
+  guardrail: make sure each bullet contains a minimum of 100 words
+  ...
+```
+
+```python Code
+@CrewBase
+class InternalCrew:
+    agents_config = "config/agents.yaml"
+    tasks_config = "config/tasks.yaml"
+
+    ...
+    @task
+    def research_task(self):
+        return Task(config=self.tasks_config["research_task"])  # type: ignore[index]
+    ...
+```
+
+
+#### Use custom models for code generation
+
+```python Code
+from crewai import Task
+from crewai.llm import LLM
+
+task = Task(
+    description="Generate JSON data",
+    expected_output="Valid JSON object",
+    guardrail=LLMGuardrail(
+        description="Ensure the response is a valid JSON object",
+        llm=LLM(model="gpt-4o-mini"),
+    )
+)
+```
+
 ### How Guardrails Work
 
 1. **Optional Attribute**: Guardrails are an optional attribute at the task level, allowing you to add validation only where needed.

docs/concepts/tools.mdx

@@ -15,6 +15,18 @@ 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.
@@ -79,7 +91,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
@@ -141,7 +153,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>
 
@@ -178,48 +190,6 @@ def my_tool(question: str) -> str:
     return "Result from your custom tool"
 ```
 
-### Structured Tools
-
-The `StructuredTool` class wraps functions as tools, providing flexibility and validation while reducing boilerplate. It supports custom schemas and dynamic logic for seamless integration of complex functionalities.
-
-#### Example:
-Using `StructuredTool.from_function`, you can wrap a function that interacts with an external API or system, providing a structured interface. This enables robust validation and consistent execution, making it easier to integrate complex functionalities into your applications as demonstrated in the following example:
-
-```python
-from crewai.tools.structured_tool import CrewStructuredTool
-from pydantic import BaseModel
-
-# Define the schema for the tool's input using Pydantic
-class APICallInput(BaseModel):
-    endpoint: str
-    parameters: dict
-
-# Wrapper function to execute the API call
-def tool_wrapper(*args, **kwargs):
-    # Here, you would typically call the API using the parameters
-    # For demonstration, we'll return a placeholder string
-    return f"Call the API at {kwargs['endpoint']} with parameters {kwargs['parameters']}"
-
-# Create and return the structured tool
-def create_structured_tool():
-    return CrewStructuredTool.from_function(
-        name='Wrapper API',
-        description="A tool to wrap API calls with structured input.",
-        args_schema=APICallInput,
-        func=tool_wrapper,
-    )
-
-# Example usage
-structured_tool = create_structured_tool()
-
-# Execute the tool with structured input
-result = structured_tool._run(**{
-    "endpoint": "https://example.com/api",
-    "parameters": {"key1": "value1", "key2": "value2"}
-})
-print(result)  # Output: Call the API at https://example.com/api with parameters {'key1': 'value1', 'key2': 'value2'}
-```
-
 ### Custom Caching Mechanism
 
 <Tip>

docs/docs.json

@@ -8,25 +8,27 @@
     "dark": "#C94C3C"
   },
   "favicon": "favicon.svg",
+  "contextual": {
+    "options": ["copy", "view", "chatgpt", "claude"]
+  },
   "navigation": {
     "tabs": [
       {
-        "tab": "Get Started",
+        "tab": "Documentation",
         "groups": [
           {
             "group": "Get Started",
             "pages": [
               "introduction",
               "installation",
-              "quickstart",
-              "changelog"
+              "quickstart"
             ]
           },
           {
             "group": "Guides",
             "pages": [
               {
-                "group": "Concepts",
+                "group": "Strategy",
                 "pages": [
                   "guides/concepts/evaluating-use-cases"
                 ]
@@ -76,41 +78,7 @@
               "concepts/testing",
               "concepts/cli",
               "concepts/tools",
-              "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/weave-integration",
-              "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/portkey-observability"
+              "concepts/event-listener"
             ]
           },
           {
@@ -140,6 +108,7 @@
               "tools/hyperbrowserloadtool",
               "tools/linkupsearchtool",
               "tools/llamaindextool",
+              "tools/langchaintool",
               "tools/serperdevtool",
               "tools/s3readertool",
               "tools/s3writertool",
@@ -169,6 +138,40 @@
               "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": [
@@ -177,6 +180,42 @@
           }
         ]
       },
+      {
+        "tab": "Enterprise",
+        "groups": [
+          {
+            "group": "Getting Started",
+            "pages": [
+              "enterprise/introduction"
+            ]
+          },
+          {
+            "group": "How-To Guides",
+            "pages": [
+              "enterprise/guides/build-crew",
+              "enterprise/guides/deploy-crew",
+              "enterprise/guides/kickoff-crew",
+              "enterprise/guides/update-crew",
+              "enterprise/guides/use-crew-api",
+              "enterprise/guides/enable-crew-studio"
+            ]
+          },
+          {
+            "group": "Features",
+            "pages": [
+              "enterprise/features/tool-repository",
+              "enterprise/features/webhook-streaming",
+              "enterprise/features/traces"
+            ]
+          },
+          {
+            "group": "Resources",
+            "pages": [
+              "enterprise/resources/frequently-asked-questions"
+            ]
+          }
+        ]
+      },
       {
         "tab": "Examples",
         "groups": [
@@ -187,14 +226,35 @@
             ]
           }
         ]
+      },
+      {
+        "tab": "Releases",
+        "groups": [
+          {
+            "group": "Releases",
+            "pages": [
+              "changelog"
+            ]
+          }
+        ]
       }
     ],
     "global": {
       "anchors": [
         {
-          "anchor": "Community",
+          "anchor": "Website",
+          "href": "https://crewai.com",
+          "icon": "globe"
+        },
+        {
+          "anchor": "Forum",
           "href": "https://community.crewai.com",
           "icon": "discourse"
+        },
+        {
+          "anchor": "Get Help",
+          "href": "mailto:support@crewai.com",
+          "icon": "headset"
         }
       ]
     }
@@ -208,6 +268,12 @@
     "strict": false
   },
   "navbar": {
+    "links": [
+      {
+        "label": "Start Free Trial",
+        "href": "https://app.crewai.com"
+      }
+    ],
     "primary": {
       "type": "github",
       "href": "https://github.com/crewAIInc/crewAI"
@@ -217,7 +283,12 @@
     "prompt": "Search CrewAI docs"
   },
   "seo": {
-    "indexing": "navigable"
+    "indexing": "all"
+  },
+  "errors": {
+    "404": {
+      "redirect": true
+    }
   },
   "footer": {
     "socials": {
@@ -229,4 +300,4 @@
       "reddit": "https://www.reddit.com/r/crewAIInc/"
     }
   }
-}
+}

docs/enterprise/features/tool-repository.mdx

@@ -0,0 +1,106 @@
+---
+title: Tool Repository
+description: "Using the Tool Repository to manage your tools"
+icon: "toolbox"
+---
+
+## Overview
+
+The Tool Repository is a package manager for CrewAI tools. It allows users to publish, install, and manage tools that integrate with CrewAI crews and flows.
+
+Tools can be:
+
+- **Private**: accessible only within your organization (default)
+- **Public**: accessible to all CrewAI users if published with the `--public` flag
+
+The repository is not a version control system. Use Git to track code changes and enable collaboration.
+
+## Prerequisites
+
+Before using the Tool Repository, ensure you have:
+
+- A [CrewAI Enterprise](https://app.crewai.com) account
+- [CrewAI CLI](https://docs.crewai.com/concepts/cli#cli) installed
+- [Git](https://git-scm.com) installed and configured
+- Access permissions to publish or install tools in your CrewAI Enterprise organization
+
+## Installing Tools
+
+To install a tool:
+
+```bash
+crewai tool install <tool-name>
+```
+
+This installs the tool and adds it to `pyproject.toml`.
+
+## Creating and Publishing Tools
+
+To create a new tool project:
+
+```bash
+crewai tool create <tool-name>
+```
+
+This generates a scaffolded tool project locally.
+
+After making changes, initialize a Git repository and commit the code:
+
+```bash
+git init
+git add .
+git commit -m "Initial version"
+```
+
+To publish the tool:
+
+```bash
+crewai tool publish
+```
+
+By default, tools are published as private. To make a tool public:
+
+```bash
+crewai tool publish --public
+```
+
+For more details on how to build tools, see [Creating your own tools](https://docs.crewai.com/concepts/tools#creating-your-own-tools).
+
+## Updating Tools
+
+To update a published tool:
+
+1. Modify the tool locally
+2. Update the version in `pyproject.toml` (e.g., from `0.1.0` to `0.1.1`)
+3. Commit the changes and publish
+
+```bash
+git commit -m "Update version to 0.1.1"
+crewai tool publish
+```
+
+## Deleting Tools
+
+To delete a tool:
+
+1. Go to [CrewAI Enterprise](https://app.crewai.com)
+2. Navigate to **Tools**
+3. Select the tool
+4. Click **Delete**
+
+<Warning>
+Deletion is permanent. Deleted tools cannot be restored or re-installed.
+</Warning>
+
+## Security Checks
+
+Every published version undergoes automated security checks, and are only available to install after they pass. 
+
+You can check the security check status of a tool at:
+
+`CrewAI Enterprise > Tools > Your Tool > Versions`
+
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with API integration or troubleshooting.
+</Card>

docs/enterprise/features/traces.mdx

@@ -0,0 +1,146 @@
+---
+title: Traces
+description: "Using Traces to monitor your Crews"
+icon: "timeline"
+---
+
+## Overview
+
+Traces provide comprehensive visibility into your crew executions, helping you monitor performance, debug issues, and optimize your AI agent workflows.
+
+## What are Traces?
+
+Traces in CrewAI Enterprise are detailed execution records that capture every aspect of your crew's operation, from initial inputs to final outputs. They record:
+
+- Agent thoughts and reasoning
+- Task execution details
+- Tool usage and outputs
+- Token consumption metrics
+- Execution times
+- Cost estimates
+
+<Frame>
+  ![Traces Overview](/images/enterprise/traces-overview.png)
+</Frame>
+
+## Accessing Traces
+
+<Steps>
+  <Step title="Navigate to the Traces Tab">
+    Once in your CrewAI Enterprise dashboard, click on the **Traces** to view all execution records.
+  </Step>
+  
+  <Step title="Select an Execution">
+    You'll see a list of all crew executions, sorted by date. Click on any execution to view its detailed trace.
+  </Step>
+</Steps>
+
+## Understanding the Trace Interface
+
+The trace interface is divided into several sections, each providing different insights into your crew's execution:
+
+### 1. Execution Summary
+
+The top section displays high-level metrics about the execution:
+
+- **Total Tokens**: Number of tokens consumed across all tasks
+- **Prompt Tokens**: Tokens used in prompts to the LLM
+- **Completion Tokens**: Tokens generated in LLM responses
+- **Requests**: Number of API calls made
+- **Execution Time**: Total duration of the crew run
+- **Estimated Cost**: Approximate cost based on token usage
+
+<Frame>
+  ![Execution Summary](/images/enterprise/trace-summary.png)
+</Frame>
+
+### 2. Tasks & Agents
+
+This section shows all tasks and agents that were part of the crew execution:
+
+- Task name and agent assignment
+- Agents and LLMs used for each task
+- Status (completed/failed)
+- Individual execution time of the task
+
+<Frame>
+  ![Task List](/images/enterprise/trace-tasks.png)
+</Frame>
+
+### 3. Final Output
+
+Displays the final result produced by the crew after all tasks are completed.
+
+<Frame>
+  ![Final Output](/images/enterprise/final-output.png)
+</Frame>
+
+### 4. Execution Timeline
+
+A visual representation of when each task started and ended, helping you identify bottlenecks or parallel execution patterns.
+
+<Frame>
+  ![Execution Timeline](/images/enterprise/trace-timeline.png)
+</Frame>
+
+### 5. Detailed Task View
+
+When you click on a specific task in the timeline or task list, you'll see:
+
+<Frame>
+  ![Detailed Task View](/images/enterprise/trace-detailed-task.png)
+</Frame>
+
+- **Task Key**: Unique identifier for the task
+- **Task ID**: Technical identifier in the system
+- **Status**: Current state (completed/running/failed)
+- **Agent**: Which agent performed the task
+- **LLM**: Language model used for this task
+- **Start/End Time**: When the task began and completed
+- **Execution Time**: Duration of this specific task
+- **Task Description**: What the agent was instructed to do
+- **Expected Output**: What output format was requested
+- **Input**: Any input provided to this task from previous tasks
+- **Output**: The actual result produced by the agent
+
+
+## Using Traces for Debugging
+
+Traces are invaluable for troubleshooting issues with your crews:
+
+<Steps>
+  <Step title="Identify Failure Points">
+    When a crew execution doesn't produce the expected results, examine the trace to find where things went wrong. Look for:
+    
+    - Failed tasks
+    - Unexpected agent decisions
+    - Tool usage errors
+    - Misinterpreted instructions
+
+    <Frame>
+      ![Failure Points](/images/enterprise/failure.png)
+    </Frame>
+  </Step>
+  
+  <Step title="Optimize Performance">
+    Use execution metrics to identify performance bottlenecks:
+    
+    - Tasks that took longer than expected
+    - Excessive token usage
+    - Redundant tool operations
+    - Unnecessary API calls
+  </Step>
+  
+  <Step title="Improve Cost Efficiency">
+    Analyze token usage and cost estimates to optimize your crew's efficiency:
+    
+    - Consider using smaller models for simpler tasks
+    - Refine prompts to be more concise
+    - Cache frequently accessed information
+    - Structure tasks to minimize redundant operations
+  </Step>
+</Steps>
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with trace analysis or any other CrewAI Enterprise features.
+</Card>

docs/enterprise/features/webhook-streaming.mdx

@@ -0,0 +1,82 @@
+---
+title: Webhook Streaming
+description: "Using Webhook Streaming to stream events to your webhook"
+icon: "webhook"
+---
+
+## Overview
+
+Enterprise Event Streaming lets you receive real-time webhook updates about your crews and flows deployed to 
+CrewAI Enterprise, such as model calls, tool usage, and flow steps.
+
+## Usage
+
+When using the Kickoff API, include a `webhooks` object to your request, for example:
+
+```json
+{
+  "inputs": {"foo": "bar"},
+  "webhooks": {
+    "events": ["crew_kickoff_started", "llm_call_started"],
+    "url": "https://your.endpoint/webhook",
+    "realtime": false,
+    "authentication": {
+      "strategy": "bearer",
+      "token": "my-secret-token"
+    }
+  }
+}
+```
+
+If `realtime` is set to `true`, each event is delivered individually and immediately, at the cost of crew/flow performance.
+
+## Webhook Format
+
+Each webhook sends a list of events:
+
+```json
+{
+  "events": [
+    {
+      "id": "event-id",
+      "execution_id": "crew-run-id",
+      "timestamp": "2025-02-16T10:58:44.965Z",
+      "type": "llm_call_started",
+      "data": {
+        "model": "gpt-4",
+        "messages": [
+          {"role": "system", "content": "You are an assistant."},
+          {"role": "user", "content": "Summarize this article."}
+        ]
+      }
+    }
+  ]
+}
+```
+
+The `data` object structure varies by event type. Refer to the [event list](https://github.com/crewAIInc/crewAI/tree/main/src/crewai/utilities/events) on GitHub.
+
+As requests are sent over HTTP, the order of events can't be guaranteed. If you need ordering, use the `timestamp` field.
+
+## Supported Events
+
+CrewAI supports both system events and custom events in Enterprise Event Streaming. These events are sent to your configured webhook endpoint during crew and flow execution.
+
+- `crew_kickoff_started`
+- `crew_step_started`
+- `crew_step_completed`
+- `crew_execution_completed`
+- `llm_call_started`
+- `llm_call_completed`
+- `tool_usage_started`
+- `tool_usage_completed`
+- `crew_test_failed`
+- *...and others*
+
+Event names match the internal event bus. See [GitHub source](https://github.com/crewAIInc/crewAI/tree/main/src/crewai/utilities/events) for the full list.
+
+You can emit your own custom events, and they will be delivered through the webhook stream alongside system events.
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with webhook integration or troubleshooting.
+</Card>

docs/enterprise/guides/build-crew.mdx

@@ -0,0 +1,43 @@
+---
+title: "Build Crew"
+description: "A Crew is a group of agents that work together to complete a task."
+icon: "people-arrows"
+---
+
+## Overview
+
+[CrewAI Enterprise](https://app.crewai.com) streamlines the process of **creating**, **deploying**, and **managing** your AI agents in production environments.
+
+## Getting Started
+
+<iframe 
+    width="100%"
+    height="400"
+    src="https://www.youtube.com/embed/-kSOTtYzgEw"
+    title="Building Crews with CrewAI CLI" 
+    frameborder="0"
+    style={{ borderRadius: '10px' }}
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+    allowfullscreen
+></iframe>
+
+### Installation and Setup
+
+<Card title="Follow Standard Installation" icon="wrench" href="/installation">
+  Follow our standard installation guide to set up CrewAI CLI and create your first project.
+</Card>
+
+### Building Your Crew
+
+<Card title="Quickstart Tutorial" icon="rocket" href="/quickstart">
+  Follow our quickstart guide to create your first agent crew using YAML configuration.
+</Card>
+
+## Support and Resources
+
+For Enterprise-specific support or questions, contact our dedicated support team at [support@crewai.com](mailto:support@crewai.com).
+
+
+<Card title="Schedule a Demo" icon="calendar" href="mailto:support@crewai.com">
+  Book time with our team to learn more about Enterprise features and how they can benefit your organization.
+</Card>

docs/enterprise/guides/deploy-crew.mdx

@@ -0,0 +1,237 @@
+---
+title: "Deploy Crew"
+description: "Deploy your local CrewAI project to the Enterprise platform"
+icon: "cloud-arrow-up"
+---
+
+## Overview
+
+This guide will walk you through the process of deploying your locally developed CrewAI project to the CrewAI Enterprise platform, 
+transforming it into a production-ready API endpoint.
+
+## Option 1: CLI Deployment
+
+<iframe 
+    width="100%"
+    height="400"
+    src="https://www.youtube.com/embed/3EqSV-CYDZA" 
+    title="Deploying a Crew to CrewAI Enterprise" 
+    frameborder="0"
+    style={{ borderRadius: '10px' }}
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+    allowfullscreen
+></iframe>
+
+### Prerequisites
+
+Before starting the deployment process, make sure you have:
+
+- A CrewAI project built locally ([follow our quickstart guide](/quickstart) if you haven't created one yet)
+- Your code pushed to a GitHub repository
+- The latest version of the CrewAI CLI installed (`uv tool install crewai`)
+
+<Note>
+For a quick reference project, you can clone our example repository at [github.com/tonykipkemboi/crewai-latest-ai-development](https://github.com/tonykipkemboi/crewai-latest-ai-development).
+</Note>
+
+
+<Steps>
+
+  <Step title="Authenticate with the Enterprise Platform">
+    First, you need to authenticate your CLI with the CrewAI Enterprise platform:
+
+    ```bash
+    # If you already have a CrewAI Enterprise account
+    crewai login
+
+    # If you're creating a new account
+    crewai signup
+    ```
+
+    When you run either command, the CLI will:
+    1. Display a URL and a unique device code
+    2. Open your browser to the authentication page
+    3. Prompt you to confirm the device
+    4. Complete the authentication process
+
+    Upon successful authentication, you'll see a confirmation message in your terminal!
+
+  </Step>
+
+  <Step title="Create a Deployment">
+
+    From your project directory, run:
+
+    ```bash
+    crewai deploy create
+    ```
+
+    This command will:
+    1. Detect your GitHub repository information
+    2. Identify environment variables in your local `.env` file
+    3. Securely transfer these variables to the Enterprise platform
+    4. Create a new deployment with a unique identifier
+
+    On successful creation, you'll see a message like:
+    ```shell
+    Deployment created successfully!
+    Name: your_project_name
+    Deployment ID: 01234567-89ab-cdef-0123-456789abcdef
+    Current Status: Deploy Enqueued
+    ```
+
+  </Step>
+
+  <Step title="Monitor Deployment Progress">
+
+    Track the deployment status with:
+
+    ```bash
+    crewai deploy status
+    ```
+
+    For detailed logs of the build process:
+
+    ```bash
+    crewai deploy logs
+    ```
+
+    <Tip>
+    The first deployment typically takes 10-15 minutes as it builds the container images. Subsequent deployments are much faster.
+    </Tip>
+
+  </Step>
+</Steps>
+
+## Additional CLI Commands
+
+The CrewAI CLI offers several commands to manage your deployments:
+
+  ```bash
+  # List all your deployments
+  crewai deploy list
+
+  # Get the status of your deployment
+  crewai deploy status
+
+  # View the logs of your deployment
+  crewai deploy logs
+
+  # Push updates after code changes
+  crewai deploy push
+
+  # Remove a deployment
+  crewai deploy remove <deployment_id>
+  ``` 
+
+## Option 2: Deploy Directly via Web Interface
+
+You can also deploy your crews directly through the CrewAI Enterprise web interface by connecting your GitHub account. This approach doesn't require using the CLI on your local machine.
+
+<Steps>
+
+  <Step title="Pushing to GitHub">
+
+  You need to push your crew to a GitHub repository. If you haven't created a crew yet, you can [follow this tutorial](/quickstart).
+
+  </Step>
+
+  <Step title="Connecting GitHub to CrewAI Enterprise">
+
+    1. Log in to [CrewAI Enterprise](https://app.crewai.com)
+    2. Click on the button "Connect GitHub" 
+
+    <Frame>
+      ![Connect GitHub Button](/images/enterprise/connect-github.png)
+    </Frame>
+
+  </Step>
+
+  <Step title="Select the Repository">
+
+    After connecting your GitHub account, you'll be able to select which repository to deploy:
+
+    <Frame>
+      ![Select Repository](/images/enterprise/select-repo.png)
+    </Frame>
+
+  </Step>
+
+  <Step title="Set Environment Variables">
+
+    Before deploying, you'll need to set up your environment variables to connect to your LLM provider or other services:
+
+    1. You can add variables individually or in bulk
+    2. Enter your environment variables in `KEY=VALUE` format (one per line)
+
+    <Frame>
+      ![Set Environment Variables](/images/enterprise/set-env-variables.png)
+    </Frame>
+
+  </Step>
+
+  <Step title="Deploy Your Crew">
+
+    1. Click the "Deploy" button to start the deployment process
+    2. You can monitor the progress through the progress bar
+    3. The first deployment typically takes around 10-15 minutes; subsequent deployments will be faster
+
+    <Frame>
+      ![Deploy Progress](/images/enterprise/deploy-progress.png)
+    </Frame>
+
+    Once deployment is complete, you'll see:
+    - Your crew's unique URL
+    - A Bearer token to protect your crew API
+    - A "Delete" button if you need to remove the deployment
+
+  </Step>
+
+</Steps>
+
+### Interact with Your Deployed Crew
+
+Once deployment is complete, you can access your crew through:
+
+1. **REST API**: The platform generates a unique HTTPS endpoint with these key routes:
+   - `/inputs`: Lists the required input parameters
+   - `/kickoff`: Initiates an execution with provided inputs
+   - `/status/{kickoff_id}`: Checks the execution status
+
+2. **Web Interface**: Visit [app.crewai.com](https://app.crewai.com) to access:
+   - **Status tab**: View deployment information, API endpoint details, and authentication token
+   - **Run tab**: Visual representation of your crew's structure
+   - **Executions tab**: History of all executions
+   - **Metrics tab**: Performance analytics
+   - **Traces tab**: Detailed execution insights
+
+### Trigger an Execution
+
+From the Enterprise dashboard, you can:
+
+1. Click on your crew's name to open its details
+2. Select "Trigger Crew" from the management interface
+3. Enter the required inputs in the modal that appears
+4. Monitor progress as the execution moves through the pipeline
+
+### Monitoring and Analytics
+
+The Enterprise platform provides comprehensive observability features:
+
+- **Execution Management**: Track active and completed runs
+- **Traces**: Detailed breakdowns of each execution
+- **Metrics**: Token usage, execution times, and costs
+- **Timeline View**: Visual representation of task sequences
+
+### Advanced Features
+
+The Enterprise platform also offers:
+
+- **Environment Variables Management**: Securely store and manage API keys
+- **LLM Connections**: Configure integrations with various LLM providers
+- **Custom Tools Repository**: Create, share, and install tools
+- **Crew Studio**: Build crews through a chat interface without writing code
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with deployment issues or questions about the Enterprise platform.
+</Card>

docs/enterprise/guides/enable-crew-studio.mdx

@@ -0,0 +1,166 @@
+---
+title: "Enable Crew Studio"
+description: "Enabling Crew Studio on CrewAI Enterprise"
+icon: "comments"
+---
+
+<Tip>
+Crew Studio is a powerful **no-code/low-code** tool that allows you to quickly scaffold or build Crews through a conversational interface. 
+</Tip>
+
+## What is Crew Studio?
+
+Crew Studio is an innovative way to create AI agent crews without writing code. 
+
+<Frame>
+  ![Crew Studio Interface](/images/enterprise/crew-studio-interface.png)
+</Frame>
+
+With Crew Studio, you can:
+
+- Chat with the Crew Assistant to describe your problem
+- Automatically generate agents and tasks
+- Select appropriate tools
+- Configure necessary inputs
+- Generate downloadable code for customization
+- Deploy directly to the CrewAI Enterprise platform
+
+## Configuration Steps
+
+Before you can start using Crew Studio, you need to configure your LLM connections:
+
+<Steps>
+  <Step title="Set Up LLM Connection">
+    Go to the **LLM Connections** tab in your CrewAI Enterprise dashboard and create a new LLM connection.
+
+    <Note>
+      Feel free to use any LLM provider you want that is supported by CrewAI.
+    </Note>
+    
+    Configure your LLM connection:
+    
+    - Enter a `Connection Name` (e.g., `OpenAI`)
+    - Select your model provider: `openai` or `azure`
+    - Select models you'd like to use in your Studio-generated Crews
+      - We recommend at least `gpt-4o`, `o1-mini`, and `gpt-4o-mini`
+    - Add your API key as an environment variable:
+      - For OpenAI: Add `OPENAI_API_KEY` with your API key
+      - For Azure OpenAI: Refer to [this article](https://blog.crewai.com/configuring-azure-openai-with-crewai-a-comprehensive-guide/) for configuration details
+    - Click `Add Connection` to save your configuration
+    
+    <Frame>
+      ![LLM Connection Configuration](/images/enterprise/llm-connection-config.png)
+    </Frame>
+  </Step>
+  
+  <Step title="Verify Connection Added">
+    Once you complete the setup, you'll see your new connection added to the list of available connections.
+    
+    <Frame>
+      ![Connection Added](/images/enterprise/connection-added.png)
+    </Frame>
+  </Step>
+  
+  <Step title="Configure LLM Defaults">
+    In the main menu, go to **Settings → Defaults** and configure the LLM Defaults settings:
+    
+    - Select default models for agents and other components
+    - Set default configurations for Crew Studio
+    
+    Click `Save Settings` to apply your changes.
+    
+    <Frame>
+      ![LLM Defaults Configuration](/images/enterprise/llm-defaults.png)
+    </Frame>
+  </Step>
+</Steps>
+
+## Using Crew Studio
+
+Now that you've configured your LLM connection and default settings, you're ready to start using Crew Studio!
+
+<Steps>
+  <Step title="Access Studio">
+    Navigate to the **Studio** section in your CrewAI Enterprise dashboard.
+  </Step>
+  
+  <Step title="Start a Conversation">
+    Start a conversation with the Crew Assistant by describing the problem you want to solve:
+    
+    ```md
+    I need a crew that can research the latest AI developments and create a summary report.
+    ```
+    
+    The Crew Assistant will ask clarifying questions to better understand your requirements.
+  </Step>
+  
+  <Step title="Review Generated Crew">
+    Review the generated crew configuration, including:
+    
+    - Agents and their roles
+    - Tasks to be performed
+    - Required inputs
+    - Tools to be used
+    
+    This is your opportunity to refine the configuration before proceeding.
+  </Step>
+  
+  <Step title="Deploy or Download">
+    Once you're satisfied with the configuration, you can:
+    
+    - Download the generated code for local customization
+    - Deploy the crew directly to the CrewAI Enterprise platform
+    - Modify the configuration and regenerate the crew
+  </Step>
+  
+  <Step title="Test Your Crew">
+    After deployment, test your crew with sample inputs to ensure it performs as expected.
+  </Step>
+</Steps>
+
+<Tip>
+For best results, provide clear, detailed descriptions of what you want your crew to accomplish. Include specific inputs and expected outputs in your description.
+</Tip>
+
+## Example Workflow
+
+Here's a typical workflow for creating a crew with Crew Studio:
+
+<Steps>
+  <Step title="Describe Your Problem">
+    Start by describing your problem:
+    
+    ```md
+    I need a crew that can analyze financial news and provide investment recommendations
+    ```
+  </Step>
+  
+  <Step title="Answer Questions">
+    Respond to clarifying questions from the Crew Assistant to refine your requirements.
+  </Step>
+  
+  <Step title="Review the Plan">
+    Review the generated crew plan, which might include:
+    
+    - A Research Agent to gather financial news
+    - An Analysis Agent to interpret the data
+    - A Recommendations Agent to provide investment advice
+  </Step>
+  
+  <Step title="Approve or Modify">
+    Approve the plan or request changes if necessary.
+  </Step>
+  
+  <Step title="Download or Deploy">
+    Download the code for customization or deploy directly to the platform.
+  </Step>
+  
+  <Step title="Test and Refine">
+    Test your crew with sample inputs and refine as needed.
+  </Step>
+</Steps>
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with Crew Studio or any other CrewAI Enterprise features.
+</Card>
+

docs/enterprise/guides/kickoff-crew.mdx

@@ -0,0 +1,186 @@
+---
+title: "Kickoff Crew"
+description: "Kickoff a Crew on CrewAI Enterprise"
+icon: "flag-checkered"
+---
+
+## Overview
+
+Once you've deployed your crew to the CrewAI Enterprise platform, you can kickoff executions through the web interface or the API. This guide covers both approaches.
+
+## Method 1: Using the Web Interface
+
+### Step 1: Navigate to Your Deployed Crew
+
+1. Log in to [CrewAI Enterprise](https://app.crewai.com)
+2. Click on the crew name from your projects list
+3. You'll be taken to the crew's detail page
+
+<Frame>
+  ![Crew Dashboard](/images/enterprise/crew-dashboard.png)
+</Frame>
+
+### Step 2: Initiate Execution
+
+From your crew's detail page, you have two options to kickoff an execution:
+
+#### Option A: Quick Kickoff
+
+1. Click the `Kickoff` link in the Test Endpoints section
+2. Enter the required input parameters for your crew in the JSON editor
+3. Click the `Send Request` button
+
+<Frame>
+  ![Kickoff Endpoint](/images/enterprise/kickoff-endpoint.png)
+</Frame>
+
+#### Option B: Using the Visual Interface
+
+1. Click the `Run` tab in the crew detail page
+2. Enter the required inputs in the form fields
+3. Click the `Run Crew` button
+
+<Frame>
+  ![Run Crew](/images/enterprise/run-crew.png)
+</Frame>
+
+### Step 3: Monitor Execution Progress
+
+After initiating the execution:
+
+1. You'll receive a response containing a `kickoff_id` - **copy this ID**
+2. This ID is essential for tracking your execution
+
+<Frame>
+  ![Copy Task ID](/images/enterprise/copy-task-id.png)
+</Frame>
+
+### Step 4: Check Execution Status
+
+To monitor the progress of your execution:
+
+1. Click the "Status" endpoint in the Test Endpoints section
+2. Paste the `kickoff_id` into the designated field
+3. Click the "Get Status" button
+
+<Frame>
+  ![Get Status](/images/enterprise/get-status.png)
+</Frame>
+
+The status response will show:
+- Current execution state (`running`, `completed`, etc.)
+- Details about which tasks are in progress
+- Any outputs produced so far
+
+### Step 5: View Final Results
+
+Once execution is complete:
+
+1. The status will change to `completed`
+2. You can view the full execution results and outputs
+3. For a more detailed view, check the `Executions` tab in the crew detail page
+
+## Method 2: Using the API
+
+You can also kickoff crews programmatically using the CrewAI Enterprise REST API.
+
+### Authentication
+
+All API requests require a bearer token for authentication:
+
+```bash
+curl -H "Authorization: Bearer YOUR_CREW_TOKEN" https://your-crew-url.crewai.com
+```
+
+Your bearer token is available on the Status tab of your crew's detail page.
+
+### Checking Crew Health
+
+Before executing operations, you can verify that your crew is running properly:
+
+```bash
+curl -H "Authorization: Bearer YOUR_CREW_TOKEN" https://your-crew-url.crewai.com
+```
+
+A successful response will return a message indicating the crew is operational:
+
+```
+Healthy%
+```
+
+### Step 1: Retrieve Required Inputs
+
+First, determine what inputs your crew requires:
+
+```bash
+curl -X GET \
+  -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  https://your-crew-url.crewai.com/inputs
+```
+
+The response will be a JSON object containing an array of required input parameters, for example:
+
+```json
+{"inputs":["topic","current_year"]}
+```
+
+This example shows that this particular crew requires two inputs: `topic` and `current_year`.
+
+### Step 2: Kickoff Execution
+
+Initiate execution by providing the required inputs:
+
+```bash
+curl -X POST \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  -d '{"inputs": {"topic": "AI Agent Frameworks", "current_year": "2025"}}' \
+  https://your-crew-url.crewai.com/kickoff
+```
+
+The response will include a `kickoff_id` that you'll need for tracking:
+
+```json
+{"kickoff_id":"abcd1234-5678-90ef-ghij-klmnopqrstuv"}
+```
+
+### Step 3: Check Execution Status
+
+Monitor the execution progress using the kickoff_id:
+
+```bash
+curl -X GET \
+  -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  https://your-crew-url.crewai.com/status/abcd1234-5678-90ef-ghij-klmnopqrstuv
+```
+
+## Handling Executions
+
+### Long-Running Executions
+
+For executions that may take a long time:
+
+1. Consider implementing a polling mechanism to check status periodically
+2. Use webhooks (if available) for notification when execution completes
+3. Implement error handling for potential timeouts
+
+### Execution Context
+
+The execution context includes:
+
+- Inputs provided at kickoff
+- Environment variables configured during deployment
+- Any state maintained between tasks
+
+### Debugging Failed Executions
+
+If an execution fails:
+
+1. Check the "Executions" tab for detailed logs
+2. Review the "Traces" tab for step-by-step execution details
+3. Look for LLM responses and tool usage in the trace details
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with execution issues or questions about the Enterprise platform.
+</Card>
+

docs/enterprise/guides/update-crew.mdx

@@ -0,0 +1,89 @@
+---
+title: "Update Crew"
+description: "Updating a Crew on CrewAI Enterprise"
+icon: "pencil"
+---
+
+<Note>
+After deploying your crew to CrewAI Enterprise, you may need to make updates to the code, security settings, or configuration. 
+This guide explains how to perform these common update operations.
+</Note>
+
+## Why Update Your Crew?
+
+CrewAI won't automatically pick up GitHub updates by default, so you'll need to manually trigger updates, unless you checked the `Auto-update` option when deploying your crew.
+
+There are several reasons you might want to update your crew deployment:
+- You want to update the code with a latest commit you pushed to GitHub
+- You want to reset the bearer token for security reasons
+- You want to update environment variables
+
+## 1. Updating Your Crew Code for a Latest Commit
+
+When you've pushed new commits to your GitHub repository and want to update your deployment:
+
+1. Navigate to your crew in the CrewAI Enterprise platform
+2. Click on the `Re-deploy` button on your crew details page
+
+<Frame>
+  ![Re-deploy Button](/images/enterprise/redeploy-button.png)
+</Frame>
+
+This will trigger an update that you can track using the progress bar. The system will pull the latest code from your repository and rebuild your deployment.
+
+## 2. Resetting Bearer Token
+
+If you need to generate a new bearer token (for example, if you suspect the current token might have been compromised):
+
+1. Navigate to your crew in the CrewAI Enterprise platform
+2. Find the `Bearer Token` section
+3. Click the `Reset` button next to your current token
+
+<Frame>
+  ![Reset Token](/images/enterprise/reset-token.png)
+</Frame>
+
+<Warning>
+Resetting your bearer token will invalidate the previous token immediately. Make sure to update any applications or scripts that are using the old token.
+</Warning>
+
+## 3. Updating Environment Variables
+
+To update the environment variables for your crew:
+
+1. First access the deployment page by clicking on your crew's name
+
+<Frame>
+  ![Environment Variables Button](/images/enterprise/env-vars-button.png)
+</Frame>
+
+2. Locate the `Environment Variables` section (you will need to click the `Settings` icon to access it)
+3. Edit the existing variables or add new ones in the fields provided
+4. Click the `Update` button next to each variable you modify
+
+<Frame>
+  ![Update Environment Variables](/images/enterprise/update-env-vars.png)
+</Frame>
+
+5. Finally, click the `Update Deployment` button at the bottom of the page to apply the changes
+
+<Note>
+Updating environment variables will trigger a new deployment, but this will only update the environment configuration and not the code itself.
+</Note>
+
+## After Updating
+
+After performing any update:
+
+1. The system will rebuild and redeploy your crew
+2. You can monitor the deployment progress in real-time
+3. Once complete, test your crew to ensure the changes are working as expected
+
+<Tip>
+If you encounter any issues after updating, you can view deployment logs in the platform or contact support for assistance.
+</Tip>
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with updating your crew or troubleshooting deployment issues.
+</Card>
+

docs/enterprise/guides/use-crew-api.mdx

@@ -0,0 +1,319 @@
+---
+title: "Trigger Deployed Crew API"
+description: "Using your deployed crew's API on CrewAI Enterprise"
+icon: "arrow-up-right-from-square"
+---
+
+Once you have deployed your crew to CrewAI Enterprise, it automatically becomes available as a REST API. This guide explains how to interact with your crew programmatically.
+
+## API Basics
+
+Your deployed crew exposes several endpoints that allow you to:
+1. Discover required inputs
+2. Start crew executions
+3. Monitor execution status
+4. Receive results
+
+### Authentication
+
+All API requests require a bearer token for authentication, which is generated when you deploy your crew:
+
+```bash
+curl -H "Authorization: Bearer YOUR_CREW_TOKEN" https://your-crew-url.crewai.com/...
+```
+
+<Tip>
+You can find your bearer token in the Status tab of your crew's detail page in the CrewAI Enterprise dashboard.
+</Tip>
+
+<Frame>
+  ![Bearer Token](/images/enterprise/bearer-token.png)
+</Frame>
+
+## Available Endpoints
+
+Your crew API provides three main endpoints:
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/inputs` | GET | Lists all required inputs for crew execution |
+| `/kickoff` | POST | Starts a crew execution with provided inputs |
+| `/status/{kickoff_id}` | GET | Retrieves the status and results of an execution |
+
+## GET /inputs
+
+The inputs endpoint allows you to discover what parameters your crew requires:
+
+```bash
+curl -X GET \
+  -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  https://your-crew-url.crewai.com/inputs
+```
+
+### Response
+
+```json
+{
+  "inputs": ["budget", "interests", "duration", "age"]
+}
+```
+
+This response indicates that your crew expects four input parameters: `budget`, `interests`, `duration`, and `age`.
+
+## POST /kickoff
+
+The kickoff endpoint starts a new crew execution:
+
+```bash
+curl -X POST \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  -d '{
+    "inputs": {
+      "budget": "1000 USD",
+      "interests": "games, tech, ai, relaxing hikes, amazing food",
+      "duration": "7 days",
+      "age": "35"
+    }
+  }' \
+  https://your-crew-url.crewai.com/kickoff
+```
+
+### Request Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `inputs` | Object | Yes | Key-value pairs of all required inputs |
+| `meta` | Object | No | Additional metadata to pass to the crew |
+| `taskWebhookUrl` | String | No | Callback URL executed after each task |
+| `stepWebhookUrl` | String | No | Callback URL executed after each agent thought |
+| `crewWebhookUrl` | String | No | Callback URL executed when the crew finishes |
+
+### Example with Webhooks
+
+```json
+{
+  "inputs": {
+    "budget": "1000 USD",
+    "interests": "games, tech, ai, relaxing hikes, amazing food",
+    "duration": "7 days",
+    "age": "35"
+  },
+  "meta": {
+    "requestId": "user-request-12345",
+    "source": "mobile-app"
+  },
+  "taskWebhookUrl": "https://your-server.com/webhooks/task",
+  "stepWebhookUrl": "https://your-server.com/webhooks/step",
+  "crewWebhookUrl": "https://your-server.com/webhooks/crew"
+}
+```
+
+### Response
+
+```json
+{
+  "kickoff_id": "abcd1234-5678-90ef-ghij-klmnopqrstuv"
+}
+```
+
+The `kickoff_id` is used to track and retrieve the execution results.
+
+## GET /status/{kickoff_id}
+
+The status endpoint allows you to check the progress and results of a crew execution:
+
+```bash
+curl -X GET \
+  -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  https://your-crew-url.crewai.com/status/abcd1234-5678-90ef-ghij-klmnopqrstuv
+```
+
+### Response Structure
+
+The response structure will vary depending on the execution state:
+
+#### In Progress
+
+```json
+{
+  "status": "running",
+  "current_task": "research_task",
+  "progress": {
+    "completed_tasks": 0,
+    "total_tasks": 2
+  }
+}
+```
+
+#### Completed
+
+```json
+{
+  "status": "completed",
+  "result": {
+    "output": "Comprehensive travel itinerary...",
+    "tasks": [
+      {
+        "task_id": "research_task",
+        "output": "Research findings...",
+        "agent": "Researcher",
+        "execution_time": 45.2
+      },
+      {
+        "task_id": "planning_task",
+        "output": "7-day itinerary plan...",
+        "agent": "Trip Planner",
+        "execution_time": 62.8
+      }
+    ]
+  },
+  "execution_time": 108.5
+}
+```
+
+## Webhook Integration
+
+When you provide webhook URLs in your kickoff request, the system will make POST requests to those URLs at specific points in the execution:
+
+### taskWebhookUrl
+
+Called when each task completes:
+
+```json
+{
+  "kickoff_id": "abcd1234-5678-90ef-ghij-klmnopqrstuv",
+  "task_id": "research_task",
+  "status": "completed",
+  "output": "Research findings...",
+  "agent": "Researcher",
+  "execution_time": 45.2
+}
+```
+
+### stepWebhookUrl
+
+Called after each agent thought or action:
+
+```json
+{
+  "kickoff_id": "abcd1234-5678-90ef-ghij-klmnopqrstuv",
+  "task_id": "research_task",
+  "agent": "Researcher",
+  "step_type": "thought",
+  "content": "I should first search for popular destinations that match these interests..."
+}
+```
+
+### crewWebhookUrl
+
+Called when the entire crew execution completes:
+
+```json
+{
+  "kickoff_id": "abcd1234-5678-90ef-ghij-klmnopqrstuv",
+  "status": "completed",
+  "result": {
+    "output": "Comprehensive travel itinerary...",
+    "tasks": [
+      {
+        "task_id": "research_task",
+        "output": "Research findings...",
+        "agent": "Researcher",
+        "execution_time": 45.2
+      },
+      {
+        "task_id": "planning_task",
+        "output": "7-day itinerary plan...",
+        "agent": "Trip Planner",
+        "execution_time": 62.8
+      }
+    ]
+  },
+  "execution_time": 108.5,
+  "meta": {
+    "requestId": "user-request-12345",
+    "source": "mobile-app"
+  }
+}
+```
+
+## Best Practices
+
+### Handling Long-Running Executions
+
+Crew executions can take anywhere from seconds to minutes depending on their complexity. Consider these approaches:
+
+1. **Webhooks (Recommended)**: Set up webhook endpoints to receive notifications when the execution completes
+2. **Polling**: Implement a polling mechanism with exponential backoff
+3. **Client-Side Timeout**: Set appropriate timeouts for your API requests
+
+### Error Handling
+
+The API may return various error codes:
+
+| Code | Description | Recommended Action |
+|------|-------------|-------------------|
+| 401 | Unauthorized | Check your bearer token |
+| 404 | Not Found | Verify your crew URL and kickoff_id |
+| 422 | Validation Error | Ensure all required inputs are provided |
+| 500 | Server Error | Contact support with the error details |
+
+### Sample Code
+
+Here's a complete Python example for interacting with your crew API:
+
+```python
+import requests
+import time
+
+# Configuration
+CREW_URL = "https://your-crew-url.crewai.com"
+BEARER_TOKEN = "your-crew-token"
+HEADERS = {
+    "Authorization": f"Bearer {BEARER_TOKEN}",
+    "Content-Type": "application/json"
+}
+
+# 1. Get required inputs
+response = requests.get(f"{CREW_URL}/inputs", headers=HEADERS)
+required_inputs = response.json()["inputs"]
+print(f"Required inputs: {required_inputs}")
+
+# 2. Start crew execution
+payload = {
+    "inputs": {
+        "budget": "1000 USD",
+        "interests": "games, tech, ai, relaxing hikes, amazing food",
+        "duration": "7 days",
+        "age": "35"
+    }
+}
+
+response = requests.post(f"{CREW_URL}/kickoff", headers=HEADERS, json=payload)
+kickoff_id = response.json()["kickoff_id"]
+print(f"Execution started with ID: {kickoff_id}")
+
+# 3. Poll for results
+MAX_RETRIES = 30
+POLL_INTERVAL = 10  # seconds
+for i in range(MAX_RETRIES):
+    print(f"Checking status (attempt {i+1}/{MAX_RETRIES})...")
+    response = requests.get(f"{CREW_URL}/status/{kickoff_id}", headers=HEADERS)
+    data = response.json()
+    
+    if data["status"] == "completed":
+        print("Execution completed!")
+        print(f"Result: {data['result']['output']}")
+        break
+    elif data["status"] == "error":
+        print(f"Execution failed: {data.get('error', 'Unknown error')}")
+        break
+    else:
+        print(f"Status: {data['status']}, waiting {POLL_INTERVAL} seconds...")
+        time.sleep(POLL_INTERVAL)
+```
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with API integration or troubleshooting.
+</Card>

docs/enterprise/introduction.mdx

@@ -0,0 +1,99 @@
+---
+title: "CrewAI Enterprise"
+description: "Deploy, monitor, and scale your AI agent workflows"
+icon: "globe"
+---
+
+## Introduction
+
+CrewAI Enterprise provides a platform for deploying, monitoring, and scaling your crews and agents in a production environment.
+
+<Frame>
+  <img src="/images/enterprise/crewai-enterprise-dashboard.png" alt="CrewAI Enterprise Dashboard" />
+</Frame>
+
+CrewAI Enterprise extends the power of the open-source framework with features designed for production deployments, collaboration, and scalability. Deploy your crews to a managed infrastructure and monitor their execution in real-time.
+
+## Key Features
+
+<CardGroup cols={2}>
+  <Card title="Crew Deployments" icon="rocket">
+    Deploy your crews to a managed infrastructure with a few clicks
+  </Card>
+  <Card title="API Access" icon="code">
+    Access your deployed crews via REST API for integration with existing systems
+  </Card>
+  <Card title="Observability" icon="chart-line">
+    Monitor your crews with detailed execution traces and logs
+  </Card>
+  <Card title="Tool Repository" icon="toolbox">
+    Publish and install tools to enhance your crews' capabilities
+  </Card>
+  <Card title="Webhook Streaming" icon="webhook">
+    Stream real-time events and updates to your systems
+  </Card>
+  <Card title="Crew Studio" icon="paintbrush">
+    Create and customize crews using a no-code/low-code interface
+  </Card>
+</CardGroup>
+
+## Deployment Options
+
+<CardGroup cols={3}>
+  <Card title="GitHub Integration" icon="github">
+    Connect directly to your GitHub repositories to deploy code
+  </Card>
+  <Card title="Crew Studio" icon="palette">
+    Deploy crews created through the no-code Crew Studio interface
+  </Card>
+  <Card title="CLI Deployment" icon="terminal">
+    Use the CrewAI CLI for more advanced deployment workflows
+  </Card>
+</CardGroup>
+
+## Getting Started
+
+<Steps>
+  <Step title="Sign up for an account">
+    Create your account at [app.crewai.com](https://app.crewai.com)
+    <Card 
+      title="Sign Up" 
+      icon="user"
+      href="https://app.crewai.com/signup"
+    >
+      Sign Up
+    </Card>
+  </Step>
+  <Step title="Create your first crew">
+    Use code or Crew Studio to create your crew
+    <Card 
+      title="Create Crew" 
+      icon="paintbrush"
+      href="/enterprise/guides/create-crew"
+    >
+      Create Crew
+    </Card>
+  </Step>
+  <Step title="Deploy your crew">
+    Deploy your crew to the Enterprise platform
+    <Card 
+      title="Deploy Crew" 
+      icon="rocket"
+      href="/enterprise/guides/deploy-crew"
+    >
+      Deploy Crew
+    </Card>
+  </Step>
+  <Step title="Access your crew">
+    Integrate with your crew via the generated API endpoints
+    <Card 
+      title="API Access" 
+      icon="code"
+      href="/enterprise/guides/use-crew-api"
+    >
+      Use the Crew API
+    </Card>
+  </Step>
+</Steps>
+
+For detailed instructions, check out our [deployment guide](/enterprise/guides/deploy-crew) or click the button below to get started.

docs/enterprise/resources/frequently-asked-questions.mdx

@@ -0,0 +1,964 @@
+---
+title: FAQs
+description: "Frequently asked questions about CrewAI Enterprise"
+icon: "code"
+---
+
+<AccordionGroup>
+    <Accordion title="How is task execution handled in the hierarchical process?">
+        In the hierarchical process, a manager agent is automatically created and coordinates the workflow, delegating tasks and validating outcomes for
+        streamlined and effective execution. The manager agent utilizes tools to facilitate task delegation and execution by agents under the manager's guidance.
+        The manager LLM is crucial for the hierarchical process and must be set up correctly for proper function.
+    </Accordion>
+
+    <Accordion title="Where can I get the latest CrewAI documentation?">
+        The most up-to-date documentation for CrewAI is available on our official documentation website; https://docs.crewai.com/
+        <Card href="https://docs.crewai.com/" icon="books">CrewAI Docs</Card>
+    </Accordion>
+
+    <Accordion title="What are the key differences between Hierarchical and Sequential Processes in CrewAI?">
+        #### Hierarchical Process:
+        Tasks are delegated and executed based on a structured chain of command.
+        A manager language model (`manager_llm`) must be specified for the manager agent.
+        Manager agent oversees task execution, planning, delegation, and validation.
+        Tasks are not pre-assigned; the manager allocates tasks to agents based on their capabilities.
+
+        #### Sequential Process:
+        Tasks are executed one after another, ensuring tasks are completed in an orderly progression.
+        Output of one task serves as context for the next.
+        Task execution follows the predefined order in the task list.
+
+        #### Which Process is Better Suited for Complex Projects?
+
+        The hierarchical process is better suited for complex projects because it allows for:
+
+        - **Dynamic task allocation and delegation**: Manager agent can assign tasks based on agent capabilities, allowing for efficient resource utilization.
+        - **Structured validation and oversight**: Manager agent reviews task outputs and ensures task completion, increasing reliability and accuracy.
+        - **Complex task management**: Assigning tools at the agent level allows for precise control over tool availability, facilitating the execution of intricate tasks.
+    </Accordion>
+
+    <Accordion title="What are the benefits of using memory in the CrewAI framework?">
+        - **Adaptive Learning**: Crews become more efficient over time, adapting to new information and refining their approach to tasks.
+        - **Enhanced Personalization**: Memory enables agents to remember user preferences and historical interactions, leading to personalized experiences.
+        - **Improved Problem Solving**: Access to a rich memory store aids agents in making more informed decisions, drawing on past learnings and contextual insights.
+    </Accordion>
+
+    <Accordion title="What is the purpose of setting a maximum RPM limit for an agent?">
+        Setting a maximum RPM limit for an agent prevents the agent from making too many requests to external services, which can help to avoid rate limits and improve performance.
+    </Accordion>
+
+    <Accordion title="What role does human input play in the execution of tasks within a CrewAI crew?">
+        It allows agents to request additional information or clarification when necessary.
+        This feature is crucial in complex decision-making processes or when agents require more details to complete a task effectively.
+
+        To integrate human input into agent execution, set the `human_input` flag in the task definition. When enabled, the agent prompts the user for input before delivering its final answer. 
+        This input can provide extra context, clarify ambiguities, or validate the agent's output.
+    </Accordion>
+
+    <Accordion title="What advanced customization options are available for tailoring and enhancing agent behavior and capabilities in CrewAI?">
+        CrewAI provides a range of advanced customization options to tailor and enhance agent behavior and capabilities:
+        
+        - **Language Model Customization**: Agents can be customized with specific language models (`llm`) and function-calling language models (`function_calling_llm`), offering advanced control over their processing and decision-making abilities.
+
+        - **Performance and Debugging Settings**: Adjust an agent's performance and monitor its operations for efficient task execution.
+
+        - **Verbose Mode**: Enables detailed logging of an agent's actions, useful for debugging and optimization.
+
+        - **RPM Limit**: Sets the maximum number of requests per minute (`max_rpm`).
+
+        - **Maximum Iterations for Task Execution**: The `max_iter` attribute allows users to define the maximum number of iterations an agent can perform for a single task, preventing infinite loops or excessively long executions.
+
+        - **Delegation and Autonomy**: Control an agent's ability to delegate or ask questions, tailoring its autonomy and collaborative dynamics within the CrewAI framework. By default, the `allow_delegation` attribute is set to True, enabling agents to seek assistance or delegate tasks as needed. This default behavior promotes collaborative problem-solving and efficiency within the CrewAI ecosystem. If needed, delegation can be disabled to suit specific operational requirements.
+
+        - **Human Input in Agent Execution**: Human input is critical in several agent execution scenarios, allowing agents to request additional information or clarification when necessary. This feature is especially useful in complex decision-making processes or when agents require more details to complete a task effectively.
+    </Accordion>
+
+    <Accordion title="In what scenarios is human input particularly useful in agent execution?">
+        Human input is particularly useful in agent execution when:
+        - **Agents require additional information or clarification**: When agents encounter ambiguity or incomplete data, human input can provide the necessary context to complete the task effectively.
+        - **Agents need to make complex or sensitive decisions**: Human input can assist agents in ethical or nuanced decision-making, ensuring responsible and informed outcomes.
+        - **Oversight and validation of agent output**: Human input can help validate the results generated by agents, ensuring accuracy and preventing any misinterpretation or errors.
+        - **Customizing agent behavior**: Human input can provide feedback on agent responses, allowing users to refine the agent's behavior and responses over time.
+        - **Identifying and resolving errors or limitations**: Human input can help identify and address any errors or limitations in the agent's capabilities, enabling continuous improvement and optimization.
+    </Accordion>
+
+    <Accordion title="What are the different types of memory that are available in crewAI?">
+        The different types of memory available in CrewAI are:
+        - `short-term memory`
+        - `long-term memory`
+        - `entity memory`
+        - `contextual memory`
+
+        Learn more about the different types of memory here:
+        <Card href="https://docs.crewai.com/concepts/memory" icon="brain">CrewAI Memory</Card>
+    </Accordion>
+
+    <Accordion title="How do I use Output Pydantic in a Task?">
+        To use Output Pydantic in a task, you need to define the expected output of the task as a Pydantic model. Here's an example:
+        <Steps>
+            <Step title="Define a Pydantic model">
+                First, you need to define a Pydantic model. For instance, let's create a simple model for a user:
+
+                ```python
+                from pydantic import BaseModel
+
+                class User(BaseModel):
+                    name: str
+                    age: int
+                ```
+            </Step>
+
+            <Step title="Then, when creating a task, specify the expected output as this Pydantic model:">
+
+                ```python
+                from crewai import Task, Crew, Agent
+
+                # Import the User model
+                from my_models import User
+
+                # Create a task with Output Pydantic
+                task = Task(
+                    description="Create a user with the provided name and age",
+                    expected_output=User,  # This is the Pydantic model
+                    agent=agent,
+                    tools=[tool1, tool2]
+                )
+                ```
+            </Step>
+
+            <Step title="In your agent, make sure to set the output_pydantic attribute to the Pydantic model you're using:">
+
+                ```python
+                from crewai import Agent
+
+                # Import the User model
+                from my_models import User
+
+                # Create an agent with Output Pydantic
+                agent = Agent(
+                    role='User Creator',
+                    goal='Create users',
+                    backstory='I am skilled in creating user accounts',
+                    tools=[tool1, tool2],
+                    output_pydantic=User
+                )
+                ```
+            </Step>
+
+            <Step title="When executing the crew, the output of the task will be a User object:">
+
+                ```python
+                from crewai import Crew
+
+                # Create a crew with the agent and task
+                crew = Crew(agents=[agent], tasks=[task])
+
+                # Kick off the crew
+                result = crew.kickoff()
+
+                # The output of the task will be a User object
+                print(result.tasks[0].output)
+                ``` 
+            </Step>
+        </Steps>
+        Here's a tutorial on how to consistently get structured outputs from your agents:
+            <Frame>
+                <iframe 
+                height="400"
+                width="100%"
+                src="https://www.youtube.com/embed/dNpKQk5uxHw" 
+                title="YouTube video player" frameborder="0" 
+                allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" 
+                allowfullscreen></iframe>
+            </Frame>
+    </Accordion>
+
+    <Accordion title="How can I create custom tools for my CrewAI agents?">
+        You can create custom tools by subclassing the `BaseTool` class provided by CrewAI or by using the tool decorator. Subclassing involves defining a new class that inherits from `BaseTool`, specifying the name, description, and the `_run` method for operational logic. The tool decorator allows you to create a `Tool` object directly with the required attributes and a functional logic.
+        Click here for more details:
+        <Card href="https://docs.crewai.com/how-to/create-custom-tools" icon="code">CrewAI Tools</Card>
+    </Accordion>
+
+    <Accordion title="How to Kickoff a Crew from Slack">
+        This guide explains how to start a crew directly from Slack using the CrewAI integration.
+
+        **Prerequisites:**
+        <ul>
+            <li>CrewAI integration installed and connected to your Slack workspace</li>
+            <li>At least one crew configured in CrewAI</li>
+        </ul>
+
+        **Steps:**
+        <Steps>
+            <Step title="Ensure the CrewAI Slack integration is set up">
+                In the CrewAI dashboard, navigate to the **Integrations** section.
+
+                <Frame>
+                    <img src="/images/enterprise/slack-integration.png" alt="CrewAI Slack Integration" />
+                </Frame>
+
+                Verify that Slack is listed and is connected.
+            </Step>
+            <Step title="Open your Slack channel">
+                - Navigate to the channel where you want to kickoff the crew.
+                - Type the slash command "**/kickoff**" to initiate the crew kickoff process.
+                - You should see a  "**Kickoff crew**" appear as you type:
+                    <Frame>
+                        <img src="/images/enterprise/kickoff-slack-crew.png" alt="Kickoff crew" />
+                    </Frame>
+                - Press Enter or select the "**Kickoff crew**" option. A dialog box titled "**Kickoff an AI Crew**" will appear.
+        </Step>
+            <Step title="Select the crew you want to start">
+                - In the dropdown menu labeled "**Select of the crews online:**", choose the crew you want to start.
+                - In the example below, "**prep-for-meeting**" is selected:
+                    <Frame>
+                        <img src="/images/enterprise/kickoff-slack-crew-dropdown.png" alt="Kickoff crew dropdown" />
+                    </Frame>
+                - If your crew requires any inputs, click the "**Add Inputs**" button to provide them.
+                    <Note>
+                        The "**Add Inputs**" button is shown in the example above but is not yet clicked.
+                    </Note>
+            </Step>
+            <Step title="Click Kickoff and wait for the crew to complete">
+                - Once you've selected the crew and added any necessary inputs, click "**Kickoff**" to start the crew.
+                    <Frame>
+                        <img src="/images/enterprise/kickoff-slack-crew-kickoff.png" alt="Kickoff crew" />
+                    </Frame>
+                - The crew will start executing and you will see the results in the Slack channel.
+                    <Frame>
+                        <img src="/images/enterprise/kickoff-slack-crew-results.png" alt="Kickoff crew results" />
+                    </Frame>
+            </Step>
+        </Steps>
+
+        <Tip>
+            - Make sure you have the necessary permissions to use the `/kickoff` command in your Slack workspace.
+
+            - If you don't see your desired crew in the dropdown, ensure it's properly configured and online in CrewAI.
+        </Tip>
+    </Accordion>
+
+    <Accordion title="How to export and use a React Component">
+        Click on the ellipsis (three dots on the right of your deployed crew) and select the export option and save the file locally. We will be using `CrewLead.jsx` for our example.
+
+        <Frame>
+            <img src="/images/enterprise/export-react-component.png" alt="Export React Component" />
+        </Frame>
+
+        To run this React component locally, you'll need to set up a React development environment and integrate this component into a React project. Here's a step-by-step guide to get you started:
+
+        <Steps>
+            <Step title="Install Node.js">
+                - Download and install Node.js from the official website: https://nodejs.org/
+                - Choose the LTS (Long Term Support) version for stability.
+            </Step>
+
+            <Step title="Create a new React project">
+                - Open Command Prompt or PowerShell
+                - Navigate to the directory where you want to create your project
+                - Run the following command to create a new React project:
+
+                    ```bash
+                    npx create-react-app my-crew-app
+                    ```
+                - Change into the project directory:
+                
+                    ```bash
+                    cd my-crew-app
+                    ```
+            </Step>
+
+            <Step title="Install necessary dependencies">
+
+                    ```bash
+                    npm install react-dom
+                    ```
+            </Step>
+
+            <Step title="Create the CrewLead component">
+                - Move the downloaded file `CrewLead.jsx` into the `src` folder of your project,
+            </Step>
+
+            <Step title="Modify your `App.js` to use the `CrewLead` component">
+                    - Open `src/App.js`
+                    - Replace its contents with something like this:
+
+                    ```jsx
+                    import React from 'react';
+                    import CrewLead from './CrewLead';
+
+                    function App() {
+                        return (
+                            <div className="App">
+                                <CrewLead baseUrl="YOUR_API_BASE_URL" bearerToken="YOUR_BEARER_TOKEN" />
+                            </div>
+                        );
+                    }
+
+                    export default App;
+                    ```
+                - Replace `YOUR_API_BASE_URL` and `YOUR_BEARER_TOKEN` with the actual values for your API.
+            </Step>
+
+            <Step title="Start the development server">
+                - In your project directory, run:
+                
+                    ```bash
+                    npm start
+                    ```
+                - This will start the development server, and your default web browser should open automatically to http://localhost:3000, where you'll see your React app running.
+            </Step>
+        </Steps>
+
+        You can then customise the `CrewLead.jsx` to add color, title etc
+
+        <Frame>
+            <img src="/images/enterprise/customise-react-component.png" alt="Customise React Component" />
+        </Frame>
+        <Frame>
+            <img src="/images/enterprise/customise-react-component-2.png" alt="Customise React Component" />
+        </Frame>
+    </Accordion>
+
+    <Accordion title="How to Invite Team Members to Your CrewAI Enterprise Organization">
+        As an administrator of a CrewAI Enterprise account, you can easily invite new team members to join your organization. This article will guide you through the process step-by-step.
+        <Steps>
+            <Step title="Access the Settings Page">
+                - Log in to your CrewAI Enterprise account
+                - Look for the gear icon (⚙️) in the top right corner of the dashboard
+                - Click on the gear icon to access the **Settings** page:
+                    <Frame>
+                        <img src="/images/enterprise/settings-page.png" alt="Settings Page" />
+                    </Frame>
+            </Step>
+            <Step title="Navigate to the Members Section">
+                - On the Settings page, you'll see a `General configuration` header
+                - Below this, find and click on the `Members` tab
+            </Step>
+            <Step title="Invite New Members">
+                - In the Members section, you'll see a list of current members (including yourself)
+                - At the bottom of the list, locate the `Email` input field
+                - Enter the email address of the person you want to invite
+                - Click the `Invite` button next to the email field
+            </Step>
+            <Step title="Repeat as Needed">
+                - You can repeat this process to invite multiple team members
+                - Each invited member will receive an email invitation to join your organization
+            </Step>
+            <Step title="Important Notes">
+                - Only users with administrative privileges can invite new members
+                - Ensure you have the correct email addresses for your team members
+                - Invited members will need to accept the invitation to join your organization
+                - You may want to inform your team members to check their email (including spam folders) for the invitation
+            </Step>
+        </Steps>
+        By following these steps, you can easily expand your team and collaborate more effectively within your CrewAI Enterprise organization.
+    </Accordion>
+
+    <Accordion title="Using Webhooks in CrewAI Enterprise">
+        CrewAI Enterprise allows you to automate your workflow using webhooks.
+        This article will guide you through the process of setting up and using webhooks to kickoff your crew execution, with a focus on integration with ActivePieces, 
+        a workflow automation platform similar to Zapier and Make.com. We will be setting up webhooks in the CrewAI Enterprise UI.
+
+        <Steps>
+            <Step title="Accessing the Kickoff Interface">
+                - Navigate to the CrewAI Enterprise dashboard
+                - Look for the `/kickoff` section, which is used to start the crew execution
+                    <Frame>
+                        <img src="/images/enterprise/kickoff-interface.png" alt="Kickoff Interface" />
+                    </Frame>
+            </Step>
+
+            <Step title="Configuring the JSON Content">
+                In the JSON Content section, you'll need to provide the following information:
+
+                - **inputs**: A JSON object containing:
+                    - `company`: The name of the company (e.g., "tesla")
+                    - `product_name`: The name of the product (e.g., "crewai")
+                    - `form_response`: The type of response (e.g., "financial")
+                    - `icp_description`: A brief description of the Ideal Customer Profile
+                    - `product_description`: A short description of the product
+                    - `taskWebhookUrl`, `stepWebhookUrl`, `crewWebhookUrl`: URLs for various webhook endpoints (ActivePieces, Zapier, Make.com or another compatible platform)
+            </Step>
+
+            <Step title="Integrating with ActivePieces">
+                In this example we will be using ActivePieces. You can use other platforms such as Zapier and Make.com
+
+                To integrate with ActivePieces:
+
+                1. Set up a new flow in ActivePieces
+                2. Add a trigger (e.g., `Every Day` schedule)
+                    <Frame>
+                        <img src="/images/enterprise/activepieces-trigger.png" alt="ActivePieces Trigger" />
+                    </Frame>
+
+                3. Add an HTTP action step
+                    - Set the action to `Send HTTP request`
+                    - Use `POST` as the method
+                    - Set the URL to your CrewAI Enterprise kickoff endpoint
+                    - Add necessary headers (e.g., `Bearer Token`)
+                        <Frame>
+                            <img src="/images/enterprise/activepieces-headers.png" alt="ActivePieces Headers" />
+                        </Frame>
+
+                    - In the body, include the JSON content as configured in step 2
+                        <Frame>
+                            <img src="/images/enterprise/activepieces-body.png" alt="ActivePieces Body" />
+                        </Frame>
+
+                    - The crew will then kickoff at the pre-defined time.
+            </Step>
+
+            <Step title="Setting Up the Webhook">
+                1. Create a new flow in ActivePieces and name it 
+                    <Frame>
+                        <img src="/images/enterprise/activepieces-flow.png" alt="ActivePieces Flow" />
+                    </Frame>
+
+                2. Add a webhook step as the trigger:
+                    - Select `Catch Webhook` as the trigger type
+                    - This will generate a unique URL that will receive HTTP requests and trigger your flow
+                        <Frame>
+                            <img src="/images/enterprise/activepieces-webhook.png" alt="ActivePieces Webhook" />
+                        </Frame>
+
+                    - Configure the email to use crew webhook body text
+                        <Frame>
+                            <img src="/images/enterprise/activepieces-email.png" alt="ActivePieces Email" />
+                        </Frame>
+            </Step>
+            <Step title="Generated output">
+                1. `stepWebhookUrl` - Callback that will be executed upon each agent inner thought
+
+                        ```json
+                        {
+                            "action": "**Preliminary Research Report on the Financial Industry for crewai Enterprise Solution**\n1. Industry Overview and Trends\nThe financial industry in ....\nConclusion:\nThe financial industry presents a fertile ground for implementing AI solutions like crewai, particularly in areas such as digital customer engagement, risk management, and regulatory compliance. Further engagement with the lead is recommended to better tailor the crewai solution to their specific needs and scale.",
+                            "task_id": "97eba64f-958c-40a0-b61c-625fe635a3c0"
+                        }
+                        ```
+
+                2. `taskWebhookUrl` - Callback that will be executed upon the end of each task
+
+                        ```json
+                        {
+                            "description": "Using the information gathered from the lead's data, conduct preliminary research on the lead's industry, company background, and potential use cases for crewai. Focus on finding relevant data that can aid in scoring the lead and planning a strategy to pitch them crewai.The financial industry presents a fertile ground for implementing AI solutions like crewai, particularly in areas such as digital customer engagement, risk management, and regulatory compliance. Further engagement with the lead is recommended to better tailor the crewai solution to their specific needs and scale.",
+                            "task_id": "97eba64f-958c-40a0-b61c-625fe635a3c0"
+                        }
+                        ```
+
+                3. `crewWebhookUrl` - Callback that will be executed upon the end of the crew execution
+
+                        ```json
+                        {
+                            "task_id": "97eba64f-958c-40a0-b61c-625fe635a3c0",
+                            "result": {
+                                "lead_score": "Customer service enhancement, and compliance are particularly relevant.",
+                                "talking_points": [
+                                    "Highlight how crewai's AI solutions can transform customer service with automated, personalized experiences and 24/7 support, improving both customer satisfaction and operational efficiency.",
+                                    "Discuss crewai's potential to help the institution achieve its sustainability goals through better data analysis and decision-making, contributing to responsible investing and green initiatives.",
+                                    "Emphasize crewai's ability to enhance compliance with evolving regulations through efficient data processing and reporting, reducing the risk of non-compliance penalties.",
+                                    "Stress the adaptability of crewai to support both extensive multinational operations and smaller, targeted projects, ensuring the solution grows with the institution's needs."
+                                ]
+                            }
+                        }
+                        ```
+            </Step>
+        </Steps>
+    </Accordion>
+
+    <Accordion title="How to use the crewai custom GPT to create a crew">
+        <Steps>
+            <Step title="Navigate to the CrewAI custom GPT">
+                Click here https://chatgpt.com/g/g-qqTuUWsBY-crewai-assistant to access the CrewAI custom GPT
+                <Card href="https://chatgpt.com/g/g-qqTuUWsBY-crewai-assistant" icon="comments">CrewAI custom GPT</Card>
+            </Step>
+            <Step title="Describe your project idea">
+                For example:
+                ```text
+                Suggest some agents and tasks to retrieve LinkedIn profile details for a given person and a domain.
+                ```
+            </Step>
+            <Step title="The GPT will provide you with a list of suggested agents and tasks">
+                Here's an example of the response you will get:
+                <Frame>
+                    <img src="/images/enterprise/crewai-custom-gpt-1.png" alt="CrewAI custom GPT 1" />
+                </Frame>
+            </Step>
+            <Step title="Create the project structure in your terminal by entering:">
+                ```bash
+                crewai create crew linkedin-profile
+                ```
+                This will create a new crew called `linkedin-profile` in the current directory.
+
+                Follow the full instructions in the https://docs.crewai.com/quickstart to create a crew.
+                <Card href="https://docs.crewai.com/quickstart" icon="code">CrewAI Docs</Card>
+            </Step>
+            <Step title="Ask the GPT to convert the agents and tasks to YAML format.">
+                Here's an example of the final output you will have to save in the `agents.yaml` and `tasks.yaml` files:
+                <Frame>
+                    <img src="/images/enterprise/crewai-custom-gpt-2.png" alt="CrewAI custom GPT 2" />
+                </Frame>
+                - Now replace the `agents.yaml` and `tasks.yaml` with the above code
+                - Ask GPT to create the custom LinkedIn Tool
+                - Ask the GPT to put everything together into the `crew.py` file
+                - You will now have a fully working crew.
+            </Step>
+        </Steps>
+    </Accordion>
+
+    <Accordion title="How to generate images using Dall-E">
+        CrewAI supports integration with OpenAI's DALL-E, allowing your AI agents to generate images as part of their tasks. This guide will walk you through how to set up and use the DALL-E tool in your CrewAI projects.
+
+        **Prerequisites**
+            - crewAI installed (latest version)
+            - OpenAI API key with access to DALL-E
+
+        **Setting Up the DALL-E Tool**
+            To use the DALL-E tool in your CrewAI project, follow these steps:
+            <Steps>
+                <Step title="Import the DALL-E tool">
+
+                    ```python
+                    from crewai_tools import DallETool
+                    ```
+                </Step>
+
+                <Step title="Add the DALL-E tool to your agent configuration">
+
+                    ```python
+                    @agent
+                    def researcher(self) -> Agent:
+                        return Agent(
+                            config=self.agents_config['researcher'],
+                            tools=[SerperDevTool(), DallETool()],  # Add DallETool to the list of tools
+                            allow_delegation=False,
+                            verbose=True
+                        )
+                    ```
+                </Step>
+            </Steps>
+
+        **Using the DALL-E Tool**
+
+        Once you've added the DALL-E tool to your agent, it can generate images based on text prompts. 
+        The tool will return a URL to the generated image, which can be used in the agent's output or passed to other agents for further processing.
+
+        Example usage within a task:
+            ```YAML
+            role: >
+                LinkedIn Profile Senior Data Researcher
+            goal: >
+                Uncover detailed LinkedIn profiles based on provided name {name} and domain {domain}
+                Generate a Dall-e image based on domain {domain}
+            backstory: >
+                You're a seasoned researcher with a knack for uncovering the most relevant LinkedIn profiles.
+                Known for your ability to navigate LinkedIn efficiently, you excel at gathering and presenting
+                professional information clearly and concisely.
+            ```
+
+        The agent with the DALL-E tool will be able to generate the image and provide a URL in its response. You can then download the image.
+        <Frame>
+            <img src="/images/enterprise/dall-e-image.png" alt="DALL-E Image" />
+        </Frame>
+
+        **Best Practices**
+
+        1. Be specific in your image generation prompts to get the best results.
+        2. Remember that image generation can take some time, so factor this into your task planning.
+        3. Always comply with OpenAI's usage policies when generating images.
+
+        **Troubleshooting**
+        1. Ensure your OpenAI API key has access to DALL-E.
+        2. Check that you're using the latest version of crewAI and crewai-tools.
+        3. Verify that the DALL-E tool is correctly added to the agent's tool list.
+    </Accordion>
+
+    <Accordion title="How to use Annotations in crew.py">
+        This guide explains how to use annotations to properly reference **agents**, **tasks**, and other components in the `crew.py` file.
+
+        **Introduction**
+
+        Annotations in the framework are used to decorate classes and methods, providing metadata and functionality to various components of your crew. 
+        These annotations help in organizing and structuring your code, making it more readable and maintainable.
+
+        **Available Annotations**
+
+        The CrewAI framework provides the following annotations:
+
+            - `@CrewBase`: Used to decorate the main crew class.
+            - `@agent`: Decorates methods that define and return Agent objects.
+            - `@task`: Decorates methods that define and return Task objects.
+            - `@crew`: Decorates the method that creates and returns the Crew object.
+            - `@llm`: Decorates methods that initialize and return Language Model objects.
+            - `@tool`: Decorates methods that initialize and return Tool objects.
+            - `@callback`: (Not shown in the example, but available) Used for defining callback methods.
+            - `@output_json`: (Not shown in the example, but available) Used for methods that output JSON data.
+            - `@output_pydantic`: (Not shown in the example, but available) Used for methods that output Pydantic models.
+            - `@cache_handler`: (Not shown in the example, but available) Used for defining cache handling methods.
+
+        **Usage Examples**
+
+        Let's go through examples of how to use these annotations based on the provided LinkedinProfileCrew class:
+
+        **1. Crew Base Class**
+            ```python
+            @CrewBase
+            class LinkedinProfileCrew():
+                """LinkedinProfile crew"""
+                agents_config = 'config/agents.yaml'
+                tasks_config = 'config/tasks.yaml'
+            ```
+
+            The `@CrewBase` annotation is used to decorate the main crew class. 
+            This class typically contains configurations and methods for creating agents, tasks, and the crew itself.
+
+        **2. Tool Definition**
+            ```python
+            @tool
+                def myLinkedInProfileTool(self):
+                    return LinkedInProfileTool()
+                ```
+
+            The `@tool` annotation is used to decorate methods that return tool objects. These tools can be used by agents to perform specific tasks.
+
+        **3. LLM Definition**
+            ```python
+            @llm
+            def groq_llm(self):
+                api_key = os.getenv('api_key')
+                return ChatGroq(api_key=api_key, temperature=0, model_name="mixtral-8x7b-32768")
+            ```
+
+            The `@llm` annotation is used to decorate methods that initialize and return Language Model objects. These LLMs are used by agents for natural language processing tasks.
+
+        **4. Agent Definition**
+            ```python
+            @agent
+            def researcher(self) -> Agent:
+                return Agent(
+                    config=self.agents_config['researcher']
+                )
+            ```
+
+            The `@agent` annotation is used to decorate methods that define and return Agent objects. 
+
+        **5. Task Definition**
+            ```python
+            @task
+            def research_task(self) -> Task:
+                return Task(
+                    config=self.tasks_config['research_linkedin_task'],
+                    agent=self.researcher()
+                )
+            ```
+
+            The `@task` annotation is used to decorate methods that define and return Task objects. These methods specify the task configuration and the agent responsible for the task.
+
+        **6. Crew Creation**
+            ```python
+            @crew
+            def crew(self) -> Crew:
+                """Creates the LinkedinProfile crew"""
+                return Crew(
+                    agents=self.agents,
+                            tasks=self.tasks,
+                            process=Process.sequential,
+                            verbose=True
+                )
+            ``` 
+
+            The `@crew` annotation is used to decorate the method that creates and returns the `Crew` object. This method assembles all the components (agents and tasks) into a functional crew.
+
+        **YAML Configuration**
+
+        The agent configurations are typically stored in a YAML file. Here's an example of how the `agents.yaml` file might look for the researcher agent:
+
+            ```yaml
+            researcher:
+                role: >
+                    LinkedIn Profile Senior Data Researcher
+                goal: >
+                    Uncover detailed LinkedIn profiles based on provided name {name} and domain {domain}
+                    Generate a Dall-E image based on domain {domain}
+                backstory: >
+                    You're a seasoned researcher with a knack for uncovering the most relevant      LinkedIn profiles.
+                    Known for your ability to navigate LinkedIn efficiently, you excel at            gathering and presenting
+                    professional information clearly and concisely.
+                allow_delegation: False
+                verbose: True
+                llm: groq_llm
+                tools:
+                    - myLinkedInProfileTool
+                    - mySerperDevTool
+                    - myDallETool
+            ```
+
+        This YAML configuration corresponds to the researcher agent defined in the `LinkedinProfileCrew` class. The configuration specifies the agent's role, goal, backstory, and other properties such as the LLM and tools it uses.
+
+        Note how the `llm` and `tools` in the YAML file correspond to the methods decorated with `@llm` and `@tool` in the Python class. This connection allows for a flexible and modular design where you can easily update agent configurations without changing the core code.
+
+        **Best Practices**
+            - **Consistent Naming**: Use clear and consistent naming conventions for your methods. For example, agent methods could be named after their roles (e.g., researcher, reporting_analyst).
+            - **Environment Variables**: Use environment variables for sensitive information like API keys.
+            - **Flexibility**: Design your crew to be flexible by allowing easy addition or removal of agents and tasks.
+            - **YAML-Code Correspondence**: Ensure that the names and structures in your YAML files correspond correctly to the decorated methods in your Python code.
+
+        By following these guidelines and properly using annotations, you can create well-structured and maintainable crews using the CrewAI framework.
+    </Accordion>
+
+    <Accordion title="How to Integrate CrewAI Enterprise with Zapier">
+        This guide will walk you through the process of integrating CrewAI Enterprise with Zapier, allowing you to automate workflows between CrewAI Enterprise and other applications.
+
+        **Prerequisites**
+        - A CrewAI Enterprise account
+        - A Zapier account
+        - A Slack account (for this specific integration)
+
+        **Step-by-Step Guide**
+        <Steps>
+            <Step title="Set Up the Slack Trigger">
+
+                - In Zapier, create a new Zap.
+
+                <Frame>
+                    <img src="/images/enterprise/zapier-1.png" alt="Zapier 1" />
+                </Frame>
+
+            </Step>
+
+            <Step title="Choose Slack as your trigger app.">
+
+                <Frame>
+                    <img src="/images/enterprise/zapier-2.png" alt="Zapier 2" />
+                </Frame>
+                - Select `New Pushed Message` as the Trigger Event.
+                - Connect your Slack account if you haven't already.
+
+            </Step>
+
+            <Step title="Configure the CrewAI Enterprise Action">
+
+                - Add a new action step to your Zap.
+                - Choose CrewAI+ as your action app and Kickoff as the Action Event
+
+                <Frame>
+                    <img src="/images/enterprise/zapier-3.png" alt="Zapier 5" />
+                </Frame>
+
+            </Step>
+
+            <Step title="Connect your CrewAI Enterprise account.">
+
+                - Connect your CrewAI Enterprise account.
+                - Select the appropriate Crew for your workflow.
+
+                <Frame>
+                    <img src="/images/enterprise/zapier-4.png" alt="Zapier 6" />
+                </Frame>
+                - Configure the inputs for the Crew using the data from the Slack message.
+            </Step>
+
+            <Step title="Format the CrewAI Enterprise Output">
+
+                - Add another action step to format the text output from CrewAI Enterprise.
+                - Use Zapier's formatting tools to convert the Markdown output to HTML.
+
+                <Frame>
+                    <img src="/images/enterprise/zapier-5.png" alt="Zapier 8" />
+                </Frame>
+                <Frame>
+                    <img src="/images/enterprise/zapier-6.png" alt="Zapier 9" />
+                </Frame>
+
+            </Step>
+
+            <Step title="Send the Output via Email">
+                - Add a final action step to send the formatted output via email.
+                - Choose your preferred email service (e.g., Gmail, Outlook).
+                - Configure the email details, including recipient, subject, and body.
+                - Insert the formatted CrewAI Enterprise output into the email body.
+
+                <Frame>
+                    <img src="/images/enterprise/zapier-7.png" alt="Zapier 7" />
+                </Frame>
+
+            </Step>
+
+            <Step title="Kick Off the crew from Slack">
+
+                - Enter the text in your Slack channel
+
+                <Frame>
+                    <img src="/images/enterprise/zapier-7b.png" alt="Zapier 10" />
+                </Frame>
+
+                - Select the 3 ellipsis button and then chose Push to Zapier
+
+                <Frame>
+                    <img src="/images/enterprise/zapier-8.png" alt="Zapier 11" />
+                </Frame>
+
+            </Step>
+
+            <Step title="Select the crew and then Push to Kick Off">
+
+                <Frame>
+                    <img src="/images/enterprise/zapier-9.png" alt="Zapier 12" />
+                </Frame>
+
+            </Step>
+
+        </Steps>
+
+        **Tips for Success**
+
+        - Ensure that your CrewAI Enterprise inputs are correctly mapped from the Slack message.
+        - Test your Zap thoroughly before turning it on to catch any potential issues.
+        - Consider adding error handling steps to manage potential failures in the workflow.
+
+        By following these steps, you'll have successfully integrated CrewAI Enterprise with Zapier, allowing for automated workflows triggered by Slack messages and resulting in email notifications with CrewAI Enterprise output.
+    </Accordion>
+
+    <Accordion title="How to Integrate CrewAI Enterprise with HubSpot">
+        This guide provides a step-by-step process to integrate CrewAI Enterprise with HubSpot, enabling you to initiate crews directly from HubSpot Workflows.
+
+        **Prerequisites**
+
+            - A CrewAI Enterprise account
+            - A HubSpot account with the [HubSpot Workflows](https://knowledge.hubspot.com/workflows/create-workflows) feature
+
+        **Step-by-Step Guide**
+        <Steps>
+            <Step title="Connect your HubSpot account with CrewAI Enterprise">
+
+                - Log in to your `CrewAI Enterprise account > Integrations`
+                - Select `HubSpot` from the list of available integrations
+                - Choose the HubSpot account you want to integrate with CrewAI Enterprise
+                - Follow the on-screen prompts to authorize CrewAI Enterprise access to your HubSpot account
+                - A confirmation message will appear once HubSpot is successfully linked with CrewAI Enterprise
+
+            </Step>
+            <Step title="Create a HubSpot Workflow">
+
+                - Log in to your `HubSpot account > Automations > Workflows > New workflow`
+                - Select the workflow type that fits your needs (e.g., Start from scratch)
+                - In the workflow builder, click the Plus (+) icon to add a new action.
+                - Choose `Integrated apps > CrewAI > Kickoff a Crew`.
+                - Select the Crew you want to initiate.
+                - Click `Save` to add the action to your workflow
+                <Frame>
+                    <img src="/images/enterprise/hubspot-workflow-1.png" alt="HubSpot Workflow 1" />
+                </Frame>
+
+            </Step>
+            <Step title="Use Crew results with other actions">
+
+                - After the Kickoff a Crew step, click the Plus (+) icon to add a new action.
+                - For example, to send an internal email notification, choose `Communications > Send internal email notification`
+                - In the Body field, click `Insert data`, select `View properties or action outputs from > Action outputs > Crew Result` to include Crew data in the email
+                    <Frame>
+                        <img src="/images/enterprise/hubspot-workflow-2.png" alt="HubSpot Workflow 2" />
+                    </Frame>
+                - Configure any additional actions as needed
+                - Review your workflow steps to ensure everything is set up correctly
+                - Activate the workflow
+                    <Frame>
+                        <img src="/images/enterprise/hubspot-workflow-3.png" alt="HubSpot Workflow 3" />
+                    </Frame>
+
+            </Step>
+        </Steps>
+        For more detailed information on available actions and customization options, refer to the [HubSpot Workflows Documentation](https://knowledge.hubspot.com/workflows/create-workflows).
+    </Accordion>
+
+    <Accordion title="How to connect Azure OpenAI with Crew Studio?">
+        1. In Azure, go to `Azure AI Services > select your deployment > open Azure OpenAI Studio`.
+        2. On the left menu, click `Deployments`. If you don’t have one, create a deployment with your desired model.
+        3. Once created, select your deployment and locate the `Target URI` and `Key` on the right side of the page. Keep this page open, as you’ll need this information.
+            <Frame>
+                <img src="/images/enterprise/azure-openai-studio.png" alt="Azure OpenAI Studio" />
+            </Frame>
+        4. In another tab, open `CrewAI Enterprise > LLM Connections`. Name your LLM Connection, select Azure as the provider, and choose the same model you selected in Azure.
+        5. On the same page, add environment variables from step 3:
+            - One named `AZURE_DEPLOYMENT_TARGET_URL` (using the Target URI). The URL should look like this: https://your-deployment.openai.azure.com/openai/deployments/gpt-4o/chat/completions?api-version=2024-08-01-preview
+            - Another named `AZURE_API_KEY` (using the Key).
+        6. Click `Add Connection` to save your LLM Connection.
+        7. In `CrewAI Enterprise > Settings > Defaults > Crew Studio LLM Settings`, set the new LLM Connection and model as defaults.
+        8. Ensure network access settings:
+            - In Azure, go to `Azure OpenAI > select your deployment`.
+            - Navigate to `Resource Management > Networking`.
+            - Ensure that `Allow access from all networks` is enabled. If this setting is restricted, CrewAI may be blocked from accessing your Azure OpenAI endpoint.
+
+        You're all set! Crew Studio will now use your Azure OpenAI connection.
+    </Accordion>
+
+    <Accordion title="How to use HITL?">
+        Human-in-the-Loop (HITL) Instructions
+        HITL is a powerful approach that combines artificial intelligence with human expertise to enhance decision-making and improve task outcomes. Follow these steps to implement HITL within CrewAI:
+        <Steps>
+            <Step title="Configure Your Task">
+                Set up your task with human input enabled:
+                <Frame>
+                    <img src="/images/enterprise/crew-human-input.png" alt="Crew Human Input" />
+                </Frame>
+            </Step>
+
+            <Step title="Provide Webhook URL">
+                When kicking off your crew, include a webhook URL for human input:
+                <Frame>
+                    <img src="/images/enterprise/crew-webhook-url.png" alt="Crew Webhook URL" />
+                </Frame>
+            </Step>
+
+            <Step title="Receive Webhook Notification">
+                Once the crew completes the task requiring human input, you'll receive a webhook notification containing:
+                    - Execution ID
+                    - Task ID
+                    - Task output
+            </Step>
+
+            <Step title="Review Task Output">
+                The system will pause in the `Pending Human Input` state. Review the task output carefully.
+            </Step>
+
+            <Step title="Submit Human Feedback">
+                Call the resume endpoint of your crew with the following information:
+                <Frame>
+                    <img src="/images/enterprise/crew-resume-endpoint.png" alt="Crew Resume Endpoint" />
+                </Frame>
+                <Warning>
+                    **Feedback Impact on Task Execution**:
+                    It's crucial to exercise care when providing feedback, as the entire feedback content will be incorporated as additional context for further task executions.
+                </Warning>
+                This means:
+                - All information in your feedback becomes part of the task's context.
+                - Irrelevant details may negatively influence it.
+                - Concise, relevant feedback helps maintain task focus and efficiency.
+                - Always review your feedback carefully before submission to ensure it contains only pertinent information that will positively guide the task's execution.
+            </Step>
+            <Step title="Handle Negative Feedback">
+                If you provide negative feedback:
+                - The crew will retry the task with added context from your feedback.
+                - You'll receive another webhook notification for further review.
+                - Repeat steps 4-6 until satisfied.
+            </Step>
+
+            <Step title="Execution Continuation">
+                When you submit positive feedback, the execution will proceed to the next steps.
+            </Step>
+        </Steps>
+    </Accordion>
+
+    <Accordion title="How to configure Salesforce with CrewAI Enterprise">
+        **Salesforce Demo**
+
+        Salesforce is a leading customer relationship management (CRM) platform that helps businesses streamline their sales, service, and marketing operations.
+        <Frame>
+            <iframe width="100%" height="400" src="https://www.youtube.com/embed/oJunVqjjfu4" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+        </Frame>
+    </Accordion>
+
+    <Accordion title="How can you control the maximum number of requests per minute that the entire crew can perform?">
+        The `max_rpm` attribute sets the maximum number of requests per minute the crew can perform to avoid rate limits and will override individual agents' `max_rpm` settings if you set it.
+    </Accordion>
+</AccordionGroup>

docs/guides/crews/first-crew.mdx

@@ -35,7 +35,8 @@ Let's get started building your first crew!
 Before starting, make sure you have:
 
 1. Installed CrewAI following the [installation guide](/installation)
-2. Set up your OpenAI API key in your environment variables
+2. Set up your LLM API key in your environment, following the [LLM setup
+   guide](/concepts/llms#setting-up-your-llm)
 3. Basic understanding of Python
 
 ## Step 1: Create a New CrewAI Project
@@ -92,7 +93,8 @@ For our research crew, we'll create two agents:
 1. A **researcher** who excels at finding and organizing information
 2. An **analyst** who can interpret research findings and create insightful reports
 
-Let's modify the `agents.yaml` file to define these specialized agents:
+Let's modify the `agents.yaml` file to define these specialized agents. Be sure
+to set `llm` to the provider you are using.
 
 ```yaml
 # src/research_crew/config/agents.yaml
@@ -107,7 +109,7 @@ researcher:
     finding relevant information from various sources. You excel at
     organizing information in a clear and structured manner, making
     complex topics accessible to others.
-  llm: openai/gpt-4o-mini
+  llm: provider/model-id  # e.g. openai/gpt-4o, google/gemini-2.0-flash, anthropic/claude...
 
 analyst:
   role: >
@@ -120,7 +122,7 @@ analyst:
     and technical writing. You have a talent for identifying patterns
     and extracting meaningful insights from research data, then
     communicating those insights effectively through well-crafted reports.
-  llm: openai/gpt-4o-mini
+  llm: provider/model-id  # e.g. openai/gpt-4o, google/gemini-2.0-flash, anthropic/claude...
 ```
 
 Notice how each agent has a distinct role, goal, and backstory. These elements aren't just descriptive - they actively shape how the agent approaches its tasks. By crafting these carefully, you can create agents with specialized skills and perspectives that complement each other.
@@ -185,15 +187,20 @@ 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'],
+            config=self.agents_config['researcher'], # type: ignore[index]
             verbose=True,
             tools=[SerperDevTool()]
         )
@@ -201,20 +208,20 @@ class ResearchCrew():
     @agent
     def analyst(self) -> Agent:
         return Agent(
-            config=self.agents_config['analyst'],
+            config=self.agents_config['analyst'], # type: ignore[index]
             verbose=True
         )
 
     @task
     def research_task(self) -> Task:
         return Task(
-            config=self.tasks_config['research_task']
+            config=self.tasks_config['research_task'] # type: ignore[index]
         )
 
     @task
     def analysis_task(self) -> Task:
         return Task(
-            config=self.tasks_config['analysis_task'],
+            config=self.tasks_config['analysis_task'], # type: ignore[index]
             output_file='output/report.md'
         )
 
@@ -277,12 +284,12 @@ This script prepares the environment, specifies our research topic, and kicks of
 
 Create a `.env` file in your project root with your API keys:
 
-```
-OPENAI_API_KEY=your_openai_api_key
+```sh
 SERPER_API_KEY=your_serper_api_key
+# Add your provider's API key here too.
 ```
 
-You can get a Serper API key from [Serper.dev](https://serper.dev/).
+See the [LLM Setup guide](/concepts/llms#setting-up-your-llm) for details on configuring your provider of choice. You can get a Serper API key from [Serper.dev](https://serper.dev/).
 
 ## Step 8: Install Dependencies
 
@@ -387,4 +394,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

@@ -45,7 +45,8 @@ Let's dive in and build your first flow!
 Before starting, make sure you have:
 
 1. Installed CrewAI following the [installation guide](/installation)
-2. Set up your OpenAI API key in your environment variables
+2. Set up your LLM API key in your environment, following the [LLM setup
+   guide](/concepts/llms#setting-up-your-llm)
 3. Basic understanding of Python
 
 ## Step 1: Create a New CrewAI Flow Project
@@ -107,6 +108,8 @@ Now, let's modify the generated files for the content writer crew. We'll set up
 
 1. First, update the agents configuration file to define our content creation team:
 
+   Remember to set `llm` to the provider you are using.
+
 ```yaml
 # src/guide_creator_flow/crews/content_crew/config/agents.yaml
 content_writer:
@@ -119,7 +122,7 @@ content_writer:
     You are a talented educational writer with expertise in creating clear, engaging
     content. You have a gift for explaining complex concepts in accessible language
     and organizing information in a way that helps readers build their understanding.
-  llm: openai/gpt-4o-mini
+  llm: provider/model-id  # e.g. openai/gpt-4o, google/gemini-2.0-flash, anthropic/claude...
 
 content_reviewer:
   role: >
@@ -132,7 +135,7 @@ content_reviewer:
     content. You have an eye for detail, clarity, and coherence. You excel at
     improving content while maintaining the original author's voice and ensuring
     consistent quality across multiple sections.
-  llm: openai/gpt-4o-mini
+  llm: provider/model-id  # e.g. openai/gpt-4o, google/gemini-2.0-flash, anthropic/claude...
 ```
 
 These agent definitions establish the specialized roles and perspectives that will shape how our AI agents approach content creation. Notice how each agent has a distinct purpose and expertise.
@@ -203,35 +206,40 @@ 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'],
+            config=self.agents_config['content_writer'], # type: ignore[index]
             verbose=True
         )
 
     @agent
     def content_reviewer(self) -> Agent:
         return Agent(
-            config=self.agents_config['content_reviewer'],
+            config=self.agents_config['content_reviewer'], # type: ignore[index]
             verbose=True
         )
 
     @task
     def write_section_task(self) -> Task:
         return Task(
-            config=self.tasks_config['write_section_task']
+            config=self.tasks_config['write_section_task'] # type: ignore[index]
         )
 
     @task
     def review_section_task(self) -> Task:
         return Task(
-            config=self.tasks_config['review_section_task'],
+            config=self.tasks_config['review_section_task'], # type: ignore[index]
             context=[self.write_section_task()]
         )
 
@@ -263,6 +271,7 @@ 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
@@ -341,6 +350,9 @@ 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)
@@ -432,10 +444,15 @@ This is the power of flows - combining different types of processing (user inter
 
 ## Step 6: Set Up Your Environment Variables
 
-Create a `.env` file in your project root with your API keys:
+Create a `.env` file in your project root with your API keys. See the [LLM setup
+guide](/concepts/llms#setting-up-your-llm) for details on configuring a provider.
 
-```
+```sh .env
 OPENAI_API_KEY=your_openai_api_key
+# or
+GEMINI_API_KEY=your_gemini_api_key
+# or
+ANTHROPIC_API_KEY=your_anthropic_api_key
 ```
 
 ## Step 7: Install Dependencies
@@ -538,7 +555,10 @@ Let's break down the key components of flows to help you understand how to build
 Flows allow you to make direct calls to language models when you need simple, structured responses:
 
 ```python
-llm = LLM(model="openai/gpt-4o-mini", response_format=GuideOutline)
+llm = LLM(
+    model="model-id-here",  # gpt-4o, gemini-2.0-flash, anthropic/claude...
+    response_format=GuideOutline
+)
 response = llm.call(messages=messages)
 ```
 

docs/how-to/arize-phoenix-observability.mdx

@@ -0,0 +1,145 @@
+---
+title: Arize Phoenix
+description: Arize Phoenix integration for CrewAI with OpenTelemetry and OpenInference
+icon: magnifying-glass-chart
+---
+
+# Arize Phoenix Integration
+
+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.
+
+> **What is Arize Phoenix?** [Arize Phoenix](https://phoenix.arize.com) is an LLM observability platform that provides tracing and evaluation for AI applications.
+
+[![Watch a Video Demo of Our Integration with Phoenix](https://storage.googleapis.com/arize-assets/fixtures/setup_crewai.png)](https://www.youtube.com/watch?v=Yc5q3l6F7Ww)
+
+## Get Started
+
+We'll walk through a simple example of using CrewAI and integrating it with Arize Phoenix via OpenTelemetry using OpenInference.
+
+You can also access this guide on [Google Colab](https://colab.research.google.com/github/Arize-ai/phoenix/blob/main/tutorials/tracing/crewai_tracing_tutorial.ipynb).
+
+### Step 1: Install Dependencies
+
+```bash
+pip install openinference-instrumentation-crewai crewai crewai-tools arize-phoenix-otel
+```
+
+### Step 2: Set Up Environment Variables
+
+Setup Phoenix Cloud API keys and configure OpenTelemetry to send traces to Phoenix. Phoenix Cloud is a hosted version of Arize Phoenix, but it is not required to use this integration.
+
+You can get your free Serper API key [here](https://serper.dev/).
+
+```python
+import os
+from getpass import getpass
+
+# Get your Phoenix Cloud credentials
+PHOENIX_API_KEY = getpass("🔑 Enter your Phoenix Cloud API Key: ")
+
+# Get API keys for services
+OPENAI_API_KEY = getpass("🔑 Enter your OpenAI API key: ")
+SERPER_API_KEY = getpass("🔑 Enter your Serper API key: ")
+
+# Set environment variables
+os.environ["PHOENIX_CLIENT_HEADERS"] = f"api_key={PHOENIX_API_KEY}"
+os.environ["PHOENIX_COLLECTOR_ENDPOINT"] = "https://app.phoenix.arize.com" # Phoenix Cloud, change this to your own endpoint if you are using a self-hosted instance
+os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+os.environ["SERPER_API_KEY"] = SERPER_API_KEY
+```
+
+### Step 3: Initialize OpenTelemetry with Phoenix
+
+Initialize the OpenInference OpenTelemetry instrumentation SDK to start capturing traces and send them to Phoenix. 
+
+```python
+from phoenix.otel import register
+
+tracer_provider = register(
+    project_name="crewai-tracing-demo",
+    auto_instrument=True,
+)
+```
+
+### Step 4: Create a CrewAI Application
+
+We'll create a CrewAI application where two agents collaborate to research and write a blog post about AI advancements.
+
+```python
+from crewai import Agent, Crew, Process, Task
+from crewai_tools import SerperDevTool
+
+search_tool = SerperDevTool()
+
+# Define your agents with roles and goals
+researcher = Agent(
+    role="Senior Research Analyst",
+    goal="Uncover cutting-edge developments in AI and data science",
+    backstory="""You work at a leading tech think tank.
+    Your expertise lies in identifying emerging trends.
+    You have a knack for dissecting complex data and presenting actionable insights.""",
+    verbose=True,
+    allow_delegation=False,
+    # You can pass an optional llm attribute specifying what model you wanna use.
+    # llm=ChatOpenAI(model_name="gpt-3.5", temperature=0.7),
+    tools=[search_tool],
+)
+writer = Agent(
+    role="Tech Content Strategist",
+    goal="Craft compelling content on tech advancements",
+    backstory="""You are a renowned Content Strategist, known for your insightful and engaging articles.
+    You transform complex concepts into compelling narratives.""",
+    verbose=True,
+    allow_delegation=True,
+)
+
+# Create tasks for your agents
+task1 = Task(
+    description="""Conduct a comprehensive analysis of the latest advancements in AI in 2024.
+    Identify key trends, breakthrough technologies, and potential industry impacts.""",
+    expected_output="Full analysis report in bullet points",
+    agent=researcher,
+)
+
+task2 = Task(
+    description="""Using the insights provided, develop an engaging blog
+    post that highlights the most significant AI advancements.
+    Your post should be informative yet accessible, catering to a tech-savvy audience.
+    Make it sound cool, avoid complex words so it doesn't sound like AI.""",
+    expected_output="Full blog post of at least 4 paragraphs",
+    agent=writer,
+)
+
+# Instantiate your crew with a sequential process
+crew = Crew(
+    agents=[researcher, writer], tasks=[task1, task2], verbose=1, process=Process.sequential
+)
+
+# Get your crew to work!
+result = crew.kickoff()
+
+print("######################")
+print(result)
+```
+
+### Step 5: View Traces in Phoenix
+
+After running the agent, you can view the traces generated by your CrewAI application in Phoenix. You should see detailed steps of the agent interactions and LLM calls, which can help you debug and optimize your AI agents.
+
+Log into your Phoenix Cloud account and navigate to the project you specified in the `project_name` parameter. You'll see a timeline view of your trace with all the agent interactions, tool usages, and LLM calls.
+
+![Example trace in Phoenix showing agent interactions](https://storage.googleapis.com/arize-assets/fixtures/crewai_traces.png)
+
+
+### Version Compatibility Information
+- Python 3.8+
+- CrewAI >= 0.86.0
+- Arize Phoenix >= 7.0.1
+- OpenTelemetry SDK >= 1.31.0
+
+
+### References
+- [Phoenix Documentation](https://docs.arize.com/phoenix/) - Overview of the Phoenix platform.
+- [CrewAI Documentation](https://docs.crewai.com/) - Overview of the CrewAI framework.
+- [OpenTelemetry Docs](https://opentelemetry.io/docs/) - OpenTelemetry guide
+- [OpenInference GitHub](https://github.com/openinference/openinference) - Source code for OpenInference SDK.

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

@@ -0,0 +1,443 @@
+---
+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-llm.mdx

@@ -1,9 +1,13 @@
-# Custom LLM Implementations
+---
+title: Custom LLM Implementation
+description: Learn how to create custom LLM implementations in CrewAI.
+icon: code
+---
+
+## 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/how-to/custom-manager-agent.mdx

@@ -1,5 +1,5 @@
 ---
-title: Create Your Own Manager Agent
+title: Custom 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/kickoff-async.mdx

@@ -92,12 +92,14 @@ coding_agent = Agent(
 # Create tasks that require code execution
 task_1 = Task(
     description="Analyze the first dataset and calculate the average age of participants. Ages: {ages}",
-    agent=coding_agent
+    agent=coding_agent,
+    expected_output="The average age of the participants."
 )
 
 task_2 = Task(
     description="Analyze the second dataset and calculate the average age of participants. Ages: {ages}",
-    agent=coding_agent
+    agent=coding_agent,
+    expected_output="The average age of the participants."
 )
 
 # Create two crews and add tasks

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

@@ -20,10 +20,8 @@ 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: