docs(mintlify): remove OpenAPI Endpoints groups; add localized MDX endpoint pages for pt-BR and ko

docs(mintlify): add explicit endpoint MDX pages and include in nav; keep OpenAPI auto-gen as fallback
docs(mintlify): use explicit openapi {source, directory} with absolute paths to fix branch deployment routing
2025-12-16 20:38:29 +00:00 · 2025-08-20 11:23:31 -04:00 · 2025-08-20 11:13:05 -04:00 · 2025-08-20 11:07:09 -04:00 · 2025-08-20 10:51:51 -04:00 · 2025-08-20 09:35:27 -04:00
796 changed files with 103508 additions and 6536 deletions
--- a/.cursorrules
+++ b/.cursorrules
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -7,14 +7,18 @@ permissions:

 env:
  OPENAI_API_KEY: fake-api-key
+  PYTHONUNBUFFERED: 1

 jobs:
  tests:
+    name: tests (${{ matrix.python-version }})
    runs-on: ubuntu-latest
    timeout-minutes: 15
    strategy:
+      fail-fast: true
      matrix:
        python-version: ['3.10', '3.11', '3.12', '3.13']
+        group: [1, 2, 3, 4, 5, 6, 7, 8]
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
@@ -23,6 +27,9 @@ jobs:
        uses: astral-sh/setup-uv@v3
        with:
          enable-cache: true
+          cache-dependency-glob: |
+            **/pyproject.toml
+            **/uv.lock

      - name: Set up Python ${{ matrix.python-version }}
        run: uv python install ${{ matrix.python-version }}
@@ -30,5 +37,14 @@ jobs:
      - name: Install the project
        run: uv sync --dev --all-extras

-      - name: Run tests
-        run: uv run pytest --block-network --timeout=60 -vv
+      - name: Run tests (group ${{ matrix.group }} of 8)
+        run: |
+          uv run pytest \
+            --block-network \
+            --timeout=30 \
+            -vv \
+            --splits 8 \
+            --group ${{ matrix.group }} \
+            --durations=10 \
+            -n auto \
+            --maxfail=3
--- a/.gitignore
+++ b/.gitignore
@@ -21,9 +21,9 @@ crew_tasks_output.json
 .mypy_cache
 .ruff_cache
 .venv
-agentops.log
 test_flow.html
 crewairules.mdc
 plan.md
 conceptual_plan.md
-build_image
+build_image
+chromadb-*.lock
--- a/docs/changelog.mdx
+++ b/docs/changelog.mdx
@@ -1,473 +0,0 @@
---
-title: Changelog
-description: View the latest updates and changes to CrewAI
-icon: timeline
---
-
-<Update label="2024-05-22" description="v0.121.0" tags={["Latest"]}>
-  ## Release Highlights
-  <Frame>
-    <img src="/images/releases/v01210.png" />
-  </Frame>
-  
-  <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
-    <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.121.0">View on GitHub</a>
-  </div>
-
-  **Core Improvements & Fixes**
-  - Fixed encoding error when creating tools
-  - Fixed failing llama test
-  - Updated logging configuration for consistency
-  - Enhanced telemetry initialization and event handling
-
-  **New Features & Enhancements**
-  - Added **markdown attribute** to the Task class
-  - Added **reasoning attribute** to the Agent class
-  - Added **inject_date flag** to Agent for automatic date injection
-  - Implemented **HallucinationGuardrail** (no-op with test coverage)
-
-  **Documentation & Guides**
-  - Added documentation for **StagehandTool** and improved MDX structure
-  - Added documentation for **MCP integration** and updated enterprise docs
-  - Documented knowledge events and updated reasoning docs
-  - Added stop parameter documentation
-  - Fixed import references in doc examples (before_kickoff, after_kickoff)
-  - General docs updates and restructuring for clarity
-</Update>
-
-<Update label="2024-05-15" description="v0.120.1">
-  ## Release Highlights
-  <Frame>
-    <img src="/images/releases/v01201.png" />
-  </Frame>
-  
-  <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
-    <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.120.1">View on GitHub</a>
-  </div>
-
-  **Core Improvements & Fixes**
-  - Fixed **interpolation with hyphens**
-</Update>
-
-<Update label="2024-05-14" description="v0.120.0">
-  ## Release Highlights
-  <Frame>
-    <img src="/images/releases/v01200.png" />
-  </Frame>
-  
-  <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
-    <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.120.0">View on GitHub</a>
-  </div>
-
-  **Core Improvements & Fixes**
-  - Enabled **full Ruff rule set** by default for stricter linting
-  - Addressed race condition in FilteredStream using context managers
-  - Fixed agent knowledge reset issue
-  - Refactored agent fetching logic into utility module
-
-  **New Features & Enhancements**
-  - Added support for **loading an Agent directly from a repository**
-  - Enabled setting an empty context for Task
-  - Enhanced Agent repository feedback and fixed Tool auto-import behavior
-  - Introduced direct initialization of knowledge (bypassing knowledge_sources)
-
-  **Documentation & Guides**
-  - Updated security.md for current security practices
-  - Cleaned up Google setup section for clarity
-  - Added link to AI Studio when entering Gemini key
-  - Updated Arize Phoenix observability guide
-  - Refreshed flow documentation
-</Update>
-
-<Update label="2024-05-08" description="v0.119.0">
-  ## Release Highlights
-  <Frame>
-    <img src="/images/releases/v01190.png" />
-  </Frame>
-  
-  <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
-    <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.119.0">View on GitHub</a>
-  </div>
-
-  **Core Improvements & Fixes**
-  - Improved test reliability by enhancing pytest handling for flaky tests
-  - Fixed memory reset crash when embedding dimensions mismatch
-  - Enabled parent flow identification for Crew and LiteAgent
-  - Prevented telemetry-related crashes when unavailable
-  - Upgraded **LiteLLM version** for better compatibility
-  - Fixed llama converter tests by removing skip_external_api
-
-  **New Features & Enhancements**
-  - Introduced **knowledge retrieval prompt re-writing** in Agent for improved tracking and debugging
-  - Made LLM setup and quickstart guides model-agnostic
-
-  **Documentation & Guides**
-  - Added advanced configuration docs for the RAG tool
-  - Updated Windows troubleshooting guide
-  - Refined documentation examples for better clarity
-  - Fixed typos across docs and config files
-</Update>
-
-<Update label="2024-04-28" description="v0.118.0">
-  ## Release Highlights
-  <Frame>
-    <img src="/images/releases/v01180.png" />
-  </Frame>
-  
-  <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
-    <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.118.0">View on GitHub</a>
-  </div>
-
-  **Core Improvements & Fixes**
-  - Fixed issues with missing prompt or system templates
-  - Removed global logging configuration to avoid unintended overrides
-  - Renamed **TaskGuardrail to LLMGuardrail** for improved clarity
-  - Downgraded litellm to version 1.167.1 for compatibility
-  - Added missing init.py files to ensure proper module initialization
-
-  **New Features & Enhancements**
-  - Added support for **no-code Guardrail creation** to simplify AI behavior controls
-
-  **Documentation & Guides**
-  - Removed CrewStructuredTool from public documentation to reflect internal usage
-  - Updated enterprise documentation and YouTube embed for improved onboarding experience
-</Update>
-
-<Update label="2024-04-20" 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="2024-04-25" 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="2024-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="2024-03-17" description="v0.108.0">
-  ## 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`
-  - Enhanced Event Listener with rich visualization and improved logging
-  - Added fingerprints
-
-  **Bug Fixes**
-  - Fixed Mistral issues
-  - Fixed a bug in documentation
-  - Fixed type check error in fingerprint property
-
-  **Documentation Updates**
-  - Improved tool documentation
-  - Updated installation guide for the `uv` tool package
-  - Added instructions for upgrading crewAI with the `uv` tool
-  - Added documentation for `ApifyActorsTool`
-</Update>
-
-<Update label="2024-03-10" description="v0.105.0">
-  ## Release Highlights
-  <Frame>
-    <img src="/images/releases/v01050.png" />
-  </Frame>
-  
-  <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
-    <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.105.0">View on GitHub</a>
-  </div>
-
-  **Core Improvements & Fixes**
-  - Fixed issues with missing template variables and user memory configuration
-  - Improved async flow support and addressed agent response formatting
-  - Enhanced memory reset functionality and fixed CLI memory commands
-  - Fixed type issues, tool calling properties, and telemetry decoupling
-
-  **New Features & Enhancements**
-  - Added Flow state export and improved state utilities
-  - Enhanced agent knowledge setup with optional crew embedder
-  - Introduced event emitter for better observability and LLM call tracking
-  - Added support for Python 3.10 and ChatOllama from langchain_ollama
-  - Integrated context window size support for the o3-mini model
-  - Added support for multiple router calls
-
-  **Documentation & Guides**
-  - Improved documentation layout and hierarchical structure
-  - Added QdrantVectorSearchTool guide and clarified event listener usage
-  - Fixed typos in prompts and updated Amazon Bedrock model listings
-</Update>
-
-<Update label="2024-02-12" description="v0.102.0">
-  ## Release Highlights
-  <Frame>
-    <img src="/images/releases/v01020.png" />
-  </Frame>
-  
-  <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
-    <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.102.0">View on GitHub</a>
-  </div>
-
-  **Core Improvements & Fixes**
-  - Enhanced LLM Support: Improved structured LLM output, parameter handling, and formatting for Anthropic models
-  - Crew & Agent Stability: Fixed issues with cloning agents/crews using knowledge sources, multiple task outputs in conditional tasks, and ignored Crew task callbacks
-  - Memory & Storage Fixes: Fixed short-term memory handling with Bedrock, ensured correct embedder initialization, and added a reset memories function in the crew class
-  - Training & Execution Reliability: Fixed broken training and interpolation issues with dict and list input types
-
-  **New Features & Enhancements**
-  - Advanced Knowledge Management: Improved naming conventions and enhanced embedding configuration with custom embedder support
-  - Expanded Logging & Observability: Added JSON format support for logging and integrated MLflow tracing documentation
-  - Data Handling Improvements: Updated excel_knowledge_source.py to process multi-tab files
-  - General Performance & Codebase Clean-Up: Streamlined enterprise code alignment and resolved linting issues
-  - Adding new tool: `QdrantVectorSearchTool`
-
-  **Documentation & Guides**
-  - Updated AI & Memory Docs: Improved Bedrock, Google AI, and long-term memory documentation
-  - Task & Workflow Clarity: Added "Human Input" row to Task Attributes, Langfuse guide, and FileWriterTool documentation
-  - Fixed Various Typos & Formatting Issues
-</Update>
-
-<Update label="2024-01-28" description="v0.100.0">
-  ## Release Highlights
-  <Frame>
-    <img src="/images/releases/v01000.png" />
-  </Frame>
-  
-  <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
-    <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.100.0">View on GitHub</a>
-  </div>
-
-  **Features**
-  - Add Composio docs
-  - Add SageMaker as a LLM provider
-  
-  **Fixes**
-  - Overall LLM connection issues
-  - Using safe accessors on training
-  - Add version check to crew_chat.py
-  
-  **Documentation**
-  - New docs for crewai chat
-  - Improve formatting and clarity in CLI and Composio Tool docs
-</Update>
-
-<Update label="2024-01-20" description="v0.98.0">
-  ## Release Highlights
-  <Frame>
-    <img src="/images/releases/v0980.png" />
-  </Frame>
-  
-  <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
-    <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.98.0">View on GitHub</a>
-  </div>
-
-  **Features**
-  - Conversation crew v1
-  - Add unique ID to flow states
-  - Add @persist decorator with FlowPersistence interface
-  
-  **Integrations**
-  - Add SambaNova integration
-  - Add NVIDIA NIM provider in cli
-  - Introducing VoyageAI
-  
-  **Fixes**
-  - Fix API Key Behavior and Entity Handling in Mem0 Integration
-  - Fixed core invoke loop logic and relevant tests
-  - Make tool inputs actual objects and not strings
-  - Add important missing parts to creating tools
-  - Drop litellm version to prevent windows issue
-  - Before kickoff if inputs are none
-  - Fixed typos, nested pydantic model issue, and docling issues
-</Update>
-
-<Update label="2024-01-04" description="v0.95.0">
-  ## Release Highlights
-  <Frame>
-    <img src="/images/releases/v0950.png" />
-  </Frame>
-  
-  <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
-    <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.95.0">View on GitHub</a>
-  </div>
-
-  **New Features**
-  - Adding Multimodal Abilities to Crew
-  - Programatic Guardrails
-  - HITL multiple rounds
-  - Gemini 2.0 Support
-  - CrewAI Flows Improvements
-  - Add Workflow Permissions
-  - Add support for langfuse with litellm
-  - Portkey Integration with CrewAI
-  - Add interpolate_only method and improve error handling
-  - Docling Support
-  - Weviate Support
-  
-  **Fixes**
-  - output_file not respecting system path
-  - disk I/O error when resetting short-term memory
-  - CrewJSONEncoder now accepts enums
-  - Python max version
-  - Interpolation for output_file in Task
-  - Handle coworker role name case/whitespace properly
-  - Add tiktoken as explicit dependency and document Rust requirement
-  - Include agent knowledge in planning process
-  - Change storage initialization to None for KnowledgeStorage
-  - Fix optional storage checks
-  - include event emitter in flows
-  - Docstring, Error Handling, and Type Hints Improvements
-  - Suppressed userWarnings from litellm pydantic issues
-</Update>
-
-<Update label="2024-12-05" description="v0.86.0">
-  ## Release Highlights
-  <Frame>
-    <img src="/images/releases/v0860.png" />
-  </Frame>
-  
-  <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
-    <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.86.0">View on GitHub</a>
-  </div>
-  **Changes**
-  - Remove all references to pipeline and pipeline router
-  - Add Nvidia NIM as provider in Custom LLM
-  - Add knowledge demo + improve knowledge docs
-  - Add HITL multiple rounds of followup
-  - New docs about yaml crew with decorators
-  - Simplify template crew
-</Update>
-
-<Update label="2024-12-04" description="v0.85.0">
-  ## Release Highlights
-  <Frame>
-    <img src="/images/releases/v0850.png" />
-  </Frame>
-  
-  <div style={{ textAlign: 'center', marginBottom: '1rem' }}>
-    <a href="https://github.com/crewAIInc/crewAI/releases/tag/0.85.0">View on GitHub</a>
-  </div>
-  **Features**
-  - Added knowledge to agent level
-  - Feat/remove langchain
-  - Improve typed task outputs
-  - Log in to Tool Repository on crewai login
-  
-  **Fixes**
-  - Fixes issues with result as answer not properly exiting LLM loop
-  - Fix missing key name when running with ollama provider
-  - Fix spelling issue found
-  
-  **Documentation**
-  - Update readme for running mypy
-  - Add knowledge to mint.json
-  - Update Github actions
-  - Update Agents docs to include two approaches for creating an agent
-  - Improvements to LLM Configuration and Usage
-</Update>
-
-<Update label="2024-11-25" description="v0.83.0">
-  **New Features**
-  - New before_kickoff and after_kickoff crew callbacks
-  - Support to pre-seed agents with Knowledge
-  - Add support for retrieving user preferences and memories using Mem0
-  
-  **Fixes**
-  - Fix Async Execution
-  - Upgrade chroma and adjust embedder function generator
-  - Update CLI Watson supported models + docs
-  - Reduce level for Bandit
-  - Fixing all tests
-  
-  **Documentation**
-  - Update Docs
-</Update>
-
-<Update label="2024-11-13" description="v0.80.0">
-  **Fixes**
-  - Fixing Tokens callback replacement bug
-  - Fixing Step callback issue
-  - Add cached prompt tokens info on usage metrics
-  - Fix crew_train_success test
-</Update>
--- a/docs/concepts/training.mdx
+++ b/docs/concepts/training.mdx
@@ -1,67 +0,0 @@
---
-title: Training
-description: Learn how to train your CrewAI agents by giving them feedback early on and get consistent results.
-icon: dumbbell
---
-
-## Overview
-
-The training feature in CrewAI allows you to train your AI agents using the command-line interface (CLI). 
-By running the command `crewai train -n <n_iterations>`, you can specify the number of iterations for the training process.
-
-During training, CrewAI utilizes techniques to optimize the performance of your agents along with human feedback. 
-This helps the agents improve their understanding, decision-making, and problem-solving abilities.
-
-### Training Your Crew Using the CLI
-
-To use the training feature, follow these steps:
-
-1. Open your terminal or command prompt.
-2. Navigate to the directory where your CrewAI project is located.
-3. Run the following command:
-
-```shell
-crewai train -n <n_iterations> <filename> (optional)
-```
-<Tip>
-  Replace `<n_iterations>` with the desired number of training iterations and `<filename>` with the appropriate filename ending with `.pkl`.
-</Tip>
-
-### Training Your Crew Programmatically
-
-To train your crew programmatically, use the following steps:
-
-1. Define the number of iterations for training.
-2. Specify the input parameters for the training process.
-3. Execute the training command within a try-except block to handle potential errors.
-
-```python Code
-n_iterations = 2
-inputs = {"topic": "CrewAI Training"}
-filename = "your_model.pkl"
-
-try:
-    YourCrewName_Crew().crew().train(
-      n_iterations=n_iterations, 
-      inputs=inputs, 
-      filename=filename
-    )
-
-except Exception as e:
-    raise Exception(f"An error occurred while training the crew: {e}")
-```
-
-### Key Points to Note
-
- **Positive Integer Requirement:** Ensure that the number of iterations (`n_iterations`) is a positive integer. The code will raise a `ValueError` if this condition is not met.
- **Filename Requirement:** Ensure that the filename ends with `.pkl`. The code will raise a `ValueError` if this condition is not met.
- **Error Handling:** The code handles subprocess errors and unexpected exceptions, providing error messages to the user.
-
-It is important to note that the training process may take some time, depending on the complexity of your agents and will also require your feedback on each iteration.
-
-Once the training is complete, your agents will be equipped with enhanced capabilities and knowledge, ready to tackle complex tasks and provide more consistent and valuable insights.
-
-Remember to regularly update and retrain your agents to ensure they stay up-to-date with the latest information and advancements in the field.
-
-Happy training with CrewAI! 🚀
-  
--- a/docs/docs.json
+++ b/docs/docs.json
--- a/docs/en/api-reference/inputs.mdx
+++ b/docs/en/api-reference/inputs.mdx
@@ -0,0 +1,7 @@
+---
+title: "GET /inputs"
+description: "Get required inputs for your crew"
+openapi: "/enterprise-api.en.yaml GET /inputs"
+---
+
+
--- a/docs/en/api-reference/introduction.mdx
+++ b/docs/en/api-reference/introduction.mdx
--- a/docs/en/api-reference/kickoff.mdx
+++ b/docs/en/api-reference/kickoff.mdx
@@ -0,0 +1,7 @@
+---
+title: "POST /kickoff"
+description: "Start a crew execution"
+openapi: "/enterprise-api.en.yaml POST /kickoff"
+---
+
+
--- a/docs/en/api-reference/status.mdx
+++ b/docs/en/api-reference/status.mdx
@@ -0,0 +1,7 @@
+---
+title: "GET /status/{kickoff_id}"
+description: "Get execution status"
+openapi: "/enterprise-api.en.yaml GET /status/{kickoff_id}"
+---
+
+
--- a/docs/en/concepts/agents.mdx
+++ b/docs/en/concepts/agents.mdx
@@ -71,7 +71,7 @@ There are two ways to create agents in CrewAI: using **YAML configuration (recom

 Using YAML configuration provides a cleaner, more maintainable way to define agents. We strongly recommend using this approach in your CrewAI projects.

-After creating your CrewAI project as outlined in the [Installation](/installation) section, navigate to the `src/latest_ai_development/config/agents.yaml` file and modify the template to match your requirements.
+After creating your CrewAI project as outlined in the [Installation](/en/installation) section, navigate to the `src/latest_ai_development/config/agents.yaml` file and modify the template to match your requirements.

 <Note>
 Variables in your YAML files (like `{topic}`) will be replaced with values from your inputs when running the crew:
@@ -312,7 +312,7 @@ multimodal_agent = Agent(

 <Note>
 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>

 <Note>
 When using custom templates, you can use variables like `{role}`, `{goal}`, and `{backstory}` in your templates. These will be automatically populated during execution.
@@ -425,7 +425,7 @@ strict_agent = Agent(
 ```python Code
 # Perfect for document processing
 document_processor = Agent(
-    role="Document Analyst", 
+    role="Document Analyst",
    goal="Extract insights from large research papers",
    backstory="Expert at analyzing extensive documentation",
    respect_context_window=True,  # Handle large documents gracefully
@@ -526,6 +526,103 @@ agent = Agent(
 The context window management feature works automatically in the background. You don't need to call any special functions - just set `respect_context_window` to your preferred behavior and CrewAI handles the rest!
 </Note>

+## Direct Agent Interaction with `kickoff()`
+
+Agents can be used directly without going through a task or crew workflow using the `kickoff()` method. This provides a simpler way to interact with an agent when you don't need the full crew orchestration capabilities.
+
+### How `kickoff()` Works
+
+The `kickoff()` method allows you to send messages directly to an agent and get a response, similar to how you would interact with an LLM but with all the agent's capabilities (tools, reasoning, etc.).
+
+```python Code
+from crewai import Agent
+from crewai_tools import SerperDevTool
+
+# Create an agent
+researcher = Agent(
+    role="AI Technology Researcher",
+    goal="Research the latest AI developments",
+    tools=[SerperDevTool()],
+    verbose=True
+)
+
+# Use kickoff() to interact directly with the agent
+result = researcher.kickoff("What are the latest developments in language models?")
+
+# Access the raw response
+print(result.raw)
+```
+
+### Parameters and Return Values
+
+| Parameter         | Type                                | Description                                                               |
+| :---------------- | :---------------------------------- | :------------------------------------------------------------------------ |
+| `messages`        | `Union[str, List[Dict[str, str]]]`  | Either a string query or a list of message dictionaries with role/content |
+| `response_format` | `Optional[Type[Any]]`               | Optional Pydantic model for structured output                             |
+
+The method returns a `LiteAgentOutput` object with the following properties:
+
+- `raw`: String containing the raw output text
+- `pydantic`: Parsed Pydantic model (if a `response_format` was provided)
+- `agent_role`: Role of the agent that produced the output
+- `usage_metrics`: Token usage metrics for the execution
+
+### Structured Output
+
+You can get structured output by providing a Pydantic model as the `response_format`:
+
+```python Code
+from pydantic import BaseModel
+from typing import List
+
+class ResearchFindings(BaseModel):
+    main_points: List[str]
+    key_technologies: List[str]
+    future_predictions: str
+
+# Get structured output
+result = researcher.kickoff(
+    "Summarize the latest developments in AI for 2025",
+    response_format=ResearchFindings
+)
+
+# Access structured data
+print(result.pydantic.main_points)
+print(result.pydantic.future_predictions)
+```
+
+### Multiple Messages
+
+You can also provide a conversation history as a list of message dictionaries:
+
+```python Code
+messages = [
+    {"role": "user", "content": "I need information about large language models"},
+    {"role": "assistant", "content": "I'd be happy to help with that! What specifically would you like to know?"},
+    {"role": "user", "content": "What are the latest developments in 2025?"}
+]
+
+result = researcher.kickoff(messages)
+```
+
+### Async Support
+
+An asynchronous version is available via `kickoff_async()` with the same parameters:
+
+```python Code
+import asyncio
+
+async def main():
+    result = await researcher.kickoff_async("What are the latest developments in AI?")
+    print(result.raw)
+
+asyncio.run(main())
+```
+
+<Note>
+The `kickoff()` method uses a `LiteAgent` internally, which provides a simpler execution flow while preserving all of the agent's configuration (role, goal, backstory, tools, etc.).
+</Note>
+
 ## Important Considerations and Best Practices

 ### Security and Code Execution
--- a/docs/en/concepts/cli.mdx
+++ b/docs/en/concepts/cli.mdx
@@ -4,6 +4,8 @@ description: Learn how to use the CrewAI CLI to interact with CrewAI.
 icon: terminal
 ---

+<Warning>Since release 0.140.0, CrewAI Enterprise started a process of migrating their login provider. As such, the authentication flow via CLI was updated. Users that use Google to login, or that created their account after July 3rd, 2025 will be unable to log in with older versions of the `crewai` library.</Warning>
+
 ## Overview

 The CrewAI CLI provides a set of commands to interact with CrewAI, allowing you to create, train, run, and manage crews & flows.
@@ -86,7 +88,7 @@ crewai replay [OPTIONS]
 - `-t, --task_id TEXT`: Replay the crew from this task ID, including all subsequent tasks

 Example:
-```shell Terminal    
+```shell Terminal
 crewai replay -t task_123456
 ```

@@ -132,7 +134,7 @@ crewai test [OPTIONS]
 - `-m, --model TEXT`: LLM Model to run the tests on the Crew (default: "gpt-4o-mini")

 Example:
-```shell Terminal    
+```shell Terminal
 crewai test -n 5 -m gpt-3.5-turbo
 ```

@@ -149,7 +151,7 @@ Starting from version 0.103.0, the `crewai run` command can be used to run both
 </Note>

 <Note>
-Make sure to run these commands from the directory where your CrewAI project is set up. 
+Make sure to run these commands from the directory where your CrewAI project is set up.
 Some commands may require additional configuration or setup within your project structure.
 </Note>

@@ -186,10 +188,7 @@ def crew(self) -> Crew:
 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:
+    You can login or create an account with:
    ```shell Terminal
    crewai login
    ```
@@ -236,7 +235,7 @@ You must be authenticated to CrewAI Enterprise to use these organization managem
 - **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).

@@ -285,13 +284,13 @@ Watch this video tutorial for a step-by-step demonstration of deploying your cre

 ### 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.
+When running ```crewai create crew``` command, the CLI will show you a list of available LLM providers to choose from, followed by model selection for your chosen provider.

-Once you've selected an LLM provider, you will be prompted for API keys.
+Once you've selected an LLM provider and model, you will be prompted for API keys.

-#### Initial API key providers
+#### Available LLM Providers

-The CLI will initially prompt for API keys for the following services:
+Here's a list of the most popular LLM providers suggested by the CLI:

 * OpenAI
 * Groq
@@ -299,11 +298,11 @@ The CLI will initially prompt for API keys for the following services:
 * Google Gemini
 * SambaNova

-When you select a provider, the CLI will prompt you to enter your API key.
+When you select a provider, the CLI will then show you available models for that provider and prompt you to enter your API key.

 #### Other Options

-If you select option 6, you will be able to select from a list of LiteLLM supported providers.
+If you select "other", you will be able to select from a list of LiteLLM supported providers.

 When you select a provider, the CLI will prompt you to enter the Key name and the API key.

@@ -311,5 +310,81 @@ See the following link for each provider's key name:

 * [LiteLLM Providers](https://docs.litellm.ai/docs/providers)

+### 12. Configuration Management

+Manage CLI configuration settings for CrewAI.

+```shell Terminal
+crewai config [COMMAND] [OPTIONS]
+```
+
+#### Commands:
+
+- `list`: Display all CLI configuration parameters
+```shell Terminal
+crewai config list
+```
+
+- `set`: Set a CLI configuration parameter
+```shell Terminal
+crewai config set <key> <value>
+```
+
+- `reset`: Reset all CLI configuration parameters to default values
+```shell Terminal
+crewai config reset
+```
+
+#### Available Configuration Parameters
+
+- `enterprise_base_url`: Base URL of the CrewAI Enterprise instance
+- `oauth2_provider`: OAuth2 provider used for authentication (e.g., workos, okta, auth0)
+- `oauth2_audience`: OAuth2 audience value, typically used to identify the target API or resource
+- `oauth2_client_id`: OAuth2 client ID issued by the provider, used during authentication requests
+- `oauth2_domain`: OAuth2 provider's domain (e.g., your-org.auth0.com) used for issuing tokens
+
+#### Examples
+
+Display current configuration:
+```shell Terminal
+crewai config list
+```
+
+Example output:
+```
+CrewAI CLI Configuration
+┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+┃ Setting            ┃ Value                              ┃ Description                                                                                      ┃
+┡━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
+│ enterprise_base_url│ https://app.crewai.com             │ Base URL of the CrewAI Enterprise instance                                                       │
+│ org_name           │ Not set                            │ Name of the currently active organization                                                        │
+│ org_uuid           │ Not set                            │ UUID of the currently active organization                                                        │
+│ oauth2_provider    │ workos                             │ OAuth2 provider used for authentication (e.g., workos, okta, auth0).                             │
+│ oauth2_audience    │ client_01YYY                       │ OAuth2 audience value, typically used to identify the target API or resource.                    │
+│ oauth2_client_id   │ client_01XXX                       │ OAuth2 client ID issued by the provider, used during authentication requests.                    │
+│ oauth2_domain      │ login.crewai.com                   │ OAuth2 provider's domain (e.g., your-org.auth0.com) used for issuing tokens.                     │
+```
+
+Set the enterprise base URL:
+```shell Terminal
+crewai config set enterprise_base_url https://my-enterprise.crewai.com
+```
+
+Set OAuth2 provider:
+```shell Terminal
+crewai config set oauth2_provider auth0
+```
+
+Set OAuth2 domain:
+```shell Terminal
+crewai config set oauth2_domain my-company.auth0.com
+```
+
+Reset all configuration to defaults:
+```shell Terminal
+crewai config reset
+```
+
+<Note>
+Configuration settings are stored in `~/.config/crewai/settings.json`. Some settings like organization name and UUID are read-only and managed through authentication and organization commands. Tool repository related settings are hidden and cannot be set directly by users.
+</Note>
--- a/docs/en/concepts/collaboration.mdx
+++ b/docs/en/concepts/collaboration.mdx
--- a/docs/en/concepts/crews.mdx
+++ b/docs/en/concepts/crews.mdx
@@ -20,8 +20,7 @@ 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`.                                                                                                                                                                     |
-| **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.                                                                                                                                                                                             |
+| **Memory** _(optional)_               | `memory`               | Utilized for storing execution memories (short-term, long-term, entity memory).                                                                                                                                                                           |                                                                                                                                                                                       |
 | **Cache** _(optional)_                | `cache`                | Specifies whether to use a cache for storing the results of tools' execution. 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"}`.                                                                                                                                |
 | **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`.                                                               |
@@ -32,6 +31,7 @@ A crew in crewAI represents a collaborative group of agents working together to
 | **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.                                                     |
 | **Planning LLM** *(optional)*         | `planning_llm`         | The language model used by the AgentPlanner in a planning process.                                                                                                                                                                                        |
+| **Knowledge Sources** _(optional)_    | `knowledge_sources`    | Knowledge sources available at the crew level, accessible to all the agents.                                                                                                                                                                                    |

 <Tip>
 **Crew Max RPM**: The `max_rpm` attribute sets the maximum number of requests per minute the crew can perform to avoid rate limits and will override individual agents' `max_rpm` settings if you set it.
@@ -45,7 +45,7 @@ There are two ways to create crews in CrewAI: using **YAML configuration (recomm

 Using YAML configuration provides a cleaner, more maintainable way to define crews and is consistent with how agents and tasks are defined in CrewAI projects.

-After creating your CrewAI project as outlined in the [Installation](/installation) section, you can define your crew in a class that inherits from `CrewBase` and uses decorators to define agents, tasks, and the crew itself.
+After creating your CrewAI project as outlined in the [Installation](/en/installation) section, you can define your crew in a class that inherits from `CrewBase` and uses decorators to define agents, tasks, and the crew itself.

 #### Example Crew Class with Decorators

@@ -66,8 +66,8 @@ class YourCrewName:
    # To see an example agent and task defined in YAML, checkout the following:
    # - Task: https://docs.crewai.com/concepts/tasks#yaml-configuration-recommended
    # - Agents: https://docs.crewai.com/concepts/agents#yaml-configuration-recommended
-    agents_config = 'config/agents.yaml' 
-    tasks_config = 'config/tasks.yaml' 
+    agents_config = 'config/agents.yaml'
+    tasks_config = 'config/tasks.yaml'

    @before_kickoff
    def prepare_inputs(self, inputs):
@@ -111,7 +111,7 @@ class YourCrewName:
    def crew(self) -> Crew:
        return Crew(
            agents=self.agents,  # Automatically collected by the @agent decorator
-            tasks=self.tasks,    # Automatically collected by the @task decorator. 
+            tasks=self.tasks,    # Automatically collected by the @task decorator.
            process=Process.sequential,
            verbose=True,
        )
--- a/docs/en/concepts/event-listener.mdx
+++ b/docs/en/concepts/event-listener.mdx
@@ -177,14 +177,7 @@ class MyCustomCrew:
    # Your crew implementation...
 ```

-This is exactly how CrewAI's built-in `agentops_listener` is registered. In the CrewAI codebase, you'll find:
-
-```python
-# src/crewai/utilities/events/third_party/__init__.py
-from .agentops_listener import agentops_listener
-```
-
-This ensures the `agentops_listener` is loaded when the `crewai.utilities.events` package is imported.
+This is how third-party event listeners are registered in the CrewAI codebase.

 ## Available Event Types

@@ -255,6 +248,17 @@ CrewAI provides a wide range of events that you can listen for:
 - **LLMCallFailedEvent**: Emitted when an LLM call fails
 - **LLMStreamChunkEvent**: Emitted for each chunk received during streaming LLM responses

+### Memory Events
+
+- **MemoryQueryStartedEvent**: Emitted when a memory query is started. Contains the query, limit, and optional score threshold.
+- **MemoryQueryCompletedEvent**: Emitted when a memory query is completed successfully. Contains the query, results, limit, score threshold, and query execution time.
+- **MemoryQueryFailedEvent**: Emitted when a memory query fails. Contains the query, limit, score threshold, and error message.
+- **MemorySaveStartedEvent**: Emitted when a memory save operation is started. Contains the value to be saved, metadata, and optional agent role.
+- **MemorySaveCompletedEvent**: Emitted when a memory save operation is completed successfully. Contains the saved value, metadata, agent role, and save execution time.
+- **MemorySaveFailedEvent**: Emitted when a memory save operation fails. Contains the value, metadata, agent role, and error message.
+- **MemoryRetrievalStartedEvent**: Emitted when memory retrieval for a task prompt starts. Contains the optional task ID.
+- **MemoryRetrievalCompletedEvent**: Emitted when memory retrieval for a task prompt completes successfully. Contains the task ID, memory content, and retrieval execution time.
+
 ## Event Handler Structure

 Each event handler receives two parameters:
@@ -269,77 +273,6 @@ The structure of the event object depends on the event type, but all events inhe

 Additional fields vary by event type. For example, `CrewKickoffCompletedEvent` includes `crew_name` and `output` fields.

-## Real-World Example: Integration with AgentOps
-
-CrewAI includes an example of a third-party integration with [AgentOps](https://github.com/AgentOps-AI/agentops), a monitoring and observability platform for AI agents. Here's how it's implemented:
-
-```python
-from typing import Optional
-
-from crewai.utilities.events import (
-    CrewKickoffCompletedEvent,
-    ToolUsageErrorEvent,
-    ToolUsageStartedEvent,
-)
-from crewai.utilities.events.base_event_listener import BaseEventListener
-from crewai.utilities.events.crew_events import CrewKickoffStartedEvent
-from crewai.utilities.events.task_events import TaskEvaluationEvent
-
-try:
-    import agentops
-    AGENTOPS_INSTALLED = True
-except ImportError:
-    AGENTOPS_INSTALLED = False
-
-class AgentOpsListener(BaseEventListener):
-    tool_event: Optional["agentops.ToolEvent"] = None
-    session: Optional["agentops.Session"] = None
-
-    def __init__(self):
-        super().__init__()
-
-    def setup_listeners(self, crewai_event_bus):
-        if not AGENTOPS_INSTALLED:
-            return
-
-        @crewai_event_bus.on(CrewKickoffStartedEvent)
-        def on_crew_kickoff_started(source, event: CrewKickoffStartedEvent):
-            self.session = agentops.init()
-            for agent in source.agents:
-                if self.session:
-                    self.session.create_agent(
-                        name=agent.role,
-                        agent_id=str(agent.id),
-                    )
-
-        @crewai_event_bus.on(CrewKickoffCompletedEvent)
-        def on_crew_kickoff_completed(source, event: CrewKickoffCompletedEvent):
-            if self.session:
-                self.session.end_session(
-                    end_state="Success",
-                    end_state_reason="Finished Execution",
-                )
-
-        @crewai_event_bus.on(ToolUsageStartedEvent)
-        def on_tool_usage_started(source, event: ToolUsageStartedEvent):
-            self.tool_event = agentops.ToolEvent(name=event.tool_name)
-            if self.session:
-                self.session.record(self.tool_event)
-
-        @crewai_event_bus.on(ToolUsageErrorEvent)
-        def on_tool_usage_error(source, event: ToolUsageErrorEvent):
-            agentops.ErrorEvent(exception=event.error, trigger_event=self.tool_event)
-```
-
-This listener initializes an AgentOps session when a Crew starts, registers agents with AgentOps, tracks tool usage, and ends the session when the Crew completes.
-
-The AgentOps listener is registered in CrewAI's event system through the import in `src/crewai/utilities/events/third_party/__init__.py`:
-
-```python
-from .agentops_listener import agentops_listener
-```
-
-This ensures the `agentops_listener` is loaded when the `crewai.utilities.events` package is imported.

 ## Advanced Usage: Scoped Handlers

--- a/docs/en/concepts/flows.mdx
+++ b/docs/en/concepts/flows.mdx
--- a/docs/en/concepts/knowledge.mdx
+++ b/docs/en/concepts/knowledge.mdx
--- a/docs/en/concepts/llms.mdx
+++ b/docs/en/concepts/llms.mdx
@@ -270,7 +270,7 @@ In this section, you'll find detailed examples that help you select, configure,
    from crewai import LLM

    llm = LLM(
-        model="gemini/gemini-1.5-pro-latest",
+        model="gemini-1.5-pro-latest", # or vertex_ai/gemini-1.5-pro-latest
        temperature=0.7,
        vertex_credentials=vertex_credentials_json
    )
@@ -684,6 +684,28 @@ In this section, you'll find detailed examples that help you select, configure,
      - openrouter/deepseek/deepseek-chat
    </Info>
  </Accordion>
+
+  <Accordion title="Nebius AI Studio">
+    Set the following environment variables in your `.env` file:
+    ```toml Code
+    NEBIUS_API_KEY=<your-api-key>
+    ```
+
+    Example usage in your CrewAI project:
+    ```python Code
+    llm = LLM(
+        model="nebius/Qwen/Qwen3-30B-A3B"
+    )
+    ```
+
+    <Info>
+      Nebius AI Studio features:
+      - Large collection of open source models
+      - Higher rate limits
+      - Competitive pricing
+      - Good balance of speed and quality
+    </Info>
+  </Accordion>
 </AccordionGroup>

 ## Streaming Responses
@@ -727,9 +749,58 @@ CrewAI supports streaming responses from LLMs, allowing your application to rece
    ```

    <Tip>
-      [Click here](https://docs.crewai.com/concepts/event-listener#event-listeners) for more details 
+      [Click here](https://docs.crewai.com/concepts/event-listener#event-listeners) for more details
    </Tip>
  </Tab>
+
+  <Tab title="Agent & Task Tracking">
+    All LLM events in CrewAI include agent and task information, allowing you to track and filter LLM interactions by specific agents or tasks:
+
+    ```python
+    from crewai import LLM, Agent, Task, Crew
+    from crewai.utilities.events import LLMStreamChunkEvent
+    from crewai.utilities.events.base_event_listener import BaseEventListener
+
+    class MyCustomListener(BaseEventListener):
+        def setup_listeners(self, crewai_event_bus):
+            @crewai_event_bus.on(LLMStreamChunkEvent)
+            def on_llm_stream_chunk(source, event):
+                if researcher.id == event.agent_id:
+                    print("\n==============\n Got event:", event, "\n==============\n")
+
+
+    my_listener = MyCustomListener()
+
+    llm = LLM(model="gpt-4o-mini", temperature=0, stream=True)
+
+    researcher = Agent(
+        role="About User",
+        goal="You know everything about the user.",
+        backstory="""You are a master at understanding people and their preferences.""",
+        llm=llm,
+    )
+
+    search = Task(
+        description="Answer the following questions about the user: {question}",
+        expected_output="An answer to the question.",
+        agent=researcher,
+    )
+
+    crew = Crew(agents=[researcher], tasks=[search])
+
+    result = crew.kickoff(
+        inputs={"question": "..."}
+    )
+    ```
+
+    <Info>
+      This feature is particularly useful for:
+      - Debugging specific agent behaviors
+      - Logging LLM usage by task type
+      - Auditing which agents are making what types of LLM calls
+      - Performance monitoring of specific tasks
+    </Info>
+  </Tab>
 </Tabs>

 ## Structured LLM Calls
@@ -825,7 +896,7 @@ Learn how to get the most out of your LLM configuration:
      Remember to regularly monitor your token usage and adjust your configuration as needed to optimize costs and performance.
    </Info>
  </Accordion>
-  
+
  <Accordion title="Drop Additional Parameters">
    CrewAI internally uses Litellm for LLM calls, which allows you to drop additional parameters that are not needed for your specific use case. This can help simplify your code and reduce the complexity of your LLM configuration.
    For example, if you don't need to send the <code>stop</code> parameter, you can simply omit it from your LLM call:
--- a/docs/en/concepts/memory.mdx
+++ b/docs/en/concepts/memory.mdx
@@ -9,8 +9,7 @@ icon: database
 The CrewAI framework provides a sophisticated memory system designed to significantly enhance AI agent capabilities. CrewAI offers **three distinct memory approaches** that serve different use cases:

 1. **Basic Memory System** - Built-in short-term, long-term, and entity memory
-2. **User Memory** - User-specific memory with Mem0 integration (legacy approach)  
-3. **External Memory** - Standalone external memory providers (new approach)
+2. **External Memory** - Standalone external memory providers

 ## Memory System Components

@@ -19,7 +18,7 @@ The CrewAI framework provides a sophisticated memory system designed to signific
 | **Short-Term Memory**| Temporarily stores recent interactions and outcomes using `RAG`, enabling agents to recall and utilize information relevant to their current context during the current executions.|
 | **Long-Term Memory** | Preserves valuable insights and learnings from past executions, allowing agents to build and refine their knowledge over time. |
 | **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. |
+| **Contextual Memory**| Maintains the context of interactions by combining `ShortTermMemory`, `LongTermMemory`, `ExternalMemory` and `EntityMemory`, aiding in the coherence and relevance of agent responses over a sequence of tasks or a conversation. |

 ## 1. Basic Memory System (Recommended)

@@ -62,7 +61,7 @@ By default, CrewAI uses the `appdirs` library to determine storage locations fol
 ```
 ~/Library/Application Support/CrewAI/{project_name}/
 ├── knowledge/           # Knowledge base ChromaDB files
-├── short_term_memory/   # Short-term memory ChromaDB files  
+├── short_term_memory/   # Short-term memory ChromaDB files
 ├── long_term_memory/    # Long-term memory ChromaDB files
 ├── entities/            # Entity memory ChromaDB files
 └── long_term_memory_storage.db  # SQLite database
@@ -202,7 +201,7 @@ crew = Crew(
    tasks=[task],
    memory=True,
    embedder={
-        "provider": "anthropic",  # Match your LLM provider
+        "provider": "anthropic", # Match your LLM provider
        "config": {
            "api_key": "your-anthropic-key",
            "model": "text-embedding-3-small"
@@ -252,7 +251,7 @@ chroma_path = os.path.join(storage_path, "knowledge")
 if os.path.exists(chroma_path):
    client = chromadb.PersistentClient(path=chroma_path)
    collections = client.list_collections()
-    
+
    print("ChromaDB Collections:")
    for collection in collections:
        print(f"  - {collection.name}: {collection.count()} documents")
@@ -269,7 +268,7 @@ crew = Crew(agents=[...], tasks=[...], memory=True)

 # Reset specific memory types
 crew.reset_memories(command_type='short')     # Short-term memory
-crew.reset_memories(command_type='long')      # Long-term memory  
+crew.reset_memories(command_type='long')      # Long-term memory
 crew.reset_memories(command_type='entity')    # Entity memory
 crew.reset_memories(command_type='knowledge') # Knowledge storage
 ```
@@ -540,16 +539,71 @@ crew = Crew(
 )
 ```

+### Mem0 Provider
+
+Short-Term Memory and Entity Memory both supports a tight integration with both Mem0 OSS and Mem0 Client as a provider. Here is how you can use Mem0 as a provider.
+
+```python
+from crewai.memory.short_term.short_term_memory import ShortTermMemory
+from crewai.memory.entity_entity_memory import EntityMemory
+
+mem0_oss_embedder_config = {
+        "provider": "mem0",
+        "config": {
+            "user_id": "john",
+            "local_mem0_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"}}
+            },
+            "infer": True # Optional defaults to True
+        },
+    }
+
+
+mem0_client_embedder_config = {
+        "provider": "mem0",
+        "config": {
+            "user_id": "john",
+            "org_id": "my_org_id",        # Optional
+            "project_id": "my_project_id", # Optional
+            "api_key": "custom-api-key"    # Optional - overrides env var
+            "run_id": "my_run_id",        # Optional - for short-term memory
+            "includes": "include1",       # Optional 
+            "excludes": "exclude1",       # Optional
+            "infer": True                 # Optional defaults to True
+            "custom_categories": new_categories  # Optional - custom categories for user memory
+        },
+    }
+
+
+short_term_memory_mem0_oss = ShortTermMemory(embedder_config=mem0_oss_embedder_config) # Short Term Memory with Mem0 OSS
+short_term_memory_mem0_client = ShortTermMemory(embedder_config=mem0_client_embedder_config) # Short Term Memory with Mem0 Client
+entity_memory_mem0_oss = EntityMemory(embedder_config=mem0_oss_embedder_config) # Entity Memory with Mem0 OSS
+entity_memory_mem0_client = EntityMemory(embedder_config=mem0_client_embedder_config) # Short Term Memory with Mem0 Client
+
+crew = Crew(
+    memory=True,
+    short_term_memory=short_term_memory_mem0_oss, # or short_term_memory_mem0_client
+    entity_memory=entity_memory_mem0_oss # or entity_memory_mem0_client
+)
+```
+
 ### Choosing the Right Embedding Provider

-| Provider | Best For | Pros | Cons |
-|:---------|:----------|:------|:------|
-| **OpenAI** | General use, reliability | High quality, well-tested | Cost, requires API key |
-| **Ollama** | Privacy, cost savings | Free, local, private | Requires local setup |
-| **Google AI** | Google ecosystem | Good performance | Requires Google account |
-| **Azure OpenAI** | Enterprise, compliance | Enterprise features | Complex setup |
-| **Cohere** | Multilingual content | Great language support | Specialized use case |
-| **VoyageAI** | Retrieval tasks | Optimized for search | Newer provider |
+When selecting an embedding provider, consider factors like performance, privacy, cost, and integration needs.  
+Below is a comparison to help you decide:
+
+| Provider       | Best For                       | Pros                              | Cons                      |
+| -------------- | ------------------------------ | --------------------------------- | ------------------------- |
+| **OpenAI**     | General use, high reliability  | High quality, widely tested       | Paid service, API key required |
+| **Ollama**     | Privacy-focused, cost savings  | Free, runs locally, fully private | Requires local installation/setup |
+| **Google AI**  | Integration in Google ecosystem| Strong performance, good support  | Google account required   |
+| **Azure OpenAI** | Enterprise & compliance needs| Enterprise-grade features, security | More complex setup process |
+| **Cohere**     | Multilingual content handling  | Excellent language support        | More niche use cases      |
+| **VoyageAI**   | Information retrieval & search | Optimized for retrieval tasks     | Relatively new provider   |
+| **Mem0**       | Per-user personalization       | Search-optimized embeddings       | Paid service, API key required |
+

 ### Environment Variable Configuration

@@ -596,7 +650,7 @@ providers_to_test = [
    {
        "name": "Ollama",
        "config": {
-            "provider": "ollama", 
+            "provider": "ollama",
            "config": {"model": "mxbai-embed-large"}
        }
    }
@@ -604,7 +658,7 @@ providers_to_test = [

 for provider in providers_to_test:
    print(f"\nTesting {provider['name']} embeddings...")
-    
+
    # Create crew with specific embedder
    crew = Crew(
        agents=[...],
@@ -612,7 +666,7 @@ for provider in providers_to_test:
        memory=True,
        embedder=provider['config']
    )
-    
+
    # Run your test and measure performance
    result = crew.kickoff()
    print(f"{provider['name']} completed successfully")
@@ -623,7 +677,7 @@ for provider in providers_to_test:
 **Model not found errors:**
 ```python
 # Verify model availability
-from crewai.utilities.embedding_configurator import EmbeddingConfigurator
+from crewai.rag.embeddings.configurator import EmbeddingConfigurator

 configurator = EmbeddingConfigurator()
 try:
@@ -655,17 +709,17 @@ import time

 def test_embedding_performance(embedder_config, test_text="This is a test document"):
    start_time = time.time()
-    
+
    crew = Crew(
        agents=[...],
        tasks=[...],
        memory=True,
        embedder=embedder_config
    )
-    
+
    # Simulate memory operation
    crew.kickoff()
-    
+
    end_time = time.time()
    return end_time - start_time

@@ -676,7 +730,7 @@ openai_time = test_embedding_performance({
 })

 ollama_time = test_embedding_performance({
-    "provider": "ollama", 
+    "provider": "ollama",
    "config": {"model": "mxbai-embed-large"}
 })

@@ -684,67 +738,18 @@ print(f"OpenAI: {openai_time:.2f}s")
 print(f"Ollama: {ollama_time:.2f}s")
 ```

-## 2. User Memory with Mem0 (Legacy)
+## 2. External Memory 
+External Memory provides a standalone memory system that operates independently from the crew's built-in memory. This is ideal for specialized memory providers or cross-application memory sharing.

-<Warning>
-**Legacy Approach**: While fully functional, this approach is considered legacy. For new projects requiring user-specific memory, consider using External Memory instead.
-</Warning>
-
-User Memory integrates with [Mem0](https://mem0.ai/) to provide user-specific memory that persists across sessions and integrates with the crew's contextual memory system.
-
-### Prerequisites
-```bash
-pip install mem0ai
-```
-
-### Mem0 Cloud Configuration
+### Basic External Memory with Mem0
 ```python
 import os
-from crewai import Crew, Process
+from crewai import Agent, Crew, Process, Task
+from crewai.memory.external.external_memory import ExternalMemory

-# Set your Mem0 API key
-os.environ["MEM0_API_KEY"] = "m0-your-api-key"
-
-crew = Crew(
-    agents=[...],
-    tasks=[...],
-    memory=True,  # Required for contextual memory integration
-    memory_config={
-        "provider": "mem0",
-        "config": {"user_id": "john"},
-        "user_memory": {}  # Required - triggers user memory initialization
-    },
-    process=Process.sequential,
-    verbose=True
-)
-```
-
-### Advanced Mem0 Configuration
-```python
-crew = Crew(
-    agents=[...],
-    tasks=[...],
-    memory=True,
-    memory_config={
-        "provider": "mem0",
-        "config": {
-            "user_id": "john",
-            "org_id": "my_org_id",        # Optional
-            "project_id": "my_project_id", # Optional
-            "api_key": "custom-api-key"    # Optional - overrides env var
-        },
-        "user_memory": {}
-    }
-)
-```
-
-### Local Mem0 Configuration
-```python
-crew = Crew(
-    agents=[...],
-    tasks=[...],
-    memory=True,
-    memory_config={
+# Create external memory instance with local Mem0 Configuration
+external_memory = ExternalMemory(
+    embedder_config={
        "provider": "mem0",
        "config": {
            "user_id": "john",
@@ -761,37 +766,60 @@ crew = Crew(
                    "provider": "openai",
                    "config": {"api_key": "your-api-key", "model": "text-embedding-3-small"}
                }
-            }
+            },
+            "infer": True # Optional defaults to True
        },
-        "user_memory": {}
-    }
-)
-```
-
-## 3. External Memory (New Approach)
-
-External Memory provides a standalone memory system that operates independently from the crew's built-in memory. This is ideal for specialized memory providers or cross-application memory sharing.
-
-### Basic External Memory with Mem0
-```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"
-
-# Create external memory instance
-external_memory = ExternalMemory(
-    embedder_config={
-        "provider": "mem0", 
-        "config": {"user_id": "U-123"}
    }
 )

 crew = Crew(
    agents=[...],
    tasks=[...],
-    external_memory=external_memory,  # Separate from basic memory
+    external_memory=external_memory, # Separate from basic memory
+    process=Process.sequential,
+    verbose=True
+)
+```
+
+### Advanced External Memory with Mem0 Client
+When using Mem0 Client, you can customize the memory configuration further, by using parameters like 'includes', 'excludes', 'custom_categories', 'infer' and 'run_id' (this is only for short-term memory).
+You can find more details in the [Mem0 documentation](https://docs.mem0.ai/).
+
+```python
+import os
+from crewai import Agent, Crew, Process, Task
+from crewai.memory.external.external_memory import ExternalMemory
+
+new_categories = [
+    {"lifestyle_management_concerns": "Tracks daily routines, habits, hobbies and interests including cooking, time management and work-life balance"},
+    {"seeking_structure": "Documents goals around creating routines, schedules, and organized systems in various life areas"},
+    {"personal_information": "Basic information about the user including name, preferences, and personality traits"}
+]
+
+os.environ["MEM0_API_KEY"] = "your-api-key"
+
+# Create external memory instance with Mem0 Client
+external_memory = ExternalMemory(
+    embedder_config={
+        "provider": "mem0",
+        "config": {
+            "user_id": "john",
+            "org_id": "my_org_id",        # Optional
+            "project_id": "my_project_id", # Optional
+            "api_key": "custom-api-key"    # Optional - overrides env var
+            "run_id": "my_run_id",        # Optional - for short-term memory
+            "includes": "include1",       # Optional 
+            "excludes": "exclude1",       # Optional
+            "infer": True                 # Optional defaults to True
+            "custom_categories": new_categories  # Optional - custom categories for user memory
+        },
+    }
+)
+
+crew = Crew(
+    agents=[...],
+    tasks=[...],
+    external_memory=external_memory, # Separate from basic memory
    process=Process.sequential,
    verbose=True
 )
@@ -808,8 +836,8 @@ class CustomStorage(Storage):

    def save(self, value, metadata=None, agent=None):
        self.memories.append({
-            "value": value, 
-            "metadata": metadata, 
+            "value": value,
+            "metadata": metadata,
            "agent": agent
        })

@@ -830,17 +858,18 @@ crew = Crew(
 )
 ```

-## Memory System Comparison
+## 🧠 Memory System Comparison
+
+| **Category**        | **Feature**            | **Basic Memory**            | **External Memory**         |
+|---------------------|------------------------|-----------------------------|------------------------------|
+| **Ease of Use**     | Setup Complexity       | Simple                      | Moderate                     |
+|                     | Integration            | Built-in (contextual)       | Standalone                   |
+| **Persistence**     | Storage                | Local files                 | Custom / Mem0                |
+|                     | Cross-session Support  | ✅                           | ✅                           |
+| **Personalization** | User-specific Memory   | ❌                          |  ✅                           |
+|                     | Custom Providers       | Limited                     | Any provider                 |
+| **Use Case Fit**    | Recommended For        | Most general use cases      | Specialized / custom needs   |

-| Feature | Basic Memory | User Memory (Legacy) | External Memory |
-|---------|-------------|---------------------|----------------|
-| **Setup Complexity** | Simple | Medium | Medium |
-| **Integration** | Built-in contextual | Contextual + User-specific | Standalone |
-| **Storage** | Local files | Mem0 Cloud/Local | Custom/Mem0 |
-| **Cross-session** | ✅ | ✅ | ✅ |
-| **User-specific** | ❌ | ✅ | ✅ |
-| **Custom providers** | Limited | Mem0 only | Any provider |
-| **Recommended for** | Most use cases | Legacy projects | Specialized needs |

 ## Supported Embedding Providers

@@ -986,7 +1015,201 @@ crew = Crew(
 - 🫡 **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.

+## Memory Events
+
+CrewAI's event system provides powerful insights into memory operations. By leveraging memory events, you can monitor, debug, and optimize your memory system's performance and behavior.
+
+### Available Memory Events
+
+CrewAI emits the following memory-related events:
+
+| Event | Description | Key Properties |
+| :---- | :---------- | :------------- |
+| **MemoryQueryStartedEvent** | Emitted when a memory query begins | `query`, `limit`, `score_threshold` |
+| **MemoryQueryCompletedEvent** | Emitted when a memory query completes successfully | `query`, `results`, `limit`, `score_threshold`, `query_time_ms` |
+| **MemoryQueryFailedEvent** | Emitted when a memory query fails | `query`, `limit`, `score_threshold`, `error` |
+| **MemorySaveStartedEvent** | Emitted when a memory save operation begins | `value`, `metadata`, `agent_role` |
+| **MemorySaveCompletedEvent** | Emitted when a memory save operation completes successfully | `value`, `metadata`, `agent_role`, `save_time_ms` |
+| **MemorySaveFailedEvent** | Emitted when a memory save operation fails | `value`, `metadata`, `agent_role`, `error` |
+| **MemoryRetrievalStartedEvent** | Emitted when memory retrieval for a task prompt starts | `task_id` |
+| **MemoryRetrievalCompletedEvent** | Emitted when memory retrieval completes successfully | `task_id`, `memory_content`, `retrieval_time_ms` |
+
+### Practical Applications
+
+#### 1. Memory Performance Monitoring
+
+Track memory operation timing to optimize your application:
+
+```python
+from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.utilities.events import (
+    MemoryQueryCompletedEvent,
+    MemorySaveCompletedEvent
+)
+import time
+
+class MemoryPerformanceMonitor(BaseEventListener):
+    def __init__(self):
+        super().__init__()
+        self.query_times = []
+        self.save_times = []
+
+    def setup_listeners(self, crewai_event_bus):
+        @crewai_event_bus.on(MemoryQueryCompletedEvent)
+        def on_memory_query_completed(source, event: MemoryQueryCompletedEvent):
+            self.query_times.append(event.query_time_ms)
+            print(f"Memory query completed in {event.query_time_ms:.2f}ms. Query: '{event.query}'")
+            print(f"Average query time: {sum(self.query_times)/len(self.query_times):.2f}ms")
+
+        @crewai_event_bus.on(MemorySaveCompletedEvent)
+        def on_memory_save_completed(source, event: MemorySaveCompletedEvent):
+            self.save_times.append(event.save_time_ms)
+            print(f"Memory save completed in {event.save_time_ms:.2f}ms")
+            print(f"Average save time: {sum(self.save_times)/len(self.save_times):.2f}ms")
+
+# Create an instance of your listener
+memory_monitor = MemoryPerformanceMonitor()
+```
+
+#### 2. Memory Content Logging
+
+Log memory operations for debugging and insights:
+
+```python
+from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.utilities.events import (
+    MemorySaveStartedEvent,
+    MemoryQueryStartedEvent,
+    MemoryRetrievalCompletedEvent
+)
+import logging
+
+# Configure logging
+logger = logging.getLogger('memory_events')
+
+class MemoryLogger(BaseEventListener):
+    def setup_listeners(self, crewai_event_bus):
+        @crewai_event_bus.on(MemorySaveStartedEvent)
+        def on_memory_save_started(source, event: MemorySaveStartedEvent):
+            if event.agent_role:
+                logger.info(f"Agent '{event.agent_role}' saving memory: {event.value[:50]}...")
+            else:
+                logger.info(f"Saving memory: {event.value[:50]}...")
+
+        @crewai_event_bus.on(MemoryQueryStartedEvent)
+        def on_memory_query_started(source, event: MemoryQueryStartedEvent):
+            logger.info(f"Memory query started: '{event.query}' (limit: {event.limit})")
+
+        @crewai_event_bus.on(MemoryRetrievalCompletedEvent)
+        def on_memory_retrieval_completed(source, event: MemoryRetrievalCompletedEvent):
+            if event.task_id:
+                logger.info(f"Memory retrieved for task {event.task_id} in {event.retrieval_time_ms:.2f}ms")
+            else:
+                logger.info(f"Memory retrieved in {event.retrieval_time_ms:.2f}ms")
+            logger.debug(f"Memory content: {event.memory_content}")
+
+# Create an instance of your listener
+memory_logger = MemoryLogger()
+```
+
+#### 3. Error Tracking and Notifications
+
+Capture and respond to memory errors:
+
+```python
+from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.utilities.events import (
+    MemorySaveFailedEvent,
+    MemoryQueryFailedEvent
+)
+import logging
+from typing import Optional
+
+# Configure logging
+logger = logging.getLogger('memory_errors')
+
+class MemoryErrorTracker(BaseEventListener):
+    def __init__(self, notify_email: Optional[str] = None):
+        super().__init__()
+        self.notify_email = notify_email
+        self.error_count = 0
+
+    def setup_listeners(self, crewai_event_bus):
+        @crewai_event_bus.on(MemorySaveFailedEvent)
+        def on_memory_save_failed(source, event: MemorySaveFailedEvent):
+            self.error_count += 1
+            agent_info = f"Agent '{event.agent_role}'" if event.agent_role else "Unknown agent"
+            error_message = f"Memory save failed: {event.error}. {agent_info}"
+            logger.error(error_message)
+
+            if self.notify_email and self.error_count % 5 == 0:
+                self._send_notification(error_message)
+
+        @crewai_event_bus.on(MemoryQueryFailedEvent)
+        def on_memory_query_failed(source, event: MemoryQueryFailedEvent):
+            self.error_count += 1
+            error_message = f"Memory query failed: {event.error}. Query: '{event.query}'"
+            logger.error(error_message)
+
+            if self.notify_email and self.error_count % 5 == 0:
+                self._send_notification(error_message)
+
+    def _send_notification(self, message):
+        # Implement your notification system (email, Slack, etc.)
+        print(f"[NOTIFICATION] Would send to {self.notify_email}: {message}")
+
+# Create an instance of your listener
+error_tracker = MemoryErrorTracker(notify_email="admin@example.com")
+```
+
+### Integrating with Analytics Platforms
+
+Memory events can be forwarded to analytics and monitoring platforms to track performance metrics, detect anomalies, and visualize memory usage patterns:
+
+```python
+from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.utilities.events import (
+    MemoryQueryCompletedEvent,
+    MemorySaveCompletedEvent
+)
+
+class MemoryAnalyticsForwarder(BaseEventListener):
+    def __init__(self, analytics_client):
+        super().__init__()
+        self.client = analytics_client
+
+    def setup_listeners(self, crewai_event_bus):
+        @crewai_event_bus.on(MemoryQueryCompletedEvent)
+        def on_memory_query_completed(source, event: MemoryQueryCompletedEvent):
+            # Forward query metrics to analytics platform
+            self.client.track_metric({
+                "event_type": "memory_query",
+                "query": event.query,
+                "duration_ms": event.query_time_ms,
+                "result_count": len(event.results) if hasattr(event.results, "__len__") else 0,
+                "timestamp": event.timestamp
+            })
+
+        @crewai_event_bus.on(MemorySaveCompletedEvent)
+        def on_memory_save_completed(source, event: MemorySaveCompletedEvent):
+            # Forward save metrics to analytics platform
+            self.client.track_metric({
+                "event_type": "memory_save",
+                "agent_role": event.agent_role,
+                "duration_ms": event.save_time_ms,
+                "timestamp": event.timestamp
+            })
+```
+
+### Best Practices for Memory Event Listeners
+
+1. **Keep handlers lightweight**: Avoid complex processing in event handlers to prevent performance impacts
+2. **Use appropriate logging levels**: Use INFO for normal operations, DEBUG for details, ERROR for issues
+3. **Batch metrics when possible**: Accumulate metrics before sending to external systems
+4. **Handle exceptions gracefully**: Ensure your event handlers don't crash due to unexpected data
+5. **Consider memory consumption**: Be mindful of storing large amounts of event data
+
 ## Conclusion

-Integrating CrewAI's memory system into your projects is straightforward. By leveraging the provided memory components and configurations, 
+Integrating CrewAI's memory system into your projects is straightforward. By leveraging the provided memory components and configurations,
 you can quickly empower your agents with the ability to remember, reason, and learn from their interactions, unlocking new levels of intelligence and capability.
--- a/docs/en/concepts/planning.mdx
+++ b/docs/en/concepts/planning.mdx
--- a/docs/en/concepts/processes.mdx
+++ b/docs/en/concepts/processes.mdx
--- a/docs/en/concepts/reasoning.mdx
+++ b/docs/en/concepts/reasoning.mdx
--- a/docs/en/concepts/tasks.mdx
+++ b/docs/en/concepts/tasks.mdx
@@ -54,9 +54,11 @@ crew = Crew(
 | **Markdown** _(optional)_        | `markdown`        | `Optional[bool]`              | Whether the task should instruct the agent to return the final answer formatted in Markdown. Defaults to False.      |
 | **Config** _(optional)_          | `config`          | `Optional[Dict[str, Any]]`    | Task-specific configuration parameters.                                                                              |
 | **Output File** _(optional)_     | `output_file`     | `Optional[str]`               | File path for storing the task output.                                                                               |
+| **Create Directory** _(optional)_ | `create_directory` | `Optional[bool]`             | Whether to create the directory for output_file if it doesn't exist. Defaults to True.                               |
 | **Output JSON** _(optional)_     | `output_json`     | `Optional[Type[BaseModel]]`   | A Pydantic model to structure the JSON output.                                                                       |
 | **Output Pydantic** _(optional)_ | `output_pydantic` | `Optional[Type[BaseModel]]`   | A Pydantic model for task output.                                                                                    |
 | **Callback** _(optional)_        | `callback`        | `Optional[Any]`               | Function/object to be executed after task completion.                                                                |
+| **Guardrail** _(optional)_       | `guardrail`       | `Optional[Callable]`             | Function to validate task output before proceeding to next task.                                                  |

 ## Creating Tasks

@@ -66,7 +68,7 @@ There are two ways to create tasks in CrewAI: using **YAML configuration (recomm

 Using YAML configuration provides a cleaner, more maintainable way to define tasks. We strongly recommend using this approach to define tasks in your CrewAI projects.

-After creating your CrewAI project as outlined in the [Installation](/installation) section, navigate to the `src/latest_ai_development/config/tasks.yaml` file and modify the template to match your specific task requirements.
+After creating your CrewAI project as outlined in the [Installation](/en/installation) section, navigate to the `src/latest_ai_development/config/tasks.yaml` file and modify the template to match your specific task requirements.

 <Note>
 Variables in your YAML files (like `{topic}`) will be replaced with values from your inputs when running the crew:
@@ -277,7 +279,7 @@ formatted_task = Task(

 When `markdown=True`, the agent will receive additional instructions to format the output using:
 - `#` for headers
- `**text**` for bold text  
+- `**text**` for bold text
 - `*text*` for italic text
 - `-` or `*` for bullet points
 - `` `code` `` for inline code
@@ -332,9 +334,11 @@ Task guardrails provide a way to validate and transform task outputs before they
 are passed to the next task. This feature helps ensure data quality and provides
 feedback to agents when their output doesn't meet specific criteria.

-### Using Task Guardrails
+Guardrails are implemented as Python functions that contain custom validation logic, giving you complete control over the validation process and ensuring reliable, deterministic results.

-To add a guardrail to a task, provide a validation function through the `guardrail` parameter:
+### Function-Based Guardrails
+
+To add a function-based guardrail to a task, provide a validation function through the `guardrail` parameter:

 ```python Code
 from typing import Tuple, Union, Dict, Any
@@ -372,9 +376,7 @@ blog_task = Task(
   - 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

@@ -798,184 +800,91 @@ While creating and executing tasks, certain validation mechanisms are in place t

 These validations help in maintaining the consistency and reliability of task executions within the crewAI framework.

-## Task Guardrails

-Task guardrails provide a powerful way to validate, transform, or filter task outputs before they are passed to the next task. Guardrails are optional functions that execute before the next task starts, allowing you to ensure that task outputs meet specific requirements or formats.
-
-### Basic Usage
-
-#### Define your own logic to validate
-
-```python Code
-from typing import Tuple, Union
-from crewai import Task
-
-def validate_json_output(result: str) -> Tuple[bool, Union[dict, str]]:
-    """Validate that the output is valid JSON."""
-    try:
-        json_data = json.loads(result)
-        return (True, json_data)
-    except json.JSONDecodeError:
-        return (False, "Output must be valid JSON")
-
-task = Task(
-    description="Generate JSON data",
-    expected_output="Valid JSON object",
-    guardrail=validate_json_output
-)
-```
-
-#### 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.
-2. **Execution Timing**: The guardrail function is executed before the next task starts, ensuring valid data flow between tasks.
-3. **Return Format**: Guardrails must return a tuple of `(success, data)`:
-   - If `success` is `True`, `data` is the validated/transformed result
-   - If `success` is `False`, `data` is the error message
-4. **Result Routing**:
-   - On success (`True`), the result is automatically passed to the next task
-   - On failure (`False`), the error is sent back to the agent to generate a new answer
-
-### Common Use Cases
-
-#### Data Format Validation
-```python Code
-def validate_email_format(result: str) -> Tuple[bool, Union[str, str]]:
-    """Ensure the output contains a valid email address."""
-    import re
-    email_pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$'
-    if re.match(email_pattern, result.strip()):
-        return (True, result.strip())
-    return (False, "Output must be a valid email address")
-```
-
-#### Content Filtering
-```python Code
-def filter_sensitive_info(result: str) -> Tuple[bool, Union[str, str]]:
-    """Remove or validate sensitive information."""
-    sensitive_patterns = ['SSN:', 'password:', 'secret:']
-    for pattern in sensitive_patterns:
-        if pattern.lower() in result.lower():
-            return (False, f"Output contains sensitive information ({pattern})")
-    return (True, result)
-```
-
-#### Data Transformation
-```python Code
-def normalize_phone_number(result: str) -> Tuple[bool, Union[str, str]]:
-    """Ensure phone numbers are in a consistent format."""
-    import re
-    digits = re.sub(r'\D', '', result)
-    if len(digits) == 10:
-        formatted = f"({digits[:3]}) {digits[3:6]}-{digits[6:]}"
-        return (True, formatted)
-    return (False, "Output must be a 10-digit phone number")
-```
-
-### Advanced Features
-
-#### Chaining Multiple Validations
-```python Code
-def chain_validations(*validators):
-    """Chain multiple validators together."""
-    def combined_validator(result):
-        for validator in validators:
-            success, data = validator(result)
-            if not success:
-                return (False, data)
-            result = data
-        return (True, result)
-    return combined_validator
-
-# Usage
-task = Task(
-    description="Get user contact info",
-    expected_output="Email and phone",
-    guardrail=chain_validations(
-        validate_email_format,
-        filter_sensitive_info
-    )
-)
-```
-
-#### Custom Retry Logic
-```python Code
-task = Task(
-    description="Generate data",
-    expected_output="Valid data",
-    guardrail=validate_data,
-    max_retries=5  # Override default retry limit
-)
-```

 ## Creating Directories when Saving Files

-You can now specify if a task should create directories when saving its output to a file. This is particularly useful for organizing outputs and ensuring that file paths are correctly structured.
+The `create_directory` parameter controls whether CrewAI should automatically create directories when saving task outputs to files. This feature is particularly useful for organizing outputs and ensuring that file paths are correctly structured, especially when working with complex project hierarchies.
+
+### Default Behavior
+
+By default, `create_directory=True`, which means CrewAI will automatically create any missing directories in the output file path:

 ```python Code
-# ...
-
-save_output_task = Task(
-    description='Save the summarized AI news to a file',
-    expected_output='File saved successfully',
-    agent=research_agent,
-    tools=[file_save_tool],
-    output_file='outputs/ai_news_summary.txt',
-    create_directory=True
+# Default behavior - directories are created automatically
+report_task = Task(
+    description='Generate a comprehensive market analysis report',
+    expected_output='A detailed market analysis with charts and insights',
+    agent=analyst_agent,
+    output_file='reports/2025/market_analysis.md',  # Creates 'reports/2025/' if it doesn't exist
+    markdown=True
 )
+```

-#...
+### Disabling Directory Creation
+
+If you want to prevent automatic directory creation and ensure that the directory already exists, set `create_directory=False`:
+
+```python Code
+# Strict mode - directory must already exist
+strict_output_task = Task(
+    description='Save critical data that requires existing infrastructure',
+    expected_output='Data saved to pre-configured location',
+    agent=data_agent,
+    output_file='secure/vault/critical_data.json',
+    create_directory=False  # Will raise RuntimeError if 'secure/vault/' doesn't exist
+)
+```
+
+### YAML Configuration
+
+You can also configure this behavior in your YAML task definitions:
+
+```yaml tasks.yaml
+analysis_task:
+  description: >
+    Generate quarterly financial analysis
+  expected_output: >
+    A comprehensive financial report with quarterly insights
+  agent: financial_analyst
+  output_file: reports/quarterly/q4_2024_analysis.pdf
+  create_directory: true  # Automatically create 'reports/quarterly/' directory
+
+audit_task:
+  description: >
+    Perform compliance audit and save to existing audit directory
+  expected_output: >
+    A compliance audit report
+  agent: auditor
+  output_file: audit/compliance_report.md
+  create_directory: false  # Directory must already exist
+```
+
+### Use Cases
+
+**Automatic Directory Creation (`create_directory=True`):**
+- Development and prototyping environments
+- Dynamic report generation with date-based folders
+- Automated workflows where directory structure may vary
+- Multi-tenant applications with user-specific folders
+
+**Manual Directory Management (`create_directory=False`):**
+- Production environments with strict file system controls
+- Security-sensitive applications where directories must be pre-configured
+- Systems with specific permission requirements
+- Compliance environments where directory creation is audited
+
+### Error Handling
+
+When `create_directory=False` and the directory doesn't exist, CrewAI will raise a `RuntimeError`:
+
+```python Code
+try:
+    result = crew.kickoff()
+except RuntimeError as e:
+    # Handle missing directory error
+    print(f"Directory creation failed: {e}")
+    # Create directory manually or use fallback location
 ```

 Check out the video below to see how to use structured outputs in CrewAI:
--- a/docs/en/concepts/testing.mdx
+++ b/docs/en/concepts/testing.mdx
--- a/docs/en/concepts/tools.mdx
+++ b/docs/en/concepts/tools.mdx
--- a/docs/en/concepts/training.mdx
+++ b/docs/en/concepts/training.mdx
@@ -0,0 +1,196 @@
+---
+title: Training
+description: Learn how to train your CrewAI agents by giving them feedback early on and get consistent results.
+icon: dumbbell
+---
+
+## Overview
+
+The training feature in CrewAI allows you to train your AI agents using the command-line interface (CLI).
+By running the command `crewai train -n <n_iterations>`, you can specify the number of iterations for the training process.
+
+During training, CrewAI utilizes techniques to optimize the performance of your agents along with human feedback.
+This helps the agents improve their understanding, decision-making, and problem-solving abilities.
+
+### Training Your Crew Using the CLI
+
+To use the training feature, follow these steps:
+
+1. Open your terminal or command prompt.
+2. Navigate to the directory where your CrewAI project is located.
+3. Run the following command:
+
+```shell
+crewai train -n <n_iterations> -f <filename.pkl>
+```
+<Tip>
+  Replace `<n_iterations>` with the desired number of training iterations and `<filename>` with the appropriate filename ending with `.pkl`.
+</Tip>
+
+<Note>
+  If you omit `-f`, the output defaults to `trained_agents_data.pkl` in the current working directory. You can pass an absolute path to control where the file is written.
+</Note>
+
+### Training your Crew programmatically
+
+To train your crew programmatically, use the following steps:
+
+1. Define the number of iterations for training.
+2. Specify the input parameters for the training process.
+3. Execute the training command within a try-except block to handle potential errors.
+
+```python Code
+n_iterations = 2
+inputs = {"topic": "CrewAI Training"}
+filename = "your_model.pkl"
+
+try:
+    YourCrewName_Crew().crew().train(
+      n_iterations=n_iterations,
+      inputs=inputs,
+      filename=filename
+    )
+
+except Exception as e:
+    raise Exception(f"An error occurred while training the crew: {e}")
+```
+
+## How trained data is used by agents
+
+CrewAI uses the training artifacts in two ways: during training to incorporate your human feedback, and after training to guide agents with consolidated suggestions.
+
+### Training data flow
+
+```mermaid
+flowchart TD
+  A["Start training<br/>CLI: crewai train -n -f<br/>or Python: crew.train(...)"] --> B["Setup training mode<br/>- task.human_input = true<br/>- disable delegation<br/>- init training_data.pkl + trained file"]
+
+  subgraph "Iterations"
+    direction LR
+    C["Iteration i<br/>initial_output"] --> D["User human_feedback"]
+    D --> E["improved_output"]
+    E --> F["Append to training_data.pkl<br/>by agent_id and iteration"]
+  end
+
+  B --> C
+  F --> G{"More iterations?"}
+  G -- "Yes" --> C
+  G -- "No" --> H["Evaluate per agent<br/>aggregate iterations"]
+
+  H --> I["Consolidate<br/>suggestions[] + quality + final_summary"]
+  I --> J["Save by agent role to trained file<br/>(default: trained_agents_data.pkl)"]
+
+  J --> K["Normal (non-training) runs"]
+  K --> L["Auto-load suggestions<br/>from trained_agents_data.pkl"]
+  L --> M["Append to prompt<br/>for consistent improvements"]
+```
+
+### During training runs
+
+- On each iteration, the system records for every agent:
+  - `initial_output`: the agent’s first answer
+  - `human_feedback`: your inline feedback when prompted
+  - `improved_output`: the agent’s follow-up answer after feedback
+- This data is stored in a working file named `training_data.pkl` keyed by the agent’s internal ID and iteration.
+- While training is active, the agent automatically appends your prior human feedback to its prompt to enforce those instructions on subsequent attempts within the training session.
+  Training is interactive: tasks set `human_input = true`, so running in a non-interactive environment will block on user input.
+
+### After training completes
+
+- When `train(...)` finishes, CrewAI evaluates the collected training data per agent and produces a consolidated result containing:
+  - `suggestions`: clear, actionable instructions distilled from your feedback and the difference between initial/improved outputs
+  - `quality`: a 0–10 score capturing improvement
+  - `final_summary`: a step-by-step set of action items for future tasks
+- These consolidated results are saved to the filename you pass to `train(...)` (default via CLI is `trained_agents_data.pkl`). Entries are keyed by the agent’s `role` so they can be applied across sessions.
+- During normal (non-training) execution, each agent automatically loads its consolidated `suggestions` and appends them to the task prompt as mandatory instructions. This gives you consistent improvements without changing your agent definitions.
+
+### File summary
+
+- `training_data.pkl` (ephemeral, per-session):
+  - Structure: `agent_id -> { iteration_number: { initial_output, human_feedback, improved_output } }`
+  - Purpose: capture raw data and human feedback during training
+  - Location: saved in the current working directory (CWD)
+- `trained_agents_data.pkl` (or your custom filename):
+  - Structure: `agent_role -> { suggestions: string[], quality: number, final_summary: string }`
+  - Purpose: persist consolidated guidance for future runs
+  - Location: written to the CWD by default; use `-f` to set a custom (including absolute) path
+
+## Small Language Model Considerations
+
+<Warning>
+  When using smaller language models (≤7B parameters) for training data evaluation, be aware that they may face challenges with generating structured outputs and following complex instructions.
+</Warning>
+
+### Limitations of Small Models in Training Evaluation
+
+<CardGroup cols={2}>
+  <Card title="JSON Output Accuracy" icon="triangle-exclamation">
+    Smaller models often struggle with producing valid JSON responses needed for structured training evaluations, leading to parsing errors and incomplete data.
+  </Card>
+  <Card title="Evaluation Quality" icon="chart-line">
+    Models under 7B parameters may provide less nuanced evaluations with limited reasoning depth compared to larger models.
+  </Card>
+  <Card title="Instruction Following" icon="list-check">
+    Complex training evaluation criteria may not be fully followed or considered by smaller models.
+  </Card>
+  <Card title="Consistency" icon="rotate">
+    Evaluations across multiple training iterations may lack consistency with smaller models.
+  </Card>
+</CardGroup>
+
+### Recommendations for Training
+
+<Tabs>
+  <Tab title="Best Practice">
+    For optimal training quality and reliable evaluations, we strongly recommend using models with at least 7B parameters or larger:
+
+    ```python
+    from crewai import Agent, Crew, Task, LLM
+
+    # Recommended minimum for training evaluation
+    llm = LLM(model="mistral/open-mistral-7b")
+
+    # Better options for reliable training evaluation
+    llm = LLM(model="anthropic/claude-3-sonnet-20240229-v1:0")
+    llm = LLM(model="gpt-4o")
+
+    # Use this LLM with your agents
+    agent = Agent(
+        role="Training Evaluator",
+        goal="Provide accurate training feedback",
+        llm=llm
+    )
+    ```
+
+    <Tip>
+      More powerful models provide higher quality feedback with better reasoning, leading to more effective training iterations.
+    </Tip>
+  </Tab>
+  <Tab title="Small Model Usage">
+    If you must use smaller models for training evaluation, be aware of these constraints:
+
+    ```python
+    # Using a smaller model (expect some limitations)
+    llm = LLM(model="huggingface/microsoft/Phi-3-mini-4k-instruct")
+    ```
+
+    <Warning>
+      While CrewAI includes optimizations for small models, expect less reliable and less nuanced evaluation results that may require more human intervention during training.
+    </Warning>
+  </Tab>
+</Tabs>
+
+### Key Points to Note
+
+- **Positive Integer Requirement:** Ensure that the number of iterations (`n_iterations`) is a positive integer. The code will raise a `ValueError` if this condition is not met.
+- **Filename Requirement:** Ensure that the filename ends with `.pkl`. The code will raise a `ValueError` if this condition is not met.
+- **Error Handling:** The code handles subprocess errors and unexpected exceptions, providing error messages to the user.
+- Trained guidance is applied at prompt time; it does not modify your Python/YAML agent configuration.
+- Agents automatically load trained suggestions from a file named `trained_agents_data.pkl` located in the current working directory. If you trained to a different filename, either rename it to `trained_agents_data.pkl` before running, or adjust the loader in code.
+- You can change the output filename when calling `crewai train` with `-f/--filename`. Absolute paths are supported if you want to save outside the CWD.
+
+It is important to note that the training process may take some time, depending on the complexity of your agents and will also require your feedback on each iteration.
+
+Once the training is complete, your agents will be equipped with enhanced capabilities and knowledge, ready to tackle complex tasks and provide more consistent and valuable insights.
+
+Remember to regularly update and retrain your agents to ensure they stay up-to-date with the latest information and advancements in the field.
--- a/docs/en/enterprise/features/agent-repositories.mdx
+++ b/docs/en/enterprise/features/agent-repositories.mdx
@@ -0,0 +1,155 @@
+---
+title: 'Agent Repositories'
+description: 'Learn how to use Agent Repositories to share and reuse your agents across teams and projects'
+icon: 'database'
+---
+
+Agent Repositories allow enterprise users to store, share, and reuse agent definitions across teams and projects. This feature enables organizations to maintain a centralized library of standardized agents, promoting consistency and reducing duplication of effort.
+
+## Benefits of Agent Repositories
+
+- **Standardization**: Maintain consistent agent definitions across your organization
+- **Reusability**: Create an agent once and use it in multiple crews and projects
+- **Governance**: Implement organization-wide policies for agent configurations
+- **Collaboration**: Enable teams to share and build upon each other's work
+
+## Using Agent Repositories
+
+### Prerequisites
+
+1. You must have an account at CrewAI, try the [free plan](https://app.crewai.com).
+2. You need to be authenticated using the CrewAI CLI.
+3. If you have more than one organization, make sure you are switched to the correct organization using the CLI command:
+
+```bash
+crewai org switch <org_id>
+```
+
+### Creating and Managing Agents in Repositories
+
+To create and manage agents in repositories,Enterprise Dashboard.
+
+### Loading Agents from Repositories
+
+You can load agents from repositories in your code using the `from_repository` parameter:
+
+```python
+from crewai import Agent
+
+# Create an agent by loading it from a repository
+# The agent is loaded with all its predefined configurations
+researcher = Agent(
+    from_repository="market-research-agent"
+)
+
+```
+
+### Overriding Repository Settings
+
+You can override specific settings from the repository by providing them in the configuration:
+
+```python
+researcher = Agent(
+    from_repository="market-research-agent",
+    goal="Research the latest trends in AI development",  # Override the repository goal
+    verbose=True  # Add a setting not in the repository
+)
+```
+
+### Example: Creating a Crew with Repository Agents
+
+```python
+from crewai import Crew, Agent, Task
+
+# Load agents from repositories
+researcher = Agent(
+    from_repository="market-research-agent"
+)
+
+writer = Agent(
+    from_repository="content-writer-agent"
+)
+
+# Create tasks
+research_task = Task(
+    description="Research the latest trends in AI",
+    agent=researcher
+)
+
+writing_task = Task(
+    description="Write a comprehensive report based on the research",
+    agent=writer
+)
+
+# Create the crew
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[research_task, writing_task],
+    verbose=True
+)
+
+# Run the crew
+result = crew.kickoff()
+```
+
+### Example: Using `kickoff()` with Repository Agents
+
+You can also use repository agents directly with the `kickoff()` method for simpler interactions:
+
+```python
+from crewai import Agent
+from pydantic import BaseModel
+from typing import List
+
+# Define a structured output format
+class MarketAnalysis(BaseModel):
+    key_trends: List[str]
+    opportunities: List[str]
+    recommendation: str
+
+# Load an agent from repository
+analyst = Agent(
+    from_repository="market-analyst-agent",
+    verbose=True
+)
+
+# Get a free-form response
+result = analyst.kickoff("Analyze the AI market in 2025")
+print(result.raw)  # Access the raw response
+
+# Get structured output
+structured_result = analyst.kickoff(
+    "Provide a structured analysis of the AI market in 2025",
+    response_format=MarketAnalysis
+)
+
+# Access structured data
+print(f"Key Trends: {structured_result.pydantic.key_trends}")
+print(f"Recommendation: {structured_result.pydantic.recommendation}")
+```
+
+## Best Practices
+
+1. **Naming Convention**: Use clear, descriptive names for your repository agents
+2. **Documentation**: Include comprehensive descriptions for each agent
+3. **Tool Management**: Ensure that tools referenced by repository agents are available in your environment
+4. **Access Control**: Manage permissions to ensure only authorized team members can modify repository agents
+
+## Organization Management
+
+To switch between organizations or see your current organization, use the CrewAI CLI:
+
+```bash
+# View current organization
+crewai org current
+
+# Switch to a different organization
+crewai org switch <org_id>
+
+# List all available organizations
+crewai org list
+```
+
+<Note>
+When loading agents from repositories, you must be authenticated and switched to the correct organization. If you receive errors, check your authentication status and organization settings using the CLI commands above.
+</Note>
--- a/docs/en/enterprise/features/hallucination-guardrail.mdx
+++ b/docs/en/enterprise/features/hallucination-guardrail.mdx
--- a/docs/en/enterprise/features/integrations.mdx
+++ b/docs/en/enterprise/features/integrations.mdx
--- a/docs/en/enterprise/features/rbac.mdx
+++ b/docs/en/enterprise/features/rbac.mdx
@@ -0,0 +1,103 @@
+---
+title: "Role-Based Access Control (RBAC)"
+description: "Control access to crews, tools, and data with roles, scopes, and granular permissions."
+icon: "shield"
+---
+
+## Overview
+
+RBAC in CrewAI Enterprise enables secure, scalable access management through a combination of organization‑level roles and automation‑level visibility controls.
+
+<Frame>
+  <img src="/images/enterprise/users_and_roles.png" alt="RBAC overview in CrewAI Enterprise" />
+  
+</Frame>
+
+## Users and Roles
+
+Each member in your CrewAI workspace is assigned a role, which determines their access across various features. 
+
+You can:
+
+- Use predefined roles (Owner, Member)
+- Create custom roles tailored to specific permissions
+- Assign roles at any time through the settings panel
+
+You can configure users and roles in Settings → Roles.
+
+<Steps>
+  <Step title="Open Roles settings">
+    Go to <b>Settings → Roles</b> in CrewAI Enterprise.
+  </Step>
+  <Step title="Choose a role type">
+    Use a predefined role (<b>Owner</b>, <b>Member</b>) or click <b>Create role</b> to define a custom one.
+  </Step>
+  <Step title="Assign to members">
+    Select users and assign the role. You can change this anytime.
+  </Step>
+</Steps>
+
+### Configuration summary
+
+| Area | Where to configure | Options |
+|:---|:---|:---|
+| Users & Roles | Settings → Roles | Predefined: Owner, Member; Custom roles |
+| Automation visibility | Automation → Settings → Visibility | Private; Whitelist users/roles |
+
+## Automation‑level Access Control
+
+In addition to organization‑wide roles, CrewAI Automations support fine‑grained visibility settings that let you restrict access to specific automations by user or role.
+
+This is useful for:
+
+- Keeping sensitive or experimental automations private
+- Managing visibility across large teams or external collaborators
+- Testing automations in isolated contexts
+
+Deployments can be configured as private, meaning only whitelisted users and roles will be able to:
+
+- View the deployment
+- Run it or interact with its API
+- Access its logs, metrics, and settings
+
+The organization owner always has access, regardless of visibility settings.
+
+You can configure automation‑level access control in Automation → Settings → Visibility tab.
+
+<Steps>
+  <Step title="Open Visibility tab">
+    Navigate to <b>Automation → Settings → Visibility</b>.
+  </Step>
+  <Step title="Set visibility">
+    Choose <b>Private</b> to restrict access. The organization owner always retains access.
+  </Step>
+  <Step title="Whitelist access">
+    Add specific users and roles allowed to view, run, and access logs/metrics/settings.
+  </Step>
+  <Step title="Save and verify">
+    Save changes, then confirm that non‑whitelisted users cannot view or run the automation.
+  </Step>
+</Steps>
+
+### Private visibility: access outcomes
+
+| Action | Owner | Whitelisted user/role | Not whitelisted |
+|:---|:---|:---|:---|
+| View automation | ✓ | ✓ | ✗ |
+| Run automation/API | ✓ | ✓ | ✗ |
+| Access logs/metrics/settings | ✓ | ✓ | ✗ |
+
+<Tip>
+The organization owner always has access. In private mode, only whitelisted users and roles can view, run, and access logs/metrics/settings.
+</Tip>
+
+<Frame>
+  <img src="/images/enterprise/visibility.png" alt="Automation Visibility settings in CrewAI Enterprise" />
+  
+</Frame>
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with RBAC questions.
+</Card>
+
+
--- a/docs/en/enterprise/features/tool-repository.mdx
+++ b/docs/en/enterprise/features/tool-repository.mdx
@@ -35,6 +35,22 @@ crewai tool install <tool-name>

 This installs the tool and adds it to `pyproject.toml`.

+You can use the tool by importing it and adding it to your agents:
+
+```python
+from your_tool.tool import YourTool
+
+custom_tool = YourTool()
+
+researcher = Agent(
+    role='Market Research Analyst',
+    goal='Provide up-to-date market analysis of the AI industry',
+    backstory='An expert analyst with a keen eye for market trends.',
+    tools=[custom_tool],
+    verbose=True
+)
+```
+
 ## Creating and Publishing Tools

 To create a new tool project:
--- a/docs/en/enterprise/features/traces.mdx
+++ b/docs/en/enterprise/features/traces.mdx
--- a/docs/en/enterprise/features/webhook-streaming.mdx
+++ b/docs/en/enterprise/features/webhook-streaming.mdx
--- a/docs/en/enterprise/guides/azure-openai-setup.mdx
+++ b/docs/en/enterprise/guides/azure-openai-setup.mdx
--- a/docs/en/enterprise/guides/build-crew.mdx
+++ b/docs/en/enterprise/guides/build-crew.mdx
@@ -10,11 +10,11 @@ icon: "people-arrows"

 ## Getting Started

-<iframe 
+<iframe
    width="100%"
    height="400"
    src="https://www.youtube.com/embed/-kSOTtYzgEw"
-    title="Building Crews with CrewAI CLI" 
+    title="Building Crews with CrewAI CLI"
    frameborder="0"
    style={{ borderRadius: '10px' }}
    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
@@ -23,13 +23,13 @@ icon: "people-arrows"

 ### Installation and Setup

-<Card title="Follow Standard Installation" icon="wrench" href="/installation">
+<Card title="Follow Standard Installation" icon="wrench" href="/en/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">
+<Card title="Quickstart Tutorial" icon="rocket" href="/en/quickstart">
  Follow our quickstart guide to create your first agent crew using YAML configuration.
 </Card>

@@ -40,4 +40,4 @@ For Enterprise-specific support or questions, contact our dedicated support team

 <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>
+</Card>
--- a/docs/en/enterprise/guides/deploy-crew.mdx
+++ b/docs/en/enterprise/guides/deploy-crew.mdx
@@ -41,11 +41,8 @@ The CLI provides the fastest way to deploy locally developed crews to the Enterp
    First, you need to authenticate your CLI with the CrewAI Enterprise platform:

    ```bash
-    # If you already have a CrewAI Enterprise account
+    # If you already have a CrewAI Enterprise account, or want to create one:
    crewai login
-
-    # If you're creating a new account
-    crewai signup
    ```

    When you run either command, the CLI will:
@@ -122,7 +119,7 @@ The CrewAI CLI offers several commands to manage your deployments:

  # Remove a deployment
  crewai deploy remove <deployment_id>
-  ``` 
+  ```

 ## Option 2: Deploy Directly via Web Interface

@@ -132,14 +129,14 @@ You can also deploy your crews directly through the CrewAI Enterprise web interf

  <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).
+  You need to push your crew to a GitHub repository. If you haven't created a crew yet, you can [follow this tutorial](/en/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" 
+    2. Click on the button "Connect GitHub"

    <Frame>
      ![Connect GitHub Button](/images/enterprise/connect-github.png)
@@ -201,20 +198,20 @@ For security reasons, the following environment variable naming patterns are **a

 **Blocked Patterns:**
 - Variables ending with `_TOKEN` (e.g., `MY_API_TOKEN`)
- Variables ending with `_PASSWORD` (e.g., `DB_PASSWORD`) 
+- Variables ending with `_PASSWORD` (e.g., `DB_PASSWORD`)
 - Variables ending with `_SECRET` (e.g., `API_SECRET`)
 - Variables ending with `_KEY` in certain contexts

 **Specific Blocked Variables:**
 - `GITHUB_USER`, `GITHUB_TOKEN`
- `AWS_REGION`, `AWS_DEFAULT_REGION` 
+- `AWS_REGION`, `AWS_DEFAULT_REGION`
 - Various internal CrewAI system variables

 ### Allowed Exceptions

 Some variables are explicitly allowed despite matching blocked patterns:
 - `AZURE_AD_TOKEN`
- `AZURE_OPENAI_AD_TOKEN` 
+- `AZURE_OPENAI_AD_TOKEN`
 - `ENTERPRISE_ACTION_TOKEN`
 - `CREWAI_ENTEPRISE_TOOLS_TOKEN`

@@ -228,7 +225,7 @@ OPENAI_TOKEN=sk-...
 DATABASE_PASSWORD=mypassword
 API_SECRET=secret123

-# ✅ Use these naming patterns instead  
+# ✅ Use these naming patterns instead
 OPENAI_API_KEY=sk-...
 DATABASE_CREDENTIALS=mypassword
 API_CONFIG=secret123
--- a/docs/en/enterprise/guides/enable-crew-studio.mdx
+++ b/docs/en/enterprise/guides/enable-crew-studio.mdx
--- a/docs/en/enterprise/guides/hubspot-trigger.mdx
+++ b/docs/en/enterprise/guides/hubspot-trigger.mdx
--- a/docs/en/enterprise/guides/human-in-the-loop.mdx
+++ b/docs/en/enterprise/guides/human-in-the-loop.mdx
--- a/docs/en/enterprise/guides/kickoff-crew.mdx
+++ b/docs/en/enterprise/guides/kickoff-crew.mdx
--- a/docs/en/enterprise/guides/react-component-export.mdx
+++ b/docs/en/enterprise/guides/react-component-export.mdx
--- a/docs/en/enterprise/guides/salesforce-trigger.mdx
+++ b/docs/en/enterprise/guides/salesforce-trigger.mdx
--- a/docs/en/enterprise/guides/slack-trigger.mdx
+++ b/docs/en/enterprise/guides/slack-trigger.mdx
--- a/docs/en/enterprise/guides/team-management.mdx
+++ b/docs/en/enterprise/guides/team-management.mdx
--- a/docs/en/enterprise/guides/update-crew.mdx
+++ b/docs/en/enterprise/guides/update-crew.mdx
--- a/docs/en/enterprise/guides/webhook-automation.mdx
+++ b/docs/en/enterprise/guides/webhook-automation.mdx
--- a/docs/en/enterprise/guides/zapier-trigger.mdx
+++ b/docs/en/enterprise/guides/zapier-trigger.mdx
--- a/docs/en/enterprise/integrations/asana.mdx
+++ b/docs/en/enterprise/integrations/asana.mdx
--- a/docs/en/enterprise/integrations/box.mdx
+++ b/docs/en/enterprise/integrations/box.mdx
--- a/docs/en/enterprise/integrations/clickup.mdx
+++ b/docs/en/enterprise/integrations/clickup.mdx
--- a/docs/en/enterprise/integrations/github.mdx
+++ b/docs/en/enterprise/integrations/github.mdx
--- a/docs/en/enterprise/integrations/gmail.mdx
+++ b/docs/en/enterprise/integrations/gmail.mdx
--- a/docs/en/enterprise/integrations/google_calendar.mdx
+++ b/docs/en/enterprise/integrations/google_calendar.mdx
--- a/docs/en/enterprise/integrations/google_sheets.mdx
+++ b/docs/en/enterprise/integrations/google_sheets.mdx
--- a/docs/en/enterprise/integrations/hubspot.mdx
+++ b/docs/en/enterprise/integrations/hubspot.mdx
--- a/docs/en/enterprise/integrations/jira.mdx
+++ b/docs/en/enterprise/integrations/jira.mdx
--- a/docs/en/enterprise/integrations/linear.mdx
+++ b/docs/en/enterprise/integrations/linear.mdx
--- a/docs/en/enterprise/integrations/notion.mdx
+++ b/docs/en/enterprise/integrations/notion.mdx
--- a/docs/en/enterprise/integrations/salesforce.mdx
+++ b/docs/en/enterprise/integrations/salesforce.mdx
--- a/docs/en/enterprise/integrations/shopify.mdx
+++ b/docs/en/enterprise/integrations/shopify.mdx
--- a/docs/en/enterprise/integrations/slack.mdx
+++ b/docs/en/enterprise/integrations/slack.mdx
--- a/docs/en/enterprise/integrations/stripe.mdx
+++ b/docs/en/enterprise/integrations/stripe.mdx
--- a/docs/en/enterprise/integrations/zendesk.mdx
+++ b/docs/en/enterprise/integrations/zendesk.mdx
--- a/docs/en/enterprise/introduction.mdx
+++ b/docs/en/enterprise/introduction.mdx
@@ -56,8 +56,8 @@ CrewAI Enterprise extends the power of the open-source framework with features d
 <Steps>
  <Step title="Sign up for an account">
    Create your account at [app.crewai.com](https://app.crewai.com)
-    <Card 
-      title="Sign Up" 
+    <Card
+      title="Sign Up"
      icon="user"
      href="https://app.crewai.com/signup"
    >
@@ -66,34 +66,34 @@ CrewAI Enterprise extends the power of the open-source framework with features d
  </Step>
  <Step title="Build your first crew">
    Use code or Crew Studio to build your crew
-    <Card 
-      title="Build Crew" 
+    <Card
+      title="Build Crew"
      icon="paintbrush"
-      href="/enterprise/guides/build-crew"
+      href="/en/enterprise/guides/build-crew"
    >
      Build Crew
    </Card>
  </Step>
  <Step title="Deploy your crew">
    Deploy your crew to the Enterprise platform
-    <Card 
-      title="Deploy Crew" 
+    <Card
+      title="Deploy Crew"
      icon="rocket"
-      href="/enterprise/guides/deploy-crew"
+      href="/en/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" 
+    <Card
+      title="API Access"
      icon="code"
-      href="/enterprise/guides/use-crew-api"
+      href="/en/enterprise/guides/kickoff-crew"
    >
      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.
+For detailed instructions, check out our [deployment guide](/en/enterprise/guides/deploy-crew) or click the button below to get started.
--- a/docs/en/enterprise/resources/frequently-asked-questions.mdx
+++ b/docs/en/enterprise/resources/frequently-asked-questions.mdx
@@ -48,12 +48,12 @@ icon: "circle-question"

        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.

-        For detailed implementation guidance, see our [Human-in-the-Loop guide](/how-to/human-in-the-loop).
+        For detailed implementation guidance, see our [Human-in-the-Loop guide](/en/how-to/human-in-the-loop).
    </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:
-        
+
        - **Language Model Customization**: Agents can be customized with specific language models (`llm`) and function-calling language models (`function_calling_llm`)
        - **Performance and Debugging Settings**: Adjust an agent's performance and monitor its operations
        - **Verbose Mode**: Enables detailed logging of an agent's actions, useful for debugging and optimization
@@ -129,12 +129,12 @@ icon: "circle-question"

        Here's a tutorial on how to consistently get structured outputs from your agents:
        <Frame>
-            <iframe 
+            <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" 
+            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>
@@ -148,4 +148,4 @@ icon: "circle-question"
    <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>
+</AccordionGroup>
--- a/docs/en/examples/cookbooks.mdx
+++ b/docs/en/examples/cookbooks.mdx
@@ -0,0 +1,22 @@
+---
+title: CrewAI Cookbooks
+description: Feature-focused quickstarts and notebooks for learning patterns fast.
+icon: book
+---
+
+## Quickstarts & Demos
+
+<CardGroup cols={2}>
+  <Card title="Task Guardrails" icon="shield-check" href="https://github.com/crewAIInc/crewAI-quickstarts/tree/main/Task%20Guardrails"> 
+    Interactive notebooks for hands-on exploration.
+  </Card>
+  <Card title="Browse Quickstarts" icon="bolt" href="https://github.com/crewAIInc/crewAI-quickstarts">
+    Feature demos and small projects showcasing specific CrewAI capabilities.
+  </Card>
+</CardGroup>
+
+<Tip>
+Use Cookbooks to learn a pattern quickly, then jump to Full Examples for production‑grade implementations.
+</Tip>
+
+
--- a/docs/en/examples/example.mdx
+++ b/docs/en/examples/example.mdx
@@ -0,0 +1,85 @@
+---
+title: CrewAI Examples
+description: Explore curated examples organized by Crews, Flows, Integrations, and Notebooks.
+icon: rocket-launch
+---
+
+## Crews
+
+<CardGroup cols={3}>
+  <Card title="Marketing Strategy" icon="bullhorn" href="https://github.com/crewAIInc/crewAI-examples/tree/main/crews/marketing_strategy">
+    Multi‑agent marketing campaign planning.
+  </Card>
+  <Card title="Surprise Trip" icon="plane" href="https://github.com/crewAIInc/crewAI-examples/tree/main/crews/surprise_trip">
+    Personalized surprise travel planning.
+  </Card>
+  <Card title="Match Profile to Positions" icon="id-card" href="https://github.com/crewAIInc/crewAI-examples/tree/main/crews/match_profile_to_positions">
+    CV‑to‑job matching with vector search.
+  </Card>
+  <Card title="Job Posting" icon="newspaper" href="https://github.com/crewAIInc/crewAI-examples/tree/main/crews/job-posting">
+    Automated job description creation.
+  </Card>
+  <Card title="Game Builder Crew" icon="gamepad" href="https://github.com/crewAIInc/crewAI-examples/tree/main/crews/game-builder-crew">
+    Multi‑agent team that designs and builds Python games.
+  </Card>
+  <Card title="Recruitment" icon="user-group" href="https://github.com/crewAIInc/crewAI-examples/tree/main/crews/recruitment">
+    Candidate sourcing and evaluation.
+  </Card>
+  <Card title="Browse all Crews" icon="users" href="https://github.com/crewAIInc/crewAI-examples/tree/main/crews">
+    See the full list of crew examples.
+  </Card>
+</CardGroup>
+
+## Flows
+
+<CardGroup cols={3}>
+  <Card title="Content Creator Flow" icon="pen" href="https://github.com/crewAIInc/crewAI-examples/tree/main/flows/content_creator_flow">
+    Multi‑crew content generation with routing.
+  </Card>
+  <Card title="Email Auto Responder" icon="envelope" href="https://github.com/crewAIInc/crewAI-examples/tree/main/flows/email_auto_responder_flow">
+    Automated email monitoring and replies.
+  </Card>
+  <Card title="Lead Score Flow" icon="chart-line" href="https://github.com/crewAIInc/crewAI-examples/tree/main/flows/lead_score_flow">
+    Lead qualification with human‑in‑the‑loop.
+  </Card>
+  <Card title="Meeting Assistant Flow" icon="calendar" href="https://github.com/crewAIInc/crewAI-examples/tree/main/flows/meeting_assistant_flow">
+    Notes processing with integrations.
+  </Card>
+  <Card title="Self Evaluation Loop" icon="rotate" href="https://github.com/crewAIInc/crewAI-examples/tree/main/flows/self_evaluation_loop_flow">
+    Iterative self‑improvement workflows.
+  </Card>
+  <Card title="Write a Book (Flows)" icon="book" href="https://github.com/crewAIInc/crewAI-examples/tree/main/flows/write_a_book_with_flows">
+    Parallel chapter generation.
+  </Card>
+  <Card title="Browse all Flows" icon="diagram-project" href="https://github.com/crewAIInc/crewAI-examples/tree/main/flows">
+    See the full list of flow examples.
+  </Card>
+</CardGroup>
+
+## Integrations
+
+<CardGroup cols={3}>
+  <Card title="CrewAI ↔ LangGraph" icon="link" href="https://github.com/crewAIInc/crewAI-examples/tree/main/integrations/crewai-langgraph">
+    Integration with LangGraph framework.
+  </Card>
+  <Card title="Azure OpenAI" icon="cloud" href="https://github.com/crewAIInc/crewAI-examples/tree/main/integrations/azure_model">
+    Using CrewAI with Azure OpenAI.
+  </Card>
+  <Card title="NVIDIA Models" icon="microchip" href="https://github.com/crewAIInc/crewAI-examples/tree/main/integrations/nvidia_models">
+    NVIDIA ecosystem integrations.
+  </Card>
+  <Card title="Browse Integrations" icon="puzzle-piece" href="https://github.com/crewAIInc/crewAI-examples/tree/main/integrations">
+    See all integration examples.
+  </Card>
+</CardGroup>
+
+## Notebooks
+
+<CardGroup cols={2}>
+  <Card title="Simple QA Crew + Flow" icon="book" href="https://github.com/crewAIInc/crewAI-examples/tree/main/Notebooks/Simple%20QA%20Crew%20%2B%20Flow">
+    Simple QA Crew + Flow.
+  </Card>
+  <Card title="All Notebooks" icon="book" href="https://github.com/crewAIInc/crewAI-examples/tree/main/Notebooks">
+    Interactive examples for learning and experimentation.
+  </Card>
+</CardGroup>
--- a/docs/en/guides/advanced/customizing-prompts.mdx
+++ b/docs/en/guides/advanced/customizing-prompts.mdx
@@ -44,7 +44,7 @@ Based on your agent configuration, CrewAI adds different default instructions:
 "I MUST use these formats, my job depends on it!"
 ```

-#### For Agents With Tools  
+#### For Agents With Tools
 ```text
 "IMPORTANT: Use the following format in your response:

@@ -127,7 +127,7 @@ custom_prompt_template = """Task: {input}
 Please complete this task thoughtfully."""

 agent = Agent(
-    role="Research Assistant", 
+    role="Research Assistant",
    goal="Help users find accurate information",
    backstory="You are a helpful research assistant.",
    system_template=custom_system_template,
@@ -164,7 +164,7 @@ crew = Crew(
 ```python
 agent = Agent(
    role="Analyst",
-    goal="Analyze data", 
+    goal="Analyze data",
    backstory="Expert analyst",
    use_system_prompt=False  # Disables system prompt separation
 )
@@ -174,13 +174,13 @@ agent = Agent(

 For production transparency, integrate with observability platforms to monitor all prompts and LLM interactions. This allows you to see exactly what prompts (including default instructions) are being sent to your LLMs.

-See our [Observability documentation](/how-to/observability) for detailed integration guides with various platforms including Langfuse, MLflow, Weights & Biases, and custom logging solutions.
+See our [Observability documentation](/en/observability/overview) for detailed integration guides with various platforms including Langfuse, MLflow, Weights & Biases, and custom logging solutions.

 ### Best Practices for Production

 1. **Always inspect generated prompts** before deploying to production
 2. **Use custom templates** when you need full control over prompt content
-3. **Integrate observability tools** for ongoing prompt monitoring (see [Observability docs](/how-to/observability))
+3. **Integrate observability tools** for ongoing prompt monitoring (see [Observability docs](/en/observability/overview))
 4. **Test with different LLMs** as default instructions may work differently across models
 5. **Document your prompt customizations** for team transparency

@@ -313,4 +313,4 @@ Low-level prompt customization in CrewAI opens the door to super custom, complex

 <Check>
 You now have the foundation for advanced prompt customizations in CrewAI. Whether you're adapting for model-specific structures or domain-specific constraints, this low-level approach lets you shape agent interactions in highly specialized ways.
-</Check>
+</Check>
--- a/docs/en/guides/advanced/fingerprinting.mdx
+++ b/docs/en/guides/advanced/fingerprinting.mdx
--- a/docs/en/guides/agents/crafting-effective-agents.mdx
+++ b/docs/en/guides/agents/crafting-effective-agents.mdx
@@ -448,5 +448,5 @@ Congratulations! You now understand the principles and practices of effective ag
 ## Next Steps

 - Experiment with different agent configurations for your specific use case
- Learn about [building your first crew](/guides/crews/first-crew) to see how agents work together
- Explore [CrewAI Flows](/guides/flows/first-flow) for more advanced orchestration
+- Learn about [building your first crew](/en/guides/crews/first-crew) to see how agents work together
+- Explore [CrewAI Flows](/en/guides/flows/first-flow) for more advanced orchestration
--- a/docs/en/guides/concepts/evaluating-use-cases.mdx
+++ b/docs/en/guides/concepts/evaluating-use-cases.mdx
@@ -11,7 +11,7 @@ When building AI applications with CrewAI, one of the most important decisions y
 At the heart of this decision is understanding the relationship between **complexity** and **precision** in your application:

 <Frame caption="Complexity vs. Precision Matrix for CrewAI Applications">
-  <img src="../../images/complexity_precision.png" alt="Complexity vs. Precision Matrix" />
+  <img src="/images/complexity_precision.png" alt="Complexity vs. Precision Matrix" />
 </Frame>

 This matrix helps visualize how different approaches align with varying requirements for complexity and precision. Let's explore what each quadrant means and how it guides your architectural choices.
@@ -497,7 +497,7 @@ You now have a framework for evaluating CrewAI use cases and choosing the right

 ## Next Steps

- Learn more about [crafting effective agents](/guides/agents/crafting-effective-agents)
- Explore [building your first crew](/guides/crews/first-crew)
- Dive into [mastering flow state management](/guides/flows/mastering-flow-state)
- Check out the [core concepts](/concepts/agents) for deeper understanding
+- Learn more about [crafting effective agents](/en/guides/agents/crafting-effective-agents)
+- Explore [building your first crew](/en/guides/crews/first-crew)
+- Dive into [mastering flow state management](/en/guides/flows/mastering-flow-state)
+- Check out the [core concepts](/en/concepts/agents) for deeper understanding
--- a/docs/en/guides/crews/first-crew.mdx
+++ b/docs/en/guides/crews/first-crew.mdx
@@ -32,9 +32,9 @@ Let's get started building your first crew!

 Before starting, make sure you have:

-1. Installed CrewAI following the [installation guide](/installation)
+1. Installed CrewAI following the [installation guide](/en/installation)
 2. Set up your LLM API key in your environment, following the [LLM setup
-   guide](/concepts/llms#setting-up-your-llm)
+   guide](/en/concepts/llms#setting-up-your-llm)
 3. Basic understanding of Python

 ## Step 1: Create a New CrewAI Project
@@ -54,7 +54,7 @@ This will generate a project with the basic structure needed for your crew. The
 - A main script to run the crew

 <Frame caption="CrewAI Framework Overview">
-  <img src="../../images/crews.png" alt="CrewAI Framework Overview" />
+  <img src="/images/crews.png" alt="CrewAI Framework Overview" />
 </Frame>


@@ -287,7 +287,7 @@ SERPER_API_KEY=your_serper_api_key
 # Add your provider's API key here too.
 ```

-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/).
+See the [LLM Setup guide](/en/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

@@ -388,7 +388,7 @@ Now that you've built your first crew, you can:
 2. Try more complex task structures and workflows
 3. Implement custom tools to give your agents new capabilities
 4. Apply your crew to different topics or problem domains
-5. Explore [CrewAI Flows](/guides/flows/first-flow) for more advanced workflows with procedural programming
+5. Explore [CrewAI Flows](/en/guides/flows/first-flow) for more advanced workflows with procedural programming

 <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.
--- a/docs/en/guides/flows/first-flow.mdx
+++ b/docs/en/guides/flows/first-flow.mdx
@@ -42,9 +42,9 @@ Let's dive in and build your first flow!

 Before starting, make sure you have:

-1. Installed CrewAI following the [installation guide](/installation)
+1. Installed CrewAI following the [installation guide](/en/installation)
 2. Set up your LLM API key in your environment, following the [LLM setup
-   guide](/concepts/llms#setting-up-your-llm)
+   guide](/en/concepts/llms#setting-up-your-llm)
 3. Basic understanding of Python

 ## Step 1: Create a New CrewAI Flow Project
@@ -59,7 +59,7 @@ cd guide_creator_flow
 This will generate a project with the basic structure needed for your flow.

 <Frame caption="CrewAI Framework Overview">
-  <img src="../../images/flows.png" alt="CrewAI Framework Overview" />
+  <img src="/images/flows.png" alt="CrewAI Framework Overview" />
 </Frame>

 ## Step 2: Understanding the Project Structure
@@ -443,7 +443,7 @@ 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. See the [LLM setup
-guide](/concepts/llms#setting-up-your-llm) for details on configuring a provider.
+guide](/en/concepts/llms#setting-up-your-llm) for details on configuring a provider.

 ```sh .env
 OPENAI_API_KEY=your_openai_api_key
--- a/docs/en/guides/flows/mastering-flow-state.mdx
+++ b/docs/en/guides/flows/mastering-flow-state.mdx
@@ -767,5 +767,5 @@ You've now mastered the concepts and practices of state management in CrewAI Flo

 - Experiment with both structured and unstructured state in your flows
 - Try implementing state persistence for long-running workflows
- Explore [building your first crew](/guides/crews/first-crew) to see how crews and flows can work together
- Check out the [Flow reference documentation](/concepts/flows) for more advanced features
+- Explore [building your first crew](/en/guides/crews/first-crew) to see how crews and flows can work together
+- Check out the [Flow reference documentation](/en/concepts/flows) for more advanced features
--- a/docs/en/installation.mdx
+++ b/docs/en/installation.mdx
@@ -72,7 +72,7 @@ If you haven't installed `uv` yet, follow **step 1** to quickly get it set up on
          </Warning>

          <Warning>
-            If you encounter the `chroma-hnswlib==0.7.6` build error (`fatal error C1083: Cannot open include file: 'float.h'`) on Windows, install (Visual Studio Build Tools)[https://visualstudio.microsoft.com/downloads/] with *Desktop development with C++*.
+            If you encounter the `chroma-hnswlib==0.7.6` build error (`fatal error C1083: Cannot open include file: 'float.h'`) on Windows, install [Visual Studio Build Tools](https://visualstudio.microsoft.com/downloads/) with *Desktop development with C++*.
          </Warning>

      - To verify that `crewai` is installed, run:
@@ -104,7 +104,6 @@ We recommend using the `YAML` template scaffolding for a structured approach to
      ```

    - This creates a new project with the following structure:
-      <Frame>
      ```
      my_project/
      ├── .gitignore
@@ -124,7 +123,6 @@ We recommend using the `YAML` template scaffolding for a structured approach to
                  ├── agents.yaml
                  └── tasks.yaml
      ```
-      </Frame>
  </Step>

  <Step title="Customize Your Project">
@@ -172,7 +170,7 @@ For teams and organizations, CrewAI offers enterprise deployment options that el

 ### CrewAI Factory (Self-hosted)
 - Containerized deployment for your infrastructure
- Supports any hyperscaler including on prem depployments
+- Supports any hyperscaler including on prem deployments
 - Integration with your existing security systems

 <Card title="Explore Enterprise Options" icon="building" href="https://crewai.com/enterprise">
@@ -186,7 +184,7 @@ For teams and organizations, CrewAI offers enterprise deployment options that el
  <Card
    title="Build Your First Agent"
    icon="code"
-    href="/quickstart"
+    href="/en/quickstart"
  >
    Follow our quickstart guide to create your first CrewAI agent and get hands-on experience.
  </Card>
--- a/docs/en/introduction.mdx
+++ b/docs/en/introduction.mdx
@@ -10,8 +10,8 @@ icon: handshake

 CrewAI empowers developers with both high-level simplicity and precise low-level control, ideal for creating autonomous AI agents tailored to any scenario:

- **[CrewAI Crews](/guides/crews/first-crew)**: Optimize for autonomy and collaborative intelligence, enabling you to create AI teams where each agent has specific roles, tools, and goals.
- **[CrewAI Flows](/guides/flows/first-flow)**: Enable granular, event-driven control, single LLM calls for precise task orchestration and supports Crews natively.
+- **[CrewAI Crews](/en/guides/crews/first-crew)**: Optimize for autonomy and collaborative intelligence, enabling you to create AI teams where each agent has specific roles, tools, and goals.
+- **[CrewAI Flows](/en/guides/flows/first-flow)**: Enable granular, event-driven control, single LLM calls for precise task orchestration and supports Crews natively.

 With over 100,000 developers certified through our community courses, CrewAI is rapidly becoming the standard for enterprise-ready AI automation.

@@ -23,7 +23,7 @@ With over 100,000 developers certified through our community courses, CrewAI is
 </Note>

 <Frame caption="CrewAI Framework Overview">
-  <img src="images/crews.png" alt="CrewAI Framework Overview" />
+  <img src="/images/crews.png" alt="CrewAI Framework Overview" />
 </Frame>

 | Component | Description | Key Features |
@@ -64,7 +64,7 @@ With over 100,000 developers certified through our community courses, CrewAI is
 </Note>

 <Frame caption="CrewAI Framework Overview">
-  <img src="images/flows.png" alt="CrewAI Framework Overview" />
+  <img src="/images/flows.png" alt="CrewAI Framework Overview" />
 </Frame>

 | Component | Description | Key Features |
@@ -94,21 +94,21 @@ With over 100,000 developers certified through our community courses, CrewAI is
 ## When to Use Crews vs. Flows

 <Note>
-  Understanding when to use [Crews](/guides/crews/first-crew) versus [Flows](/guides/flows/first-flow) is key to maximizing the potential of CrewAI in your applications.
+  Understanding when to use [Crews](/en/guides/crews/first-crew) versus [Flows](/en/guides/flows/first-flow) is key to maximizing the potential of CrewAI in your applications.
 </Note>

 | Use Case | Recommended Approach | Why? |
 |:---------|:---------------------|:-----|
-| **Open-ended research** | [Crews](/guides/crews/first-crew) | When tasks require creative thinking, exploration, and adaptation |
-| **Content generation** | [Crews](/guides/crews/first-crew) | For collaborative creation of articles, reports, or marketing materials |
-| **Decision workflows** | [Flows](/guides/flows/first-flow) | When you need predictable, auditable decision paths with precise control |
-| **API orchestration** | [Flows](/guides/flows/first-flow) | For reliable integration with multiple external services in a specific sequence |
-| **Hybrid applications** | Combined approach | Use [Flows](/guides/flows/first-flow) to orchestrate overall process with [Crews](/guides/crews/first-crew) handling complex subtasks |
+| **Open-ended research** | [Crews](/en/guides/crews/first-crew) | When tasks require creative thinking, exploration, and adaptation |
+| **Content generation** | [Crews](/en/guides/crews/first-crew) | For collaborative creation of articles, reports, or marketing materials |
+| **Decision workflows** | [Flows](/en/guides/flows/first-flow) | When you need predictable, auditable decision paths with precise control |
+| **API orchestration** | [Flows](/en/guides/flows/first-flow) | For reliable integration with multiple external services in a specific sequence |
+| **Hybrid applications** | Combined approach | Use [Flows](/en/guides/flows/first-flow) to orchestrate overall process with [Crews](/en/guides/crews/first-crew) handling complex subtasks |

 ### Decision Framework

- **Choose [Crews](/guides/crews/first-crew) when:** You need autonomous problem-solving, creative collaboration, or exploratory tasks
- **Choose [Flows](/guides/flows/first-flow) when:** You require deterministic outcomes, auditability, or precise control over execution
+- **Choose [Crews](/en/guides/crews/first-crew) when:** You need autonomous problem-solving, creative collaboration, or exploratory tasks
+- **Choose [Flows](/en/guides/flows/first-flow) when:** You require deterministic outcomes, auditability, or precise control over execution
 - **Combine both when:** Your application needs both structured processes and pockets of autonomous intelligence

 ## Why Choose CrewAI?
@@ -126,14 +126,14 @@ With over 100,000 developers certified through our community courses, CrewAI is
  <Card
    title="Build Your First Crew"
    icon="users-gear"
-    href="/guides/crews/first-crew"
+    href="/en/guides/crews/first-crew"
  >
    Step-by-step tutorial to create a collaborative AI team that works together to solve complex problems.
  </Card>
  <Card
    title="Build Your First Flow"
    icon="diagram-project"
-    href="/guides/flows/first-flow"
+    href="/en/guides/flows/first-flow"
  >
    Learn how to create structured, event-driven workflows with precise control over execution.
  </Card>
@@ -143,14 +143,14 @@ With over 100,000 developers certified through our community courses, CrewAI is
  <Card
    title="Install CrewAI"
    icon="wrench"
-    href="/installation"
+    href="/en/installation"
  >
    Get started with CrewAI in your development environment.
  </Card>
  <Card
    title="Quick Start"
    icon="bolt"
-    href="/quickstart"
+    href="en/quickstart"
  >
    Follow our quickstart guide to create your first CrewAI agent and get hands-on experience.
  </Card>
@@ -161,4 +161,4 @@ With over 100,000 developers certified through our community courses, CrewAI is
  >
    Connect with other developers, get help, and share your CrewAI experiences.
  </Card>
-</CardGroup>
+</CardGroup>
--- a/docs/en/learn/before-and-after-kickoff-hooks.mdx
+++ b/docs/en/learn/before-and-after-kickoff-hooks.mdx
--- a/docs/en/learn/bring-your-own-agent.mdx
+++ b/docs/en/learn/bring-your-own-agent.mdx
--- a/docs/en/learn/coding-agents.mdx
+++ b/docs/en/learn/coding-agents.mdx
--- a/docs/en/learn/conditional-tasks.mdx
+++ b/docs/en/learn/conditional-tasks.mdx
--- a/docs/en/learn/create-custom-tools.mdx
+++ b/docs/en/learn/create-custom-tools.mdx
--- a/docs/en/learn/custom-llm.mdx
+++ b/docs/en/learn/custom-llm.mdx
--- a/docs/en/learn/custom-manager-agent.mdx
+++ b/docs/en/learn/custom-manager-agent.mdx
--- a/docs/en/learn/customizing-agents.mdx
+++ b/docs/en/learn/customizing-agents.mdx
--- a/docs/en/learn/dalle-image-generation.mdx
+++ b/docs/en/learn/dalle-image-generation.mdx
--- a/docs/en/learn/force-tool-output-as-result.mdx
+++ b/docs/en/learn/force-tool-output-as-result.mdx
--- a/docs/en/learn/hierarchical-process.mdx
+++ b/docs/en/learn/hierarchical-process.mdx
--- a/docs/en/learn/human-in-the-loop.mdx
+++ b/docs/en/learn/human-in-the-loop.mdx
--- a/docs/en/learn/human-input-on-execution.mdx
+++ b/docs/en/learn/human-input-on-execution.mdx
--- a/docs/en/learn/kickoff-async.mdx
+++ b/docs/en/learn/kickoff-async.mdx
--- a/docs/en/learn/kickoff-for-each.mdx
+++ b/docs/en/learn/kickoff-for-each.mdx
--- a/docs/en/learn/llm-connections.mdx
+++ b/docs/en/learn/llm-connections.mdx
@@ -34,6 +34,7 @@ LiteLLM supports a wide range of providers, including but not limited to:
 - DeepInfra
 - Groq
 - SambaNova
+- Nebius AI Studio
 - [NVIDIA NIMs](https://docs.api.nvidia.com/nim/reference/models-1)
 - And many more!

--- a/docs/en/learn/llm-selection-guide.mdx
+++ b/docs/en/learn/llm-selection-guide.mdx
--- a/docs/en/learn/multimodal-agents.mdx
+++ b/docs/en/learn/multimodal-agents.mdx
--- a/docs/en/learn/overview.mdx
+++ b/docs/en/learn/overview.mdx
@@ -12,38 +12,38 @@ This section provides comprehensive guides and tutorials to help you master Crew

 ### Core Concepts
 <CardGroup cols={2}>
-  <Card title="Sequential Process" icon="list-ol" href="/learn/sequential-process">
+  <Card title="Sequential Process" icon="list-ol" href="/en/learn/sequential-process">
    Learn how to execute tasks in a sequential order for structured workflows.
  </Card>

-  <Card title="Hierarchical Process" icon="sitemap" href="/learn/hierarchical-process">
+  <Card title="Hierarchical Process" icon="sitemap" href="/en/learn/hierarchical-process">
    Implement hierarchical task execution with manager agents overseeing workflows.
  </Card>

-  <Card title="Conditional Tasks" icon="code-branch" href="/learn/conditional-tasks">
+  <Card title="Conditional Tasks" icon="code-branch" href="/en/learn/conditional-tasks">
    Create dynamic workflows with conditional task execution based on outcomes.
  </Card>

-  <Card title="Async Kickoff" icon="bolt" href="/learn/kickoff-async">
+  <Card title="Async Kickoff" icon="bolt" href="/en/learn/kickoff-async">
    Execute crews asynchronously for improved performance and concurrency.
  </Card>
 </CardGroup>

 ### Agent Development
 <CardGroup cols={2}>
-  <Card title="Customizing Agents" icon="user-gear" href="/learn/customizing-agents">
+  <Card title="Customizing Agents" icon="user-gear" href="/en/learn/customizing-agents">
    Learn how to customize agent behavior, roles, and capabilities.
  </Card>

-  <Card title="Coding Agents" icon="code" href="/learn/coding-agents">
+  <Card title="Coding Agents" icon="code" href="/en/learn/coding-agents">
    Build agents that can write, execute, and debug code automatically.
  </Card>

-  <Card title="Multimodal Agents" icon="images" href="/learn/multimodal-agents">
+  <Card title="Multimodal Agents" icon="images" href="/en/learn/multimodal-agents">
    Create agents that can process text, images, and other media types.
  </Card>

-  <Card title="Custom Manager Agent" icon="user-tie" href="/learn/custom-manager-agent">
+  <Card title="Custom Manager Agent" icon="user-tie" href="/en/learn/custom-manager-agent">
    Implement custom manager agents for complex hierarchical workflows.
  </Card>
 </CardGroup>
@@ -52,38 +52,38 @@ This section provides comprehensive guides and tutorials to help you master Crew

 ### Workflow Control
 <CardGroup cols={2}>
-  <Card title="Human in the Loop" icon="user-check" href="/learn/human-in-the-loop">
+  <Card title="Human in the Loop" icon="user-check" href="/en/learn/human-in-the-loop">
    Integrate human oversight and intervention into agent workflows.
  </Card>

-  <Card title="Human Input on Execution" icon="hand-paper" href="/learn/human-input-on-execution">
+  <Card title="Human Input on Execution" icon="hand-paper" href="/en/learn/human-input-on-execution">
    Allow human input during task execution for dynamic decision making.
  </Card>

-  <Card title="Replay Tasks" icon="rotate-left" href="/learn/replay-tasks-from-latest-crew-kickoff">
+  <Card title="Replay Tasks" icon="rotate-left" href="/en/learn/replay-tasks-from-latest-crew-kickoff">
    Replay and resume tasks from previous crew executions.
  </Card>

-  <Card title="Kickoff for Each" icon="repeat" href="/learn/kickoff-for-each">
+  <Card title="Kickoff for Each" icon="repeat" href="/en/learn/kickoff-for-each">
    Execute crews multiple times with different inputs efficiently.
  </Card>
 </CardGroup>

 ### Customization & Integration
 <CardGroup cols={2}>
-  <Card title="Custom LLM" icon="brain" href="/learn/custom-llm">
+  <Card title="Custom LLM" icon="brain" href="/en/learn/custom-llm">
    Integrate custom language models and providers with CrewAI.
  </Card>

-  <Card title="LLM Connections" icon="link" href="/learn/llm-connections">
+  <Card title="LLM Connections" icon="link" href="/en/learn/llm-connections">
    Configure and manage connections to various LLM providers.
  </Card>

-  <Card title="Create Custom Tools" icon="wrench" href="/learn/create-custom-tools">
+  <Card title="Create Custom Tools" icon="wrench" href="/en/learn/create-custom-tools">
    Build custom tools to extend agent capabilities.
  </Card>

-  <Card title="Using Annotations" icon="at" href="/learn/using-annotations">
+  <Card title="Using Annotations" icon="at" href="/en/learn/using-annotations">
    Use Python annotations for cleaner, more maintainable code.
  </Card>
 </CardGroup>
@@ -92,18 +92,18 @@ This section provides comprehensive guides and tutorials to help you master Crew

 ### Content & Media
 <CardGroup cols={2}>
-  <Card title="DALL-E Image Generation" icon="image" href="/learn/dalle-image-generation">
+  <Card title="DALL-E Image Generation" icon="image" href="/en/learn/dalle-image-generation">
    Generate images using DALL-E integration with your agents.
  </Card>

-  <Card title="Bring Your Own Agent" icon="user-plus" href="/learn/bring-your-own-agent">
+  <Card title="Bring Your Own Agent" icon="user-plus" href="/en/learn/bring-your-own-agent">
    Integrate existing agents and models into CrewAI workflows.
  </Card>
 </CardGroup>

 ### Tool Management
 <CardGroup cols={2}>
-  <Card title="Force Tool Output as Result" icon="hammer" href="/learn/force-tool-output-as-result">
+  <Card title="Force Tool Output as Result" icon="hammer" href="/en/learn/force-tool-output-as-result">
    Configure tools to return their output directly as task results.
  </Card>
 </CardGroup>
@@ -155,4 +155,4 @@ This section provides comprehensive guides and tutorials to help you master Crew
 - **Examples**: Check the Examples section for complete working implementations
 - **Support**: Contact [support@crewai.com](mailto:support@crewai.com) for technical assistance

-Start with the guides that match your current needs and gradually explore more advanced topics as you become comfortable with the fundamentals. 
+Start with the guides that match your current needs and gradually explore more advanced topics as you become comfortable with the fundamentals.
--- a/docs/en/learn/replay-tasks-from-latest-crew-kickoff.mdx
+++ b/docs/en/learn/replay-tasks-from-latest-crew-kickoff.mdx
--- a/docs/en/learn/sequential-process.mdx
+++ b/docs/en/learn/sequential-process.mdx
--- a/docs/en/learn/using-annotations.mdx
+++ b/docs/en/learn/using-annotations.mdx
--- a/docs/en/mcp/multiple-servers.mdx
+++ b/docs/en/mcp/multiple-servers.mdx
--- a/docs/en/mcp/overview.mdx
+++ b/docs/en/mcp/overview.mdx
@@ -6,11 +6,11 @@ icon: plug

 ## Overview

-The [Model Context Protocol](https://modelcontextprotocol.io/introduction) (MCP) provides a standardized way for AI agents to provide context to LLMs by communicating with external services, known as MCP Servers. 
-The `crewai-tools` library extends CrewAI's capabilities by allowing you to seamlessly integrate tools from these MCP servers into your agents. 
-This gives your crews access to a vast ecosystem of functionalities. 
+The [Model Context Protocol](https://modelcontextprotocol.io/introduction) (MCP) provides a standardized way for AI agents to provide context to LLMs by communicating with external services, known as MCP Servers.
+The `crewai-tools` library extends CrewAI's capabilities by allowing you to seamlessly integrate tools from these MCP servers into your agents.
+This gives your crews access to a vast ecosystem of functionalities.

-We currently support the following transport mechanisms: 
+We currently support the following transport mechanisms:

 - **Stdio**: for local servers (communication via standard input/output between processes on the same machine)
 - **Server-Sent Events (SSE)**: for remote servers (unidirectional, real-time data streaming from server to client over HTTP)
@@ -44,6 +44,19 @@ The `MCPServerAdapter` class from `crewai-tools` is the primary way to connect t

 Using a Python context manager (`with` statement) is the **recommended approach** for `MCPServerAdapter`. It automatically handles starting and stopping the connection to the MCP server.

+## Connection Configuration
+
+The `MCPServerAdapter` supports several configuration options to customize the connection behavior:
+
+- **`connect_timeout`** (optional): Maximum time in seconds to wait for establishing a connection to the MCP server. Defaults to 30 seconds if not specified. This is particularly useful for remote servers that may have variable response times.
+
+```python
+# Example with custom connection timeout
+with MCPServerAdapter(server_params, connect_timeout=60) as tools:
+    # Connection will timeout after 60 seconds if not established
+    pass
+```
+
 ```python
 from crewai import Agent
 from crewai_tools import MCPServerAdapter
@@ -52,27 +65,27 @@ from mcp import StdioServerParameters # For Stdio Server
 # Example server_params (choose one based on your server type):
 # 1. Stdio Server:
 server_params=StdioServerParameters(
-    command="python3", 
+    command="python3",
    args=["servers/your_server.py"],
    env={"UV_PYTHON": "3.12", **os.environ},
 )

 # 2. SSE Server:
 server_params = {
-    "url": "http://localhost:8000/sse", 
+    "url": "http://localhost:8000/sse",
    "transport": "sse"
 }

 # 3. Streamable HTTP Server:
 server_params = {
-    "url": "http://localhost:8001/mcp", 
+    "url": "http://localhost:8001/mcp",
    "transport": "streamable-http"
 }

 # Example usage (uncomment and adapt once server_params is set):
-with MCPServerAdapter(server_params) as mcp_tools:
+with MCPServerAdapter(server_params, connect_timeout=60) as mcp_tools:
    print(f"Available tools: {[tool.name for tool in mcp_tools]}")
-    
+
    my_agent = Agent(
        role="MCP Tool User",
        goal="Utilize tools from an MCP server.",
@@ -87,59 +100,130 @@ This general pattern shows how to integrate tools. For specific examples tailore

 ## Filtering Tools

+There are two ways to filter tools:
+
+1. Accessing a specific tool using dictionary-style indexing.
+2. Pass a list of tool names to the `MCPServerAdapter` constructor.
+
+### Accessing a specific tool using dictionary-style indexing.
+
 ```python
-with MCPServerAdapter(server_params) as mcp_tools:
+with MCPServerAdapter(server_params, connect_timeout=60) as mcp_tools:
    print(f"Available tools: {[tool.name for tool in mcp_tools]}")

    my_agent = Agent(
        role="MCP Tool User",
        goal="Utilize tools from an MCP server.",
        backstory="I can connect to MCP servers and use their tools.",
-        tools=mcp_tools["tool_name"], # Pass the loaded tools to your agent
+        tools=[mcp_tools["tool_name"]], # Pass the loaded tools to your agent
        reasoning=True,
        verbose=True
    )
    # ... rest of your crew setup ...
 ```
+
+### Pass a list of tool names to the `MCPServerAdapter` constructor.
+
+```python
+with MCPServerAdapter(server_params, "tool_name", connect_timeout=60) as mcp_tools:
+    print(f"Available tools: {[tool.name for tool in mcp_tools]}")
+
+    my_agent = Agent(
+        role="MCP Tool User",
+        goal="Utilize tools from an MCP server.",
+        backstory="I can connect to MCP servers and use their tools.",
+        tools=mcp_tools, # Pass the loaded tools to your agent
+        reasoning=True,
+        verbose=True
+    )
+    # ... rest of your crew setup ...
+```
+
+## Using with CrewBase
+
+To use MCPServer tools within a CrewBase class, use the `mcp_tools` method. Server configurations should be provided via the mcp_server_params attribute. You can pass either a single configuration or a list of multiple server configurations.
+
+```python
+@CrewBase
+class CrewWithMCP:
+  # ... define your agents and tasks config file ...
+
+  mcp_server_params = [
+    # Streamable HTTP Server
+    {
+        "url": "http://localhost:8001/mcp",
+        "transport": "streamable-http"
+    },
+    # SSE Server
+    {
+        "url": "http://localhost:8000/sse",
+        "transport": "sse"
+    },
+    # StdIO Server
+    StdioServerParameters(
+        command="python3",
+        args=["servers/your_stdio_server.py"],
+        env={"UV_PYTHON": "3.12", **os.environ},
+    )
+  ]
+
+  @agent
+  def your_agent(self):
+      return Agent(config=self.agents_config["your_agent"], tools=self.get_mcp_tools()) # get all available tools
+
+    # ... rest of your crew setup ...
+```
+
+You can filter which tools are available to your agent by passing a list of tool names to the `get_mcp_tools` method.
+
+```python
+@agent
+def another_agent(self):
+    return Agent(
+      config=self.agents_config["your_agent"],
+      tools=self.get_mcp_tools("tool_1", "tool_2") # get specific tools
+    )
+```
+
 ## Explore MCP Integrations

 <CardGroup cols={2}>
-  <Card 
-    title="Stdio Transport" 
-    icon="server" 
-    href="/mcp/stdio"
+  <Card
+    title="Stdio Transport"
+    icon="server"
+    href="/en/mcp/stdio"
    color="#3B82F6"
  >
    Connect to local MCP servers via standard input/output. Ideal for scripts and local executables.
  </Card>
-  <Card 
-    title="SSE Transport" 
-    icon="wifi" 
-    href="/mcp/sse"
+  <Card
+    title="SSE Transport"
+    icon="wifi"
+    href="/en/mcp/sse"
    color="#10B981"
  >
    Integrate with remote MCP servers using Server-Sent Events for real-time data streaming.
  </Card>
-  <Card 
-    title="Streamable HTTP Transport" 
-    icon="globe" 
-    href="/mcp/streamable-http"
+  <Card
+    title="Streamable HTTP Transport"
+    icon="globe"
+    href="/en/mcp/streamable-http"
    color="#F59E0B"
  >
    Utilize flexible Streamable HTTP for robust communication with remote MCP servers.
  </Card>
-  <Card 
-    title="Connecting to Multiple Servers" 
-    icon="layer-group" 
-    href="/mcp/multiple-servers"
+  <Card
+    title="Connecting to Multiple Servers"
+    icon="layer-group"
+    href="/en/mcp/multiple-servers"
    color="#8B5CF6"
  >
    Aggregate tools from several MCP servers simultaneously using a single adapter.
  </Card>
-  <Card 
-    title="Security Considerations" 
-    icon="lock" 
-    href="/mcp/security"
+  <Card
+    title="Security Considerations"
+    icon="lock"
+    href="/en/mcp/security"
    color="#EF4444"
  >
    Review important security best practices for MCP integration to keep your agents safe.
@@ -148,7 +232,7 @@ with MCPServerAdapter(server_params) as mcp_tools:

 Checkout this repository for full demos and examples of MCP integration with CrewAI! 👇

-<Card 
+<Card
 title="GitHub Repository"
 icon="github"
 href="https://github.com/tonykipkemboi/crewai-mcp-demo"
@@ -163,7 +247,7 @@ Always ensure that you trust an MCP Server before using it.
 </Warning>

 #### Security Warning: DNS Rebinding Attacks
-SSE transports can be vulnerable to DNS rebinding attacks if not properly secured. 
+SSE transports can be vulnerable to DNS rebinding attacks if not properly secured.
 To prevent this:

 1. **Always validate Origin headers** on incoming SSE connections to ensure they come from expected sources
@@ -175,6 +259,6 @@ Without these protections, attackers could use DNS rebinding to interact with lo
 For more details, see the [Anthropic's MCP Transport Security docs](https://modelcontextprotocol.io/docs/concepts/transports#security-considerations).

 ### Limitations
-*   **Supported Primitives**: Currently, `MCPServerAdapter` primarily supports adapting MCP `tools`. 
+*   **Supported Primitives**: Currently, `MCPServerAdapter` primarily supports adapting MCP `tools`.
 Other MCP primitives like `prompts` or `resources` are not directly integrated as CrewAI components through this adapter at this time.
 *   **Output Handling**: The adapter typically processes the primary text output from an MCP tool (e.g., `.content[0].text`). Complex or multi-modal outputs might require custom handling if not fitting this pattern.
--- a/Show More
+++ b/Show More