feat: add --no-commit flag to bump command (#4087)

Allows updating version files without creating a commit, branch, or PR.

.env.test

@@ -0,0 +1,161 @@
+# =============================================================================
+# Test Environment Variables
+# =============================================================================
+# This file contains all environment variables needed to run tests locally
+# in a way that mimics the GitHub Actions CI environment.
+
+# =============================================================================
+
+# -----------------------------------------------------------------------------
+# LLM Provider API Keys
+# -----------------------------------------------------------------------------
+OPENAI_API_KEY=fake-api-key
+ANTHROPIC_API_KEY=fake-anthropic-key
+GEMINI_API_KEY=fake-gemini-key
+AZURE_API_KEY=fake-azure-key
+OPENROUTER_API_KEY=fake-openrouter-key
+
+# -----------------------------------------------------------------------------
+# AWS Credentials
+# -----------------------------------------------------------------------------
+AWS_ACCESS_KEY_ID=fake-aws-access-key
+AWS_SECRET_ACCESS_KEY=fake-aws-secret-key
+AWS_DEFAULT_REGION=us-east-1
+AWS_REGION_NAME=us-east-1
+
+# -----------------------------------------------------------------------------
+# Azure OpenAI Configuration
+# -----------------------------------------------------------------------------
+AZURE_ENDPOINT=https://fake-azure-endpoint.openai.azure.com
+AZURE_OPENAI_ENDPOINT=https://fake-azure-endpoint.openai.azure.com
+AZURE_OPENAI_API_KEY=fake-azure-openai-key
+AZURE_API_VERSION=2024-02-15-preview
+OPENAI_API_VERSION=2024-02-15-preview
+
+# -----------------------------------------------------------------------------
+# Google Cloud Configuration
+# -----------------------------------------------------------------------------
+#GOOGLE_CLOUD_PROJECT=fake-gcp-project
+#GOOGLE_CLOUD_LOCATION=us-central1
+
+# -----------------------------------------------------------------------------
+# OpenAI Configuration
+# -----------------------------------------------------------------------------
+OPENAI_BASE_URL=https://api.openai.com/v1
+OPENAI_API_BASE=https://api.openai.com/v1
+
+# -----------------------------------------------------------------------------
+# Search & Scraping Tool API Keys
+# -----------------------------------------------------------------------------
+SERPER_API_KEY=fake-serper-key
+EXA_API_KEY=fake-exa-key
+BRAVE_API_KEY=fake-brave-key
+FIRECRAWL_API_KEY=fake-firecrawl-key
+TAVILY_API_KEY=fake-tavily-key
+SERPAPI_API_KEY=fake-serpapi-key
+SERPLY_API_KEY=fake-serply-key
+LINKUP_API_KEY=fake-linkup-key
+PARALLEL_API_KEY=fake-parallel-key
+
+# -----------------------------------------------------------------------------
+# Exa Configuration
+# -----------------------------------------------------------------------------
+EXA_BASE_URL=https://api.exa.ai
+
+# -----------------------------------------------------------------------------
+# Web Scraping & Automation
+# -----------------------------------------------------------------------------
+BRIGHT_DATA_API_KEY=fake-brightdata-key
+BRIGHT_DATA_ZONE=fake-zone
+BRIGHTDATA_API_URL=https://api.brightdata.com
+BRIGHTDATA_DEFAULT_TIMEOUT=600
+BRIGHTDATA_DEFAULT_POLLING_INTERVAL=1
+
+OXYLABS_USERNAME=fake-oxylabs-user
+OXYLABS_PASSWORD=fake-oxylabs-pass
+
+SCRAPFLY_API_KEY=fake-scrapfly-key
+SCRAPEGRAPH_API_KEY=fake-scrapegraph-key
+
+BROWSERBASE_API_KEY=fake-browserbase-key
+BROWSERBASE_PROJECT_ID=fake-browserbase-project
+
+HYPERBROWSER_API_KEY=fake-hyperbrowser-key
+MULTION_API_KEY=fake-multion-key
+APIFY_API_TOKEN=fake-apify-token
+
+# -----------------------------------------------------------------------------
+# Database & Vector Store Credentials
+# -----------------------------------------------------------------------------
+SINGLESTOREDB_URL=mysql://fake:fake@localhost:3306/fake
+SINGLESTOREDB_HOST=localhost
+SINGLESTOREDB_PORT=3306
+SINGLESTOREDB_USER=fake-user
+SINGLESTOREDB_PASSWORD=fake-password
+SINGLESTOREDB_DATABASE=fake-database
+SINGLESTOREDB_CONNECT_TIMEOUT=30
+
+SNOWFLAKE_USER=fake-snowflake-user
+SNOWFLAKE_PASSWORD=fake-snowflake-password
+SNOWFLAKE_ACCOUNT=fake-snowflake-account
+SNOWFLAKE_WAREHOUSE=fake-snowflake-warehouse
+SNOWFLAKE_DATABASE=fake-snowflake-database
+SNOWFLAKE_SCHEMA=fake-snowflake-schema
+
+WEAVIATE_URL=http://localhost:8080
+WEAVIATE_API_KEY=fake-weaviate-key
+
+EMBEDCHAIN_DB_URI=sqlite:///test.db
+
+# Databricks Credentials
+DATABRICKS_HOST=https://fake-databricks.cloud.databricks.com
+DATABRICKS_TOKEN=fake-databricks-token
+DATABRICKS_CONFIG_PROFILE=fake-profile
+
+# MongoDB Credentials
+MONGODB_URI=mongodb://fake:fake@localhost:27017/fake
+
+# -----------------------------------------------------------------------------
+# CrewAI Platform & Enterprise
+# -----------------------------------------------------------------------------
+# setting CREWAI_PLATFORM_INTEGRATION_TOKEN causes these test to fail:
+#=========================== short test summary info ============================
+#FAILED tests/test_context.py::TestPlatformIntegrationToken::test_platform_context_manager_basic_usage - AssertionError: assert 'fake-platform-token' is None
+# +  where 'fake-platform-token' = get_platform_integration_token()
+#FAILED tests/test_context.py::TestPlatformIntegrationToken::test_context_var_isolation_between_tests - AssertionError: assert 'fake-platform-token' is None
+# +  where 'fake-platform-token' = get_platform_integration_token()
+#FAILED tests/test_context.py::TestPlatformIntegrationToken::test_multiple_sequential_context_managers - AssertionError: assert 'fake-platform-token' is None
+# +  where 'fake-platform-token' = get_platform_integration_token()
+#CREWAI_PLATFORM_INTEGRATION_TOKEN=fake-platform-token
+CREWAI_PERSONAL_ACCESS_TOKEN=fake-personal-token
+CREWAI_PLUS_URL=https://fake.crewai.com
+
+# -----------------------------------------------------------------------------
+# Other Service API Keys
+# -----------------------------------------------------------------------------
+ZAPIER_API_KEY=fake-zapier-key
+PATRONUS_API_KEY=fake-patronus-key
+MINDS_API_KEY=fake-minds-key
+HF_TOKEN=fake-hf-token
+
+# -----------------------------------------------------------------------------
+# Feature Flags/Testing Modes
+# -----------------------------------------------------------------------------
+CREWAI_DISABLE_TELEMETRY=true
+OTEL_SDK_DISABLED=true
+CREWAI_TESTING=true
+CREWAI_TRACING_ENABLED=false
+
+# -----------------------------------------------------------------------------
+# Testing/CI Configuration
+# -----------------------------------------------------------------------------
+# VCR recording mode: "none" (default), "new_episodes", "all", "once"
+PYTEST_VCR_RECORD_MODE=none
+
+# Set to "true" by GitHub when running in GitHub Actions
+# GITHUB_ACTIONS=false
+
+# -----------------------------------------------------------------------------
+# Python Configuration
+# -----------------------------------------------------------------------------
+PYTHONUNBUFFERED=1

.github/workflows/tests.yml

@@ -5,18 +5,6 @@ on: [pull_request]
 permissions:
   contents: read
 
-env:
-  OPENAI_API_KEY: fake-api-key
-  PYTHONUNBUFFERED: 1
-  BRAVE_API_KEY: fake-brave-key
-  SNOWFLAKE_USER: fake-snowflake-user
-  SNOWFLAKE_PASSWORD: fake-snowflake-password
-  SNOWFLAKE_ACCOUNT: fake-snowflake-account
-  SNOWFLAKE_WAREHOUSE: fake-snowflake-warehouse
-  SNOWFLAKE_DATABASE: fake-snowflake-database
-  SNOWFLAKE_SCHEMA: fake-snowflake-schema
-  EMBEDCHAIN_DB_URI: sqlite:///test.db
-
 jobs:
   tests:
     name: tests (${{ matrix.python-version }})
@@ -84,26 +72,20 @@ jobs:
           # fi
 
           cd lib/crewai && uv run pytest \
-            --block-network \
-            --timeout=30 \
             -vv \
             --splits 8 \
             --group ${{ matrix.group }} \
             $DURATIONS_ARG \
             --durations=10 \
-            -n auto \
             --maxfail=3
 
       - name: Run tool tests (group ${{ matrix.group }} of 8)
         run: |
           cd lib/crewai-tools && uv run pytest \
-            --block-network \
-            --timeout=30 \
             -vv \
             --splits 8 \
             --group ${{ matrix.group }} \
             --durations=10 \
-            -n auto \
             --maxfail=3
 
 

README.md

@@ -62,9 +62,9 @@
 With over 100,000 developers certified through our community courses at [learn.crewai.com](https://learn.crewai.com), CrewAI is rapidly becoming the
 standard for enterprise-ready AI automation.
 
-# CrewAI AMP Suite
+# CrewAI AOP Suite
 
-CrewAI AMP Suite is a comprehensive bundle tailored for organizations that require secure, scalable, and easy-to-manage agent-driven automation.
+CrewAI AOP Suite is a comprehensive bundle tailored for organizations that require secure, scalable, and easy-to-manage agent-driven automation.
 
 You can try one part of the suite the [Crew Control Plane for free](https://app.crewai.com)
 
@@ -76,9 +76,9 @@ You can try one part of the suite the [Crew Control Plane for free](https://app.
 - **Advanced Security**: Built-in robust security and compliance measures ensuring safe deployment and management.
 - **Actionable Insights**: Real-time analytics and reporting to optimize performance and decision-making.
 - **24/7 Support**: Dedicated enterprise support to ensure uninterrupted operation and quick resolution of issues.
-- **On-premise and Cloud Deployment Options**: Deploy CrewAI AMP on-premise or in the cloud, depending on your security and compliance requirements.
+- **On-premise and Cloud Deployment Options**: Deploy CrewAI AOP on-premise or in the cloud, depending on your security and compliance requirements.
 
-CrewAI AMP is designed for enterprises seeking a powerful, reliable solution to transform complex business processes into efficient,
+CrewAI AOP is designed for enterprises seeking a powerful, reliable solution to transform complex business processes into efficient,
 intelligent automations.
 
 ## Table of contents
@@ -674,9 +674,9 @@ CrewAI is released under the [MIT License](https://github.com/crewAIInc/crewAI/b
 
 ### Enterprise Features
 
-- [What additional features does CrewAI AMP offer?](#q-what-additional-features-does-crewai-amp-offer)
-- [Is CrewAI AMP available for cloud and on-premise deployments?](#q-is-crewai-amp-available-for-cloud-and-on-premise-deployments)
-- [Can I try CrewAI AMP for free?](#q-can-i-try-crewai-amp-for-free)
+- [What additional features does CrewAI AOP offer?](#q-what-additional-features-does-crewai-amp-offer)
+- [Is CrewAI AOP available for cloud and on-premise deployments?](#q-is-crewai-amp-available-for-cloud-and-on-premise-deployments)
+- [Can I try CrewAI AOP for free?](#q-can-i-try-crewai-amp-for-free)
 
 ### Q: What exactly is CrewAI?
 
@@ -732,17 +732,17 @@ A: Check out practical examples in the [CrewAI-examples repository](https://gith
 
 A: Contributions are warmly welcomed! Fork the repository, create your branch, implement your changes, and submit a pull request. See the Contribution section of the README for detailed guidelines.
 
-### Q: What additional features does CrewAI AMP offer?
+### Q: What additional features does CrewAI AOP offer?
 
-A: CrewAI AMP provides advanced features such as a unified control plane, real-time observability, secure integrations, advanced security, actionable insights, and dedicated 24/7 enterprise support.
+A: CrewAI AOP provides advanced features such as a unified control plane, real-time observability, secure integrations, advanced security, actionable insights, and dedicated 24/7 enterprise support.
 
-### Q: Is CrewAI AMP available for cloud and on-premise deployments?
+### Q: Is CrewAI AOP available for cloud and on-premise deployments?
 
-A: Yes, CrewAI AMP supports both cloud-based and on-premise deployment options, allowing enterprises to meet their specific security and compliance requirements.
+A: Yes, CrewAI AOP supports both cloud-based and on-premise deployment options, allowing enterprises to meet their specific security and compliance requirements.
 
-### Q: Can I try CrewAI AMP for free?
+### Q: Can I try CrewAI AOP for free?
 
-A: Yes, you can explore part of the CrewAI AMP Suite by accessing the [Crew Control Plane](https://app.crewai.com) for free.
+A: Yes, you can explore part of the CrewAI AOP Suite by accessing the [Crew Control Plane](https://app.crewai.com) for free.
 
 ### Q: Does CrewAI support fine-tuning or training custom models?
 
@@ -762,7 +762,7 @@ A: CrewAI is highly scalable, supporting simple automations and large-scale ente
 
 ### Q: Does CrewAI offer debugging and monitoring tools?
 
-A: Yes, CrewAI AMP includes advanced debugging, tracing, and real-time observability features, simplifying the management and troubleshooting of your automations.
+A: Yes, CrewAI AOP includes advanced debugging, tracing, and real-time observability features, simplifying the management and troubleshooting of your automations.
 
 ### Q: What programming languages does CrewAI support?
 

conftest.py

@@ -0,0 +1,197 @@
+"""Pytest configuration for crewAI workspace."""
+
+from collections.abc import Generator
+import os
+from pathlib import Path
+import tempfile
+from typing import Any
+
+from dotenv import load_dotenv
+import pytest
+from vcr.request import Request  # type: ignore[import-untyped]
+
+
+env_test_path = Path(__file__).parent / ".env.test"
+load_dotenv(env_test_path, override=True)
+load_dotenv(override=True)
+
+
+@pytest.fixture(autouse=True, scope="function")
+def cleanup_event_handlers() -> Generator[None, Any, None]:
+    """Clean up event bus handlers after each test to prevent test pollution."""
+    yield
+
+    try:
+        from crewai.events.event_bus import crewai_event_bus
+
+        with crewai_event_bus._rwlock.w_locked():
+            crewai_event_bus._sync_handlers.clear()
+            crewai_event_bus._async_handlers.clear()
+    except Exception:  # noqa: S110
+        pass
+
+
+@pytest.fixture(autouse=True, scope="function")
+def setup_test_environment() -> Generator[None, Any, None]:
+    """Setup test environment for crewAI workspace."""
+    with tempfile.TemporaryDirectory() as temp_dir:
+        storage_dir = Path(temp_dir) / "crewai_test_storage"
+        storage_dir.mkdir(parents=True, exist_ok=True)
+
+        if not storage_dir.exists() or not storage_dir.is_dir():
+            raise RuntimeError(
+                f"Failed to create test storage directory: {storage_dir}"
+            )
+
+        try:
+            test_file = storage_dir / ".permissions_test"
+            test_file.touch()
+            test_file.unlink()
+        except (OSError, IOError) as e:
+            raise RuntimeError(
+                f"Test storage directory {storage_dir} is not writable: {e}"
+            ) from e
+
+        os.environ["CREWAI_STORAGE_DIR"] = str(storage_dir)
+        os.environ["CREWAI_TESTING"] = "true"
+
+        try:
+            yield
+        finally:
+            os.environ.pop("CREWAI_TESTING", "true")
+            os.environ.pop("CREWAI_STORAGE_DIR", None)
+            os.environ.pop("CREWAI_DISABLE_TELEMETRY", "true")
+            os.environ.pop("OTEL_SDK_DISABLED", "true")
+            os.environ.pop("OPENAI_BASE_URL", "https://api.openai.com/v1")
+            os.environ.pop("OPENAI_API_BASE", "https://api.openai.com/v1")
+
+
+HEADERS_TO_FILTER = {
+    "authorization": "AUTHORIZATION-XXX",
+    "content-security-policy": "CSP-FILTERED",
+    "cookie": "COOKIE-XXX",
+    "set-cookie": "SET-COOKIE-XXX",
+    "permissions-policy": "PERMISSIONS-POLICY-XXX",
+    "referrer-policy": "REFERRER-POLICY-XXX",
+    "strict-transport-security": "STS-XXX",
+    "x-content-type-options": "X-CONTENT-TYPE-XXX",
+    "x-frame-options": "X-FRAME-OPTIONS-XXX",
+    "x-permitted-cross-domain-policies": "X-PERMITTED-XXX",
+    "x-request-id": "X-REQUEST-ID-XXX",
+    "x-runtime": "X-RUNTIME-XXX",
+    "x-xss-protection": "X-XSS-PROTECTION-XXX",
+    "x-stainless-arch": "X-STAINLESS-ARCH-XXX",
+    "x-stainless-os": "X-STAINLESS-OS-XXX",
+    "x-stainless-read-timeout": "X-STAINLESS-READ-TIMEOUT-XXX",
+    "cf-ray": "CF-RAY-XXX",
+    "etag": "ETAG-XXX",
+    "Strict-Transport-Security": "STS-XXX",
+    "access-control-expose-headers": "ACCESS-CONTROL-XXX",
+    "openai-organization": "OPENAI-ORG-XXX",
+    "openai-project": "OPENAI-PROJECT-XXX",
+    "x-ratelimit-limit-requests": "X-RATELIMIT-LIMIT-REQUESTS-XXX",
+    "x-ratelimit-limit-tokens": "X-RATELIMIT-LIMIT-TOKENS-XXX",
+    "x-ratelimit-remaining-requests": "X-RATELIMIT-REMAINING-REQUESTS-XXX",
+    "x-ratelimit-remaining-tokens": "X-RATELIMIT-REMAINING-TOKENS-XXX",
+    "x-ratelimit-reset-requests": "X-RATELIMIT-RESET-REQUESTS-XXX",
+    "x-ratelimit-reset-tokens": "X-RATELIMIT-RESET-TOKENS-XXX",
+    "x-goog-api-key": "X-GOOG-API-KEY-XXX",
+    "api-key": "X-API-KEY-XXX",
+    "User-Agent": "X-USER-AGENT-XXX",
+    "apim-request-id:": "X-API-CLIENT-REQUEST-ID-XXX",
+    "azureml-model-session": "AZUREML-MODEL-SESSION-XXX",
+    "x-ms-client-request-id": "X-MS-CLIENT-REQUEST-ID-XXX",
+    "x-ms-region": "X-MS-REGION-XXX",
+    "apim-request-id": "APIM-REQUEST-ID-XXX",
+    "x-api-key": "X-API-KEY-XXX",
+    "anthropic-organization-id": "ANTHROPIC-ORGANIZATION-ID-XXX",
+    "request-id": "REQUEST-ID-XXX",
+    "anthropic-ratelimit-input-tokens-limit": "ANTHROPIC-RATELIMIT-INPUT-TOKENS-LIMIT-XXX",
+    "anthropic-ratelimit-input-tokens-remaining": "ANTHROPIC-RATELIMIT-INPUT-TOKENS-REMAINING-XXX",
+    "anthropic-ratelimit-input-tokens-reset": "ANTHROPIC-RATELIMIT-INPUT-TOKENS-RESET-XXX",
+    "anthropic-ratelimit-output-tokens-limit": "ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-LIMIT-XXX",
+    "anthropic-ratelimit-output-tokens-remaining": "ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-REMAINING-XXX",
+    "anthropic-ratelimit-output-tokens-reset": "ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-RESET-XXX",
+    "anthropic-ratelimit-tokens-limit": "ANTHROPIC-RATELIMIT-TOKENS-LIMIT-XXX",
+    "anthropic-ratelimit-tokens-remaining": "ANTHROPIC-RATELIMIT-TOKENS-REMAINING-XXX",
+    "anthropic-ratelimit-tokens-reset": "ANTHROPIC-RATELIMIT-TOKENS-RESET-XXX",
+    "x-amz-date": "X-AMZ-DATE-XXX",
+    "amz-sdk-invocation-id": "AMZ-SDK-INVOCATION-ID-XXX",
+    "accept-encoding": "ACCEPT-ENCODING-XXX",
+    "x-amzn-requestid": "X-AMZN-REQUESTID-XXX",
+    "x-amzn-RequestId": "X-AMZN-REQUESTID-XXX",
+}
+
+
+def _filter_request_headers(request: Request) -> Request:  # type: ignore[no-any-unimported]
+    """Filter sensitive headers from request before recording."""
+    for header_name, replacement in HEADERS_TO_FILTER.items():
+        for variant in [header_name, header_name.upper(), header_name.title()]:
+            if variant in request.headers:
+                request.headers[variant] = [replacement]
+
+    request.method = request.method.upper()
+    return request
+
+
+def _filter_response_headers(response: dict[str, Any]) -> dict[str, Any]:
+    """Filter sensitive headers from response before recording."""
+    # Remove Content-Encoding to prevent decompression issues on replay
+    for encoding_header in ["Content-Encoding", "content-encoding"]:
+        response["headers"].pop(encoding_header, None)
+
+    for header_name, replacement in HEADERS_TO_FILTER.items():
+        for variant in [header_name, header_name.upper(), header_name.title()]:
+            if variant in response["headers"]:
+                response["headers"][variant] = [replacement]
+    return response
+
+
+@pytest.fixture(scope="module")
+def vcr_cassette_dir(request: Any) -> str:
+    """Generate cassette directory path based on test module location.
+
+    Organizes cassettes to mirror test directory structure within each package:
+    lib/crewai/tests/llms/google/test_google.py -> lib/crewai/tests/cassettes/llms/google/
+    lib/crewai-tools/tests/tools/test_search.py -> lib/crewai-tools/tests/cassettes/tools/
+    """
+    test_file = Path(request.fspath)
+
+    for parent in test_file.parents:
+        if parent.name in ("crewai", "crewai-tools") and parent.parent.name == "lib":
+            package_root = parent
+            break
+    else:
+        package_root = test_file.parent
+
+    tests_root = package_root / "tests"
+    test_dir = test_file.parent
+
+    if test_dir != tests_root:
+        relative_path = test_dir.relative_to(tests_root)
+        cassette_dir = tests_root / "cassettes" / relative_path
+    else:
+        cassette_dir = tests_root / "cassettes"
+
+    cassette_dir.mkdir(parents=True, exist_ok=True)
+
+    return str(cassette_dir)
+
+
+@pytest.fixture(scope="module")
+def vcr_config(vcr_cassette_dir: str) -> dict[str, Any]:
+    """Configure VCR with organized cassette storage."""
+    config = {
+        "cassette_library_dir": vcr_cassette_dir,
+        "record_mode": os.getenv("PYTEST_VCR_RECORD_MODE", "once"),
+        "filter_headers": [(k, v) for k, v in HEADERS_TO_FILTER.items()],
+        "before_record_request": _filter_request_headers,
+        "before_record_response": _filter_response_headers,
+        "filter_query_parameters": ["key"],
+        "match_on": ["method", "scheme", "host", "port", "path"],
+    }
+
+    if os.getenv("GITHUB_ACTIONS") == "true":
+        config["record_mode"] = "none"
+
+    return config

docs/docs.json

@@ -253,7 +253,8 @@
                     "pages": [
                       "en/tools/integration/overview",
                       "en/tools/integration/bedrockinvokeagenttool",
-                      "en/tools/integration/crewaiautomationtool"
+                      "en/tools/integration/crewaiautomationtool",
+                      "en/tools/integration/mergeagenthandlertool"
                     ]
                   },
                   {
@@ -326,7 +327,7 @@
             ]
           },
           {
-            "tab": "AMP",
+            "tab": "AOP",
             "icon": "briefcase",
             "groups": [
               {
@@ -753,7 +754,7 @@
             ]
           },
           {
-            "tab": "AMP",
+            "tab": "AOP",
             "icon": "briefcase",
             "groups": [
               {

docs/en/api-reference/introduction.mdx

@@ -1,19 +1,19 @@
 ---
 title: "Introduction"
-description: "Complete reference for the CrewAI AMP REST API"
+description: "Complete reference for the CrewAI AOP REST API"
 icon: "code"
 mode: "wide"
 ---
 
-# CrewAI AMP API
+# CrewAI AOP API
 
-Welcome to the CrewAI AMP API reference. This API allows you to programmatically interact with your deployed crews, enabling integration with your applications, workflows, and services.
+Welcome to the CrewAI AOP API reference. This API allows you to programmatically interact with your deployed crews, enabling integration with your applications, workflows, and services.
 
 ## Quick Start
 
 <Steps>
   <Step title="Get Your API Credentials">
-    Navigate to your crew's detail page in the CrewAI AMP dashboard and copy your Bearer Token from the Status tab.
+    Navigate to your crew's detail page in the CrewAI AOP dashboard and copy your Bearer Token from the Status tab.
   </Step>
 
   <Step title="Discover Required Inputs">
@@ -46,7 +46,7 @@ curl -H "Authorization: Bearer YOUR_CREW_TOKEN" \
 | **User Bearer Token** | User-scoped access | Limited permissions, suitable for user-specific operations |
 
 <Tip>
-You can find both token types in the Status tab of your crew's detail page in the CrewAI AMP dashboard.
+You can find both token types in the Status tab of your crew's detail page in the CrewAI AOP dashboard.
 </Tip>
 
 ## Base URL
@@ -82,7 +82,7 @@ The API uses standard HTTP status codes:
 ## Interactive Testing
 
 <Info>
-**Why no "Send" button?** Since each CrewAI AMP user has their own unique crew URL, we use **reference mode** instead of an interactive playground to avoid confusion. This shows you exactly what the requests should look like without non-functional send buttons.
+**Why no "Send" button?** Since each CrewAI AOP user has their own unique crew URL, we use **reference mode** instead of an interactive playground to avoid confusion. This shows you exactly what the requests should look like without non-functional send buttons.
 </Info>
 
 Each endpoint page shows you:

docs/en/concepts/agents.mdx

@@ -20,7 +20,7 @@ Think of an agent as a specialized team member with specific skills, expertise,
 </Tip>
 
 <Note type="info" title="Enterprise Enhancement: Visual Agent Builder">
-CrewAI AMP includes a Visual Agent Builder that simplifies agent creation and configuration without writing code. Design your agents visually and test them in real-time.
+CrewAI AOP includes a Visual Agent Builder that simplifies agent creation and configuration without writing code. Design your agents visually and test them in real-time.
 
 ![Visual Agent Builder Screenshot](/images/enterprise/crew-studio-interface.png)
 

docs/en/concepts/cli.mdx

@@ -5,7 +5,7 @@ icon: terminal
 mode: "wide"
 ---
 
-<Warning>Since release 0.140.0, CrewAI AMP 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>
+<Warning>Since release 0.140.0, CrewAI AOP 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
 
@@ -186,9 +186,9 @@ def crew(self) -> Crew:
 
 ### 10. Deploy
 
-Deploy the crew or flow to [CrewAI AMP](https://app.crewai.com).
+Deploy the crew or flow to [CrewAI AOP](https://app.crewai.com).
 
-- **Authentication**: You need to be authenticated to deploy to CrewAI AMP.
+- **Authentication**: You need to be authenticated to deploy to CrewAI AOP.
     You can login or create an account with:
     ```shell Terminal
     crewai login
@@ -203,7 +203,7 @@ Deploy the crew or flow to [CrewAI AMP](https://app.crewai.com).
 
 ### 11. Organization Management
 
-Manage your CrewAI AMP organizations.
+Manage your CrewAI AOP organizations.
 
 ```shell Terminal
 crewai org [COMMAND] [OPTIONS]
@@ -227,17 +227,17 @@ crewai org switch <organization_id>
 ```
 
 <Note>
-You must be authenticated to CrewAI AMP to use these organization management commands.
+You must be authenticated to CrewAI AOP to use these organization management commands.
 </Note>
 
 - **Create a deployment** (continued):
     - Links the deployment to the corresponding remote GitHub repository (it usually detects this automatically).
 
-- **Deploy the Crew**: Once you are authenticated, you can deploy your crew or flow to CrewAI AMP.
+- **Deploy the Crew**: Once you are authenticated, you can deploy your crew or flow to CrewAI AOP.
     ```shell Terminal
     crewai deploy push
     ```
-    - Initiates the deployment process on the CrewAI AMP platform.
+    - Initiates the deployment process on the CrewAI AOP platform.
     - Upon successful initiation, it will output the Deployment created successfully! message along with the Deployment Name and a unique Deployment ID (UUID).
 
 - **Deployment Status**: You can check the status of your deployment with:
@@ -262,7 +262,7 @@ You must be authenticated to CrewAI AMP to use these organization management com
     ```shell Terminal
     crewai deploy remove
     ```
-    This deletes the deployment from the CrewAI AMP platform.
+    This deletes the deployment from the CrewAI AOP platform.
 
 - **Help Command**: You can get help with the CLI with:
     ```shell Terminal
@@ -270,7 +270,7 @@ You must be authenticated to CrewAI AMP to use these organization management com
     ```
     This shows the help message for the CrewAI Deploy CLI.
 
-Watch this video tutorial for a step-by-step demonstration of deploying your crew to [CrewAI AMP](http://app.crewai.com) using the CLI.
+Watch this video tutorial for a step-by-step demonstration of deploying your crew to [CrewAI AOP](http://app.crewai.com) using the CLI.
 
 <iframe
   className="w-full aspect-video rounded-xl"
@@ -283,7 +283,7 @@ Watch this video tutorial for a step-by-step demonstration of deploying your cre
 
 ### 11. Login
 
-Authenticate with CrewAI AMP using a secure device code flow (no email entry required).
+Authenticate with CrewAI AOP using a secure device code flow (no email entry required).
 
 ```shell Terminal
 crewai login
@@ -354,7 +354,7 @@ crewai config reset
 
 #### Available Configuration Parameters
 
-- `enterprise_base_url`: Base URL of the CrewAI AMP instance
+- `enterprise_base_url`: Base URL of the CrewAI AOP 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
@@ -370,7 +370,7 @@ crewai config list
 Example output:
 | Setting             | Value                    | Description                                                 |
 | :------------------ | :----------------------- | :---------------------------------------------------------- |
-| enterprise_base_url | https://app.crewai.com   | Base URL of the CrewAI AMP instance                  |
+| enterprise_base_url | https://app.crewai.com   | Base URL of the CrewAI AOP 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 (e.g., workos, okta, auth0)                 |

docs/en/concepts/crews.mdx

@@ -33,6 +33,7 @@ A crew in crewAI represents a collaborative group of agents working together to
 | **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.                                                                                                                                                                                    |
+| **Stream** _(optional)_               | `stream`               | Enable streaming output to receive real-time updates during crew execution. Returns a `CrewStreamingOutput` object that can be iterated for chunks. Defaults to `False`.                                                                                    |
 
 <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.
@@ -306,12 +307,27 @@ print(result)
 
 ### Different Ways to Kick Off a Crew
 
-Once your crew is assembled, initiate the workflow with the appropriate kickoff method. CrewAI provides several methods for better control over the kickoff process: `kickoff()`, `kickoff_for_each()`, `kickoff_async()`, and `kickoff_for_each_async()`.
+Once your crew is assembled, initiate the workflow with the appropriate kickoff method. CrewAI provides several methods for better control over the kickoff process.
+
+#### Synchronous Methods
 
 - `kickoff()`: Starts the execution process according to the defined process flow.
 - `kickoff_for_each()`: Executes tasks sequentially for each provided input event or item in the collection.
-- `kickoff_async()`: Initiates the workflow asynchronously.
-- `kickoff_for_each_async()`: Executes tasks concurrently for each provided input event or item, leveraging asynchronous processing.
+
+#### Asynchronous Methods
+
+CrewAI offers two approaches for async execution:
+
+| Method | Type | Description |
+|--------|------|-------------|
+| `akickoff()` | Native async | True async/await throughout the entire execution chain |
+| `akickoff_for_each()` | Native async | Native async execution for each input in a list |
+| `kickoff_async()` | Thread-based | Wraps synchronous execution in `asyncio.to_thread` |
+| `kickoff_for_each_async()` | Thread-based | Thread-based async for each input in a list |
+
+<Note>
+For high-concurrency workloads, `akickoff()` and `akickoff_for_each()` are recommended as they use native async for task execution, memory operations, and knowledge retrieval.
+</Note>
 
 ```python Code
 # Start the crew's task execution
@@ -324,19 +340,53 @@ results = my_crew.kickoff_for_each(inputs=inputs_array)
 for result in results:
     print(result)
 
-# Example of using kickoff_async
+# Example of using native async with akickoff
+inputs = {'topic': 'AI in healthcare'}
+async_result = await my_crew.akickoff(inputs=inputs)
+print(async_result)
+
+# Example of using native async with akickoff_for_each
+inputs_array = [{'topic': 'AI in healthcare'}, {'topic': 'AI in finance'}]
+async_results = await my_crew.akickoff_for_each(inputs=inputs_array)
+for async_result in async_results:
+    print(async_result)
+
+# Example of using thread-based kickoff_async
 inputs = {'topic': 'AI in healthcare'}
 async_result = await my_crew.kickoff_async(inputs=inputs)
 print(async_result)
 
-# Example of using kickoff_for_each_async
+# Example of using thread-based kickoff_for_each_async
 inputs_array = [{'topic': 'AI in healthcare'}, {'topic': 'AI in finance'}]
 async_results = await my_crew.kickoff_for_each_async(inputs=inputs_array)
 for async_result in async_results:
     print(async_result)
 ```
 
-These methods provide flexibility in how you manage and execute tasks within your crew, allowing for both synchronous and asynchronous workflows tailored to your needs.
+These methods provide flexibility in how you manage and execute tasks within your crew, allowing for both synchronous and asynchronous workflows tailored to your needs. For detailed async examples, see the [Kickoff Crew Asynchronously](/en/learn/kickoff-async) guide.
+
+### Streaming Crew Execution
+
+For real-time visibility into crew execution, you can enable streaming to receive output as it's generated:
+
+```python Code
+# Enable streaming
+crew = Crew(
+    agents=[researcher],
+    tasks=[task],
+    stream=True
+)
+
+# Iterate over streaming output
+streaming = crew.kickoff(inputs={"topic": "AI"})
+for chunk in streaming:
+    print(chunk.content, end="", flush=True)
+
+# Access final result
+result = streaming.result
+```
+
+Learn more about streaming in the [Streaming Crew Execution](/en/learn/streaming-crew-execution) guide.
 
 ### Replaying from a Specific Task
 

docs/en/concepts/event-listener.mdx

@@ -20,7 +20,7 @@ CrewAI uses an event bus architecture to emit events throughout the execution li
 When specific actions occur in CrewAI (like a Crew starting execution, an Agent completing a task, or a tool being used), the system emits corresponding events. You can register handlers for these events to execute custom code when they occur.
 
 <Note type="info" title="Enterprise Enhancement: Prompt Tracing">
-CrewAI AMP provides a built-in Prompt Tracing feature that leverages the event system to track, store, and visualize all prompts, completions, and associated metadata. This provides powerful debugging capabilities and transparency into your agent operations.
+CrewAI AOP provides a built-in Prompt Tracing feature that leverages the event system to track, store, and visualize all prompts, completions, and associated metadata. This provides powerful debugging capabilities and transparency into your agent operations.
 
 ![Prompt Tracing Dashboard](/images/enterprise/traces-overview.png)
 

docs/en/concepts/flows.mdx

@@ -897,6 +897,31 @@ flow = ExampleFlow()
 result = flow.kickoff()
 ```
 
+### Streaming Flow Execution
+
+For real-time visibility into flow execution, you can enable streaming to receive output as it's generated:
+
+```python
+class StreamingFlow(Flow):
+    stream = True  # Enable streaming
+
+    @start()
+    def research(self):
+        # Your flow implementation
+        pass
+
+# Iterate over streaming output
+flow = StreamingFlow()
+streaming = flow.kickoff()
+for chunk in streaming:
+    print(chunk.content, end="", flush=True)
+
+# Access final result
+result = streaming.result
+```
+
+Learn more about streaming in the [Streaming Flow Execution](/en/learn/streaming-flow-execution) guide.
+
 ### Using the CLI
 
 Starting from version 0.103.0, you can run flows using the `crewai run` command:

docs/en/concepts/knowledge.mdx

@@ -388,8 +388,8 @@ crew = Crew(
     agents=[sales_agent, tech_agent, support_agent],
     tasks=[...],
     embedder={  # Fallback embedder for agents without their own
-        "provider": "google",
-        "config": {"model": "text-embedding-004"}
+        "provider": "google-generativeai",
+        "config": {"model_name": "gemini-embedding-001"}
     }
 )
 
@@ -629,9 +629,9 @@ agent = Agent(
     backstory="Expert researcher",
     knowledge_sources=[knowledge_source],
     embedder={
-        "provider": "google",
+        "provider": "google-generativeai",
         "config": {
-            "model": "models/text-embedding-004",
+            "model_name": "gemini-embedding-001",
             "api_key": "your-google-key"
         }
     }

docs/en/concepts/llms.mdx

@@ -283,11 +283,54 @@ In this section, you'll find detailed examples that help you select, configure,
     )
     ```
 
+    **Extended Thinking (Claude Sonnet 4 and Beyond):**
+
+    CrewAI supports Anthropic's Extended Thinking feature, which allows Claude to think through problems in a more human-like way before responding. This is particularly useful for complex reasoning, analysis, and problem-solving tasks.
+
+    ```python Code
+    from crewai import LLM
+
+    # Enable extended thinking with default settings
+    llm = LLM(
+        model="anthropic/claude-sonnet-4",
+        thinking={"type": "enabled"},
+        max_tokens=10000
+    )
+
+    # Configure thinking with budget control
+    llm = LLM(
+        model="anthropic/claude-sonnet-4",
+        thinking={
+            "type": "enabled",
+            "budget_tokens": 5000  # Limit thinking tokens
+        },
+        max_tokens=10000
+    )
+    ```
+
+    **Thinking Configuration Options:**
+    - `type`: Set to `"enabled"` to activate extended thinking mode
+    - `budget_tokens` (optional): Maximum tokens to use for thinking (helps control costs)
+
+    **Models Supporting Extended Thinking:**
+    - `claude-sonnet-4` and newer models
+    - `claude-3-7-sonnet` (with extended thinking capabilities)
+
+    **When to Use Extended Thinking:**
+    - Complex reasoning and multi-step problem solving
+    - Mathematical calculations and proofs
+    - Code analysis and debugging
+    - Strategic planning and decision making
+    - Research and analytical tasks
+
+    **Note:** Extended thinking consumes additional tokens but can significantly improve response quality for complex tasks.
+
     **Supported Environment Variables:**
     - `ANTHROPIC_API_KEY`: Your Anthropic API key (required)
 
     **Features:**
     - Native tool use support for Claude 3+ models
+    - Extended Thinking support for Claude Sonnet 4+
     - Streaming support for real-time responses
     - Automatic system message handling
     - Stop sequences for controlled output
@@ -305,6 +348,7 @@ In this section, you'll find detailed examples that help you select, configure,
 
     | Model                        | Context Window | Best For                                      |
     |------------------------------|----------------|-----------------------------------------------|
+    | claude-sonnet-4              | 200,000 tokens | Latest with extended thinking capabilities    |
     | claude-3-7-sonnet            | 200,000 tokens | Advanced reasoning and agentic tasks          |
     | claude-3-5-sonnet-20241022   | 200,000 tokens | Latest Sonnet with best performance           |
     | claude-3-5-haiku             | 200,000 tokens | Fast, compact model for quick responses       |
@@ -1089,6 +1133,50 @@ CrewAI supports streaming responses from LLMs, allowing your application to rece
   </Tab>
 </Tabs>
 
+## Async LLM Calls
+
+CrewAI supports asynchronous LLM calls for improved performance and concurrency in your AI workflows. Async calls allow you to run multiple LLM requests concurrently without blocking, making them ideal for high-throughput applications and parallel agent operations.
+
+<Tabs>
+  <Tab title="Basic Usage">
+    Use the `acall` method for asynchronous LLM requests:
+
+    ```python
+    import asyncio
+    from crewai import LLM
+
+    async def main():
+        llm = LLM(model="openai/gpt-4o")
+
+        # Single async call
+        response = await llm.acall("What is the capital of France?")
+        print(response)
+
+    asyncio.run(main())
+    ```
+
+    The `acall` method supports all the same parameters as the synchronous `call` method, including messages, tools, and callbacks.
+  </Tab>
+
+  <Tab title="With Streaming">
+    Combine async calls with streaming for real-time concurrent responses:
+
+    ```python
+    import asyncio
+    from crewai import LLM
+
+    async def stream_async():
+        llm = LLM(model="openai/gpt-4o", stream=True)
+
+        response = await llm.acall("Write a short story about AI")
+
+        print(response)
+
+    asyncio.run(stream_async())
+    ```
+  </Tab>
+</Tabs>
+
 ## Structured LLM Calls
 
 CrewAI supports structured responses from LLM calls by allowing you to define a `response_format` using a Pydantic model. This enables the framework to automatically parse and validate the output, making it easier to integrate the response into your application without manual post-processing.

docs/en/concepts/memory.mdx

@@ -341,7 +341,7 @@ crew = Crew(
     embedder={
         "provider": "openai",
         "config": {
-            "model": "text-embedding-3-small"  # or "text-embedding-3-large"
+            "model_name": "text-embedding-3-small"  # or "text-embedding-3-large"
         }
     }
 )
@@ -353,7 +353,7 @@ crew = Crew(
         "provider": "openai",
         "config": {
             "api_key": "your-openai-api-key",  # Optional: override env var
-            "model": "text-embedding-3-large",
+            "model_name": "text-embedding-3-large",
             "dimensions": 1536,  # Optional: reduce dimensions for smaller storage
             "organization_id": "your-org-id"  # Optional: for organization accounts
         }
@@ -375,7 +375,7 @@ crew = Crew(
             "api_base": "https://your-resource.openai.azure.com/",
             "api_type": "azure",
             "api_version": "2023-05-15",
-            "model": "text-embedding-3-small",
+            "model_name": "text-embedding-3-small",
             "deployment_id": "your-deployment-name"  # Azure deployment name
         }
     }
@@ -390,10 +390,10 @@ Use Google's text embedding models for integration with Google Cloud services.
 crew = Crew(
     memory=True,
     embedder={
-        "provider": "google",
+        "provider": "google-generativeai",
         "config": {
             "api_key": "your-google-api-key",
-            "model": "text-embedding-004"  # or "text-embedding-preview-0409"
+            "model_name": "gemini-embedding-001"  # or "text-embedding-005", "text-multilingual-embedding-002"
         }
     }
 )
@@ -461,7 +461,7 @@ crew = Crew(
         "provider": "cohere",
         "config": {
             "api_key": "your-cohere-api-key",
-            "model": "embed-english-v3.0"  # or "embed-multilingual-v3.0"
+            "model_name": "embed-english-v3.0"  # or "embed-multilingual-v3.0"
         }
     }
 )
@@ -478,7 +478,7 @@ crew = Crew(
         "provider": "voyageai",
         "config": {
             "api_key": "your-voyage-api-key",
-            "model": "voyage-large-2",  # or "voyage-code-2" for code
+            "model": "voyage-3",  # or "voyage-3-lite", "voyage-code-3"
             "input_type": "document"  # or "query"
         }
     }
@@ -515,8 +515,7 @@ crew = Crew(
         "provider": "huggingface",
         "config": {
             "api_key": "your-hf-token",  # Optional for public models
-            "model": "sentence-transformers/all-MiniLM-L6-v2",
-            "api_url": "https://api-inference.huggingface.co"  # or your custom endpoint
+            "model": "sentence-transformers/all-MiniLM-L6-v2"
         }
     }
 )
@@ -912,10 +911,10 @@ crew = Crew(
 crew = Crew(
     memory=True,
     embedder={
-        "provider": "google",
+        "provider": "google-generativeai",
         "config": {
             "api_key": "your-api-key",
-            "model": "text-embedding-004"
+            "model_name": "gemini-embedding-001"
         }
     }
 )

docs/en/concepts/tasks.mdx

@@ -14,7 +14,7 @@ Tasks provide all necessary details for execution, such as a description, the ag
 Tasks within CrewAI can be collaborative, requiring multiple agents to work together. This is managed through the task properties and orchestrated by the Crew's process, enhancing teamwork and efficiency.
 
 <Note type="info" title="Enterprise Enhancement: Visual Task Builder">
-CrewAI AMP includes a Visual Task Builder in Crew Studio that simplifies complex task creation and chaining. Design your task flows visually and test them in real-time without writing code.
+CrewAI AOP includes a Visual Task Builder in Crew Studio that simplifies complex task creation and chaining. Design your task flows visually and test them in real-time without writing code.
 
 ![Task Builder Screenshot](/images/enterprise/crew-studio-interface.png)
 

docs/en/concepts/tools.mdx

@@ -17,7 +17,7 @@ This includes tools from the [CrewAI Toolkit](https://github.com/joaomdmoura/cre
 enabling everything from simple searches to complex interactions and effective teamwork among agents.
 
 <Note type="info" title="Enterprise Enhancement: Tools Repository">
-CrewAI AMP provides a comprehensive Tools Repository with pre-built integrations for common business systems and APIs. Deploy agents with enterprise tools in minutes instead of days.
+CrewAI AOP provides a comprehensive Tools Repository with pre-built integrations for common business systems and APIs. Deploy agents with enterprise tools in minutes instead of days.
 
 The Enterprise Tools Repository includes:
 - Pre-built connectors for popular enterprise systems

docs/en/enterprise/features/rbac.mdx

@@ -7,10 +7,10 @@ mode: "wide"
 
 ## Overview
 
-RBAC in CrewAI AMP enables secure, scalable access management through a combination of organization‑level roles and automation‑level visibility controls.
+RBAC in CrewAI AOP 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 AMP" />
+  <img src="/images/enterprise/users_and_roles.png" alt="RBAC overview in CrewAI AOP" />
 
 </Frame>
 
@@ -28,7 +28,7 @@ You can configure users and roles in Settings → Roles.
 
 <Steps>
   <Step title="Open Roles settings">
-    Go to <b>Settings → Roles</b> in CrewAI AMP.
+    Go to <b>Settings → Roles</b> in CrewAI AOP.
   </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.
@@ -93,7 +93,7 @@ The organization owner always has access. In private mode, only whitelisted user
 </Tip>
 
 <Frame>
-  <img src="/images/enterprise/visibility.png" alt="Automation Visibility settings in CrewAI AMP" />
+  <img src="/images/enterprise/visibility.png" alt="Automation Visibility settings in CrewAI AOP" />
 
 </Frame>
 

docs/en/enterprise/features/tools-and-integrations.mdx

@@ -189,10 +189,10 @@ Tools & Integrations is the central hub for connecting third‑party apps and ma
 
   ## Internal Tools
 
-  Create custom tools locally, publish them on CrewAI AMP Tool Repository and use them in your agents.
+  Create custom tools locally, publish them on CrewAI AOP Tool Repository and use them in your agents.
 
   <Tip>
-  Before running the commands below, make sure you log in to your CrewAI AMP account by running this command:
+  Before running the commands below, make sure you log in to your CrewAI AOP account by running this command:
     ```bash
     crewai login
     ```
@@ -210,13 +210,13 @@ Tools & Integrations is the central hub for connecting third‑party apps and ma
       ```
     </Step>
     <Step title="Publish">
-      Publish the tool to the CrewAI AMP Tool Repository.
+      Publish the tool to the CrewAI AOP Tool Repository.
       ```bash
       crewai tool publish
       ```
     </Step>
     <Step title="Install">
-      Install the tool from the CrewAI AMP Tool Repository.
+      Install the tool from the CrewAI AOP Tool Repository.
       ```bash
       crewai tool install your-tool
       ```

docs/en/enterprise/features/traces.mdx

@@ -11,7 +11,7 @@ Traces provide comprehensive visibility into your crew executions, helping you m
 
 ## What are Traces?
 
-Traces in CrewAI AMP are detailed execution records that capture every aspect of your crew's operation, from initial inputs to final outputs. They record:
+Traces in CrewAI AOP are detailed execution records that capture every aspect of your crew's operation, from initial inputs to final outputs. They record:
 
 - Agent thoughts and reasoning
 - Task execution details
@@ -28,7 +28,7 @@ Traces in CrewAI AMP are detailed execution records that capture every aspect of
 
 <Steps>
   <Step title="Navigate to the Traces Tab">
-    Once in your CrewAI AMP dashboard, click on the **Traces** to view all execution records.
+    Once in your CrewAI AOP dashboard, click on the **Traces** to view all execution records.
   </Step>
 
   <Step title="Select an Execution">
@@ -153,5 +153,5 @@ CrewAI batches trace uploads to reduce overhead on high-volume runs:
 This yields more stable tracing under load while preserving detailed task/agent telemetry.
 
 <Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
-  Contact our support team for assistance with trace analysis or any other CrewAI AMP features.
+  Contact our support team for assistance with trace analysis or any other CrewAI AOP features.
 </Card>

docs/en/enterprise/features/webhook-streaming.mdx

@@ -8,7 +8,7 @@ mode: "wide"
 ## Overview
 
 Enterprise Event Streaming lets you receive real-time webhook updates about your crews and flows deployed to
-CrewAI AMP, such as model calls, tool usage, and flow steps.
+CrewAI AOP, such as model calls, tool usage, and flow steps.
 
 ## Usage
 

docs/en/enterprise/guides/automation-triggers.mdx

@@ -1,11 +1,11 @@
 ---
 title: "Triggers Overview"
-description: "Understand how CrewAI AMP triggers work, how to manage them, and where to find integration-specific playbooks"
+description: "Understand how CrewAI AOP triggers work, how to manage them, and where to find integration-specific playbooks"
 icon: "face-smile"
 mode: "wide"
 ---
 
-CrewAI AMP triggers connect your automations to real-time events across the tools your teams already use. Instead of polling systems or relying on manual kickoffs, triggers listen for changes—new emails, calendar updates, CRM status changes—and immediately launch the crew or flow you specify.
+CrewAI AOP triggers connect your automations to real-time events across the tools your teams already use. Instead of polling systems or relying on manual kickoffs, triggers listen for changes—new emails, calendar updates, CRM status changes—and immediately launch the crew or flow you specify.
 
 <Frame>
   ![Automation Triggers Overview](/images/enterprise/crew_connectors.png)

docs/en/enterprise/guides/azure-openai-setup.mdx

@@ -19,8 +19,8 @@ This guide walks you through connecting Azure OpenAI with Crew Studio for seamle
             </Frame>
     </Step>
 
-    <Step title="Configure CrewAI AMP Connection">
-        4. In another tab, open `CrewAI AMP > LLM Connections`. Name your LLM Connection, select Azure as the provider, and choose the same model you selected in Azure.
+    <Step title="Configure CrewAI AOP Connection">
+        4. In another tab, open `CrewAI AOP > LLM Connections`. Name your LLM Connection, select Azure as the provider, and choose the same model you selected in Azure.
         5. On the same page, add environment variables from step 3:
             - One named `AZURE_DEPLOYMENT_TARGET_URL` (using the Target URI). The URL should look like this: https://your-deployment.openai.azure.com/openai/deployments/gpt-4o/chat/completions?api-version=2024-08-01-preview
             - Another named `AZURE_API_KEY` (using the Key).
@@ -28,7 +28,7 @@ This guide walks you through connecting Azure OpenAI with Crew Studio for seamle
     </Step>
 
     <Step title="Set Default Configuration">
-        7. In `CrewAI AMP > Settings > Defaults > Crew Studio LLM Settings`, set the new LLM Connection and model as defaults.
+        7. In `CrewAI AOP > Settings > Defaults > Crew Studio LLM Settings`, set the new LLM Connection and model as defaults.
     </Step>
 
     <Step title="Configure Network Access">

docs/en/enterprise/guides/build-crew.mdx

@@ -7,7 +7,7 @@ mode: "wide"
 
 ## Overview
 
-[CrewAI AMP](https://app.crewai.com) streamlines the process of **creating**, **deploying**, and **managing** your AI agents in production environments.
+[CrewAI AOP](https://app.crewai.com) streamlines the process of **creating**, **deploying**, and **managing** your AI agents in production environments.
 
 ## Getting Started
 

docs/en/enterprise/guides/capture_telemetry_logs.mdx

@@ -1,11 +1,11 @@
 ---
 title: "Open Telemetry Logs"
-description: "Understand how to capture telemetry logs from your CrewAI AMP deployments"
+description: "Understand how to capture telemetry logs from your CrewAI AOP deployments"
 icon: "magnifying-glass-chart"
 mode: "wide"
 ---
 
-CrewAI AMP provides a powerful way to capture telemetry logs from your deployments. This allows you to monitor the performance of your agents and workflows, and to debug issues that may arise.
+CrewAI AOP provides a powerful way to capture telemetry logs from your deployments. This allows you to monitor the performance of your agents and workflows, and to debug issues that may arise.
 
 ## Prerequisites
 

docs/en/enterprise/guides/deploy-crew.mdx

@@ -1,12 +1,12 @@
 ---
 title: "Deploy Crew"
-description: "Deploying a Crew on CrewAI AMP"
+description: "Deploying a Crew on CrewAI AOP"
 icon: "rocket"
 mode: "wide"
 ---
 
 <Note>
-After creating a crew locally or through Crew Studio, the next step is deploying it to the CrewAI AMP platform. This guide covers multiple deployment methods to help you choose the best approach for your workflow.
+After creating a crew locally or through Crew Studio, the next step is deploying it to the CrewAI AOP platform. This guide covers multiple deployment methods to help you choose the best approach for your workflow.
 </Note>
 
 ## Prerequisites
@@ -39,10 +39,10 @@ The CLI provides the fastest way to deploy locally developed crews to the Enterp
   </Step>
 
   <Step title="Authenticate with the Enterprise Platform">
-    First, you need to authenticate your CLI with the CrewAI AMP platform:
+    First, you need to authenticate your CLI with the CrewAI AOP platform:
 
     ```bash
-    # If you already have a CrewAI AMP account, or want to create one:
+    # If you already have a CrewAI AOP account, or want to create one:
     crewai login
     ```
 
@@ -124,7 +124,7 @@ The CrewAI CLI offers several commands to manage your deployments:
 
 ## Option 2: Deploy Directly via Web Interface
 
-You can also deploy your crews directly through the CrewAI AMP web interface by connecting your GitHub account. This approach doesn't require using the CLI on your local machine.
+You can also deploy your crews directly through the CrewAI AOP web interface by connecting your GitHub account. This approach doesn't require using the CLI on your local machine.
 
 <Steps>
 
@@ -134,9 +134,9 @@ You can also deploy your crews directly through the CrewAI AMP web interface by
 
   </Step>
 
-  <Step title="Connecting GitHub to CrewAI AMP">
+  <Step title="Connecting GitHub to CrewAI AOP">
 
-    1. Log in to [CrewAI AMP](https://app.crewai.com)
+    1. Log in to [CrewAI AOP](https://app.crewai.com)
     2. Click on the button "Connect GitHub"
 
     <Frame>
@@ -187,10 +187,101 @@ You can also deploy your crews directly through the CrewAI AMP web interface by
 
 </Steps>
 
+## Option 3: Redeploy Using API (CI/CD Integration)
+
+For automated deployments in CI/CD pipelines, you can use the CrewAI API to trigger redeployments of existing crews. This is particularly useful for GitHub Actions, Jenkins, or other automation workflows.
+
+<Steps>
+  <Step title="Get Your Personal Access Token">
+
+    Navigate to your CrewAI AOP account settings to generate an API token:
+
+    1. Go to [app.crewai.com](https://app.crewai.com)
+    2. Click on **Settings** → **Account** → **Personal Access Token**
+    3. Generate a new token and copy it securely
+    4. Store this token as a secret in your CI/CD system
+
+  </Step>
+
+  <Step title="Find Your Automation UUID">
+
+    Locate the unique identifier for your deployed crew:
+
+    1. Go to **Automations** in your CrewAI AOP dashboard
+    2. Select your existing automation/crew
+    3. Click on **Additional Details**
+    4. Copy the **UUID** - this identifies your specific crew deployment
+
+  </Step>
+
+  <Step title="Trigger Redeployment via API">
+
+    Use the Deploy API endpoint to trigger a redeployment:
+
+    ```bash
+    curl -i -X POST \
+         -H "Authorization: Bearer YOUR_PERSONAL_ACCESS_TOKEN" \
+         https://app.crewai.com/crewai_plus/api/v1/crews/YOUR-AUTOMATION-UUID/deploy
+
+    # HTTP/2 200
+    # content-type: application/json
+    #
+    # {
+    #   "uuid": "your-automation-uuid",
+    #   "status": "Deploy Enqueued",
+    #   "public_url": "https://your-crew-deployment.crewai.com",
+    #   "token": "your-bearer-token"
+    # }
+    ```
+
+    <Info>
+    If your automation was first created connected to Git, the API will automatically pull the latest changes from your repository before redeploying.
+    </Info>
+
+
+  </Step>
+
+  <Step title="GitHub Actions Integration Example">
+
+    Here's a GitHub Actions workflow with more complex deployment triggers:
+
+    ```yaml
+    name: Deploy CrewAI Automation
+
+    on:
+      push:
+        branches: [ main ]
+      pull_request:
+        types: [ labeled ]
+      release:
+        types: [ published ]
+
+    jobs:
+      deploy:
+        runs-on: ubuntu-latest
+        if: |
+          (github.event_name == 'push' && github.ref == 'refs/heads/main') ||
+          (github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'deploy')) ||
+          (github.event_name == 'release')
+        steps:
+          - name: Trigger CrewAI Redeployment
+            run: |
+              curl -X POST \
+                   -H "Authorization: Bearer ${{ secrets.CREWAI_PAT }}" \
+                   https://app.crewai.com/crewai_plus/api/v1/crews/${{ secrets.CREWAI_AUTOMATION_UUID }}/deploy
+    ```
+
+    <Tip>
+    Add `CREWAI_PAT` and `CREWAI_AUTOMATION_UUID` as repository secrets. For PR deployments, add a "deploy" label to trigger the workflow.
+    </Tip>
+
+    </Step>
+  </Steps>
+
 ## ⚠️ Environment Variable Security Requirements
 
 <Warning>
-**Important**: CrewAI AMP has security restrictions on environment variable names that can cause deployment failures if not followed.
+**Important**: CrewAI AOP has security restrictions on environment variable names that can cause deployment failures if not followed.
 </Warning>
 
 ### Blocked Environment Variable Patterns

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

@@ -1,6 +1,6 @@
 ---
 title: "Enable Crew Studio"
-description: "Enabling Crew Studio on CrewAI AMP"
+description: "Enabling Crew Studio on CrewAI AOP"
 icon: "comments"
 mode: "wide"
 ---
@@ -24,7 +24,7 @@ With Crew Studio, you can:
 - Select appropriate tools
 - Configure necessary inputs
 - Generate downloadable code for customization
-- Deploy directly to the CrewAI AMP platform
+- Deploy directly to the CrewAI AOP platform
 
 ## Configuration Steps
 
@@ -32,7 +32,7 @@ Before you can start using Crew Studio, you need to configure your LLM connectio
 
 <Steps>
   <Step title="Set Up LLM Connection">
-    Go to the **LLM Connections** tab in your CrewAI AMP dashboard and create a new LLM connection.
+    Go to the **LLM Connections** tab in your CrewAI AOP dashboard and create a new LLM connection.
 
     <Note>
       Feel free to use any LLM provider you want that is supported by CrewAI.
@@ -82,7 +82,7 @@ Now that you've configured your LLM connection and default settings, you're read
 
 <Steps>
   <Step title="Access Studio">
-    Navigate to the **Studio** section in your CrewAI AMP dashboard.
+    Navigate to the **Studio** section in your CrewAI AOP dashboard.
   </Step>
 
   <Step title="Start a Conversation">
@@ -110,7 +110,7 @@ Now that you've configured your LLM connection and default settings, you're read
     Once you're satisfied with the configuration, you can:
 
     - Download the generated code for local customization
-    - Deploy the crew directly to the CrewAI AMP platform
+    - Deploy the crew directly to the CrewAI AOP platform
     - Modify the configuration and regenerate the crew
   </Step>
 
@@ -162,5 +162,5 @@ Here's a typical workflow for creating a crew with Crew Studio:
 </Steps>
 
 <Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
-  Contact our support team for assistance with Crew Studio or any other CrewAI AMP features.
+  Contact our support team for assistance with Crew Studio or any other CrewAI AOP features.
 </Card>

docs/en/enterprise/guides/gmail-trigger.mdx

@@ -15,7 +15,7 @@ Use the Gmail Trigger to kick off your deployed crews when Gmail events happen i
 
 ## Enabling the Gmail Trigger
 
-1. Open your deployment in CrewAI AMP
+1. Open your deployment in CrewAI AOP
 2. Go to the **Triggers** tab
 3. Locate **Gmail** and switch the toggle to enable
 

docs/en/enterprise/guides/google-calendar-trigger.mdx

@@ -15,7 +15,7 @@ Use the Google Calendar trigger to launch automations whenever calendar events c
 
 ## Enabling the Google Calendar Trigger
 
-1. Open your deployment in CrewAI AMP
+1. Open your deployment in CrewAI AOP
 2. Go to the **Triggers** tab
 3. Locate **Google Calendar** and switch the toggle to enable
 

docs/en/enterprise/guides/google-drive-trigger.mdx

@@ -15,7 +15,7 @@ Trigger your automations when files are created, updated, or removed in Google D
 
 ## Enabling the Google Drive Trigger
 
-1. Open your deployment in CrewAI AMP
+1. Open your deployment in CrewAI AOP
 2. Go to the **Triggers** tab
 3. Locate **Google Drive** and switch the toggle to enable
 

docs/en/enterprise/guides/hubspot-trigger.mdx

@@ -5,22 +5,22 @@ icon: "hubspot"
 mode: "wide"
 ---
 
-This guide provides a step-by-step process to set up HubSpot triggers for CrewAI AMP, enabling you to initiate crews directly from HubSpot Workflows.
+This guide provides a step-by-step process to set up HubSpot triggers for CrewAI AOP, enabling you to initiate crews directly from HubSpot Workflows.
 
 ## Prerequisites
 
-- A CrewAI AMP account
+- A CrewAI AOP account
 - A HubSpot account with the [HubSpot Workflows](https://knowledge.hubspot.com/workflows/create-workflows) feature
 
 ## Setup Steps
 
 <Steps>
-    <Step title="Connect your HubSpot account with CrewAI AMP">
-        - Log in to your `CrewAI AMP account > Triggers`
+    <Step title="Connect your HubSpot account with CrewAI AOP">
+        - Log in to your `CrewAI AOP account > Triggers`
         - Select `HubSpot` from the list of available triggers
-        - Choose the HubSpot account you want to connect with CrewAI AMP
-        - Follow the on-screen prompts to authorize CrewAI AMP access to your HubSpot account
-        - A confirmation message will appear once HubSpot is successfully connected with CrewAI AMP
+        - Choose the HubSpot account you want to connect with CrewAI AOP
+        - Follow the on-screen prompts to authorize CrewAI AOP access to your HubSpot account
+        - A confirmation message will appear once HubSpot is successfully connected with CrewAI AOP
     </Step>
     <Step title="Create a HubSpot Workflow">
         - Log in to your `HubSpot account > Automations > Workflows > New workflow`

docs/en/enterprise/guides/kickoff-crew.mdx

@@ -1,19 +1,19 @@
 ---
 title: "Kickoff Crew"
-description: "Kickoff a Crew on CrewAI AMP"
+description: "Kickoff a Crew on CrewAI AOP"
 icon: "flag-checkered"
 mode: "wide"
 ---
 
 ## Overview
 
-Once you've deployed your crew to the CrewAI AMP platform, you can kickoff executions through the web interface or the API. This guide covers both approaches.
+Once you've deployed your crew to the CrewAI AOP platform, you can kickoff executions through the web interface or the API. This guide covers both approaches.
 
 ## Method 1: Using the Web Interface
 
 ### Step 1: Navigate to Your Deployed Crew
 
-1. Log in to [CrewAI AMP](https://app.crewai.com)
+1. Log in to [CrewAI AOP](https://app.crewai.com)
 2. Click on the crew name from your projects list
 3. You'll be taken to the crew's detail page
 
@@ -83,7 +83,7 @@ Once execution is complete:
 
 ## Method 2: Using the API
 
-You can also kickoff crews programmatically using the CrewAI AMP REST API.
+You can also kickoff crews programmatically using the CrewAI AOP REST API.
 
 ### Authentication
 

docs/en/enterprise/guides/microsoft-teams-trigger.mdx

@@ -15,7 +15,7 @@ Use the Microsoft Teams trigger to start automations whenever a new chat is crea
 
 ## Enabling the Microsoft Teams Trigger
 
-1. Open your deployment in CrewAI AMP
+1. Open your deployment in CrewAI AOP
 2. Go to the **Triggers** tab
 3. Locate **Microsoft Teams** and switch the toggle to enable
 

docs/en/enterprise/guides/onedrive-trigger.mdx

@@ -15,7 +15,7 @@ Start automations when files change inside OneDrive. You can generate audit summ
 
 ## Enabling the OneDrive Trigger
 
-1. Open your deployment in CrewAI AMP
+1. Open your deployment in CrewAI AOP
 2. Go to the **Triggers** tab
 3. Locate **OneDrive** and switch the toggle to enable
 

docs/en/enterprise/guides/outlook-trigger.mdx

@@ -15,7 +15,7 @@ Automate responses when Outlook delivers a new message or when an event is remov
 
 ## Enabling the Outlook Trigger
 
-1. Open your deployment in CrewAI AMP
+1. Open your deployment in CrewAI AOP
 2. Go to the **Triggers** tab
 3. Locate **Outlook** and switch the toggle to enable
 

docs/en/enterprise/guides/react-component-export.mdx

@@ -1,11 +1,11 @@
 ---
 title: "React Component Export"
-description: "Learn how to export and integrate CrewAI AMP React components into your applications"
+description: "Learn how to export and integrate CrewAI AOP React components into your applications"
 icon: "react"
 mode: "wide"
 ---
 
-This guide explains how to export CrewAI AMP crews as React components and integrate them into your own applications.
+This guide explains how to export CrewAI AOP crews as React components and integrate them into your own applications.
 
 ## Exporting a React Component
 

docs/en/enterprise/guides/salesforce-trigger.mdx

@@ -5,7 +5,7 @@ icon: "salesforce"
 mode: "wide"
 ---
 
-CrewAI AMP can be triggered from Salesforce to automate customer relationship management workflows and enhance your sales operations.
+CrewAI AOP can be triggered from Salesforce to automate customer relationship management workflows and enhance your sales operations.
 
 ## Overview
 
@@ -31,7 +31,7 @@ Salesforce is a leading customer relationship management (CRM) platform that hel
 
 To set up Salesforce triggers:
 
-1. **Contact Support**: Reach out to CrewAI AMP support for assistance with Salesforce trigger setup
+1. **Contact Support**: Reach out to CrewAI AOP support for assistance with Salesforce trigger setup
 2. **Review Requirements**: Ensure you have the necessary Salesforce permissions and API access
 3. **Configure Connection**: Work with the support team to establish the connection between CrewAI and your Salesforce instance
 4. **Test Triggers**: Verify the triggers work correctly with your specific use cases
@@ -47,4 +47,4 @@ Common Salesforce + CrewAI trigger scenarios include:
 
 ## Next Steps
 
-For detailed setup instructions and advanced configuration options, please contact CrewAI AMP support who can provide tailored guidance for your specific Salesforce environment and business needs.
+For detailed setup instructions and advanced configuration options, please contact CrewAI AOP support who can provide tailored guidance for your specific Salesforce environment and business needs.

docs/en/enterprise/guides/team-management.mdx

@@ -1,17 +1,17 @@
 ---
 title: "Team Management"
-description: "Learn how to invite and manage team members in your CrewAI AMP organization"
+description: "Learn how to invite and manage team members in your CrewAI AOP organization"
 icon: "users"
 mode: "wide"
 ---
 
-As an administrator of a CrewAI AMP account, you can easily invite new team members to join your organization. This guide will walk you through the process step-by-step.
+As an administrator of a CrewAI AOP account, you can easily invite new team members to join your organization. This guide will walk you through the process step-by-step.
 
 ## Inviting Team Members
 
 <Steps>
     <Step title="Access the Settings Page">
-        - Log in to your CrewAI AMP account
+        - Log in to your CrewAI AOP account
         - Look for the gear icon (⚙️) in the top right corner of the dashboard
         - Click on the gear icon to access the **Settings** page:
             <Frame caption="Settings page">
@@ -43,7 +43,7 @@ You can add roles to your team members to control their access to different part
 
 <Steps>
     <Step title="Access the Settings Page">
-        - Log in to your CrewAI AMP account
+        - Log in to your CrewAI AOP account
         - Look for the gear icon (⚙️) in the top right corner of the dashboard
         - Click on the gear icon to access the **Settings** page:
             <Frame>
@@ -85,4 +85,4 @@ You can add roles to your team members to control their access to different part
 - **Invitation Acceptance**: Invited members will need to accept the invitation to join your organization
 - **Email Notifications**: You may want to inform your team members to check their email (including spam folders) for the invitation
 
-By following these steps, you can easily expand your team and collaborate more effectively within your CrewAI AMP organization.
+By following these steps, you can easily expand your team and collaborate more effectively within your CrewAI AOP organization.

docs/en/enterprise/guides/tool-repository.mdx

@@ -20,11 +20,11 @@ The repository is not a version control system. Use Git to track code changes an
 
 Before using the Tool Repository, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account
+- A [CrewAI AOP](https://app.crewai.com) account
 - [CrewAI CLI](/en/concepts/cli#cli) installed
 - uv>=0.5.0 installed. Check out [how to upgrade](https://docs.astral.sh/uv/getting-started/installation/#upgrading-uv)
 - [Git](https://git-scm.com) installed and configured
-- Access permissions to publish or install tools in your CrewAI AMP organization
+- Access permissions to publish or install tools in your CrewAI AOP organization
 
 ## Installing Tools
 
@@ -54,11 +54,11 @@ researcher = Agent(
 
 ## Adding other packages after installing a tool
 
-After installing a tool from the CrewAI AMP Tool Repository, you need to use the `crewai uv` command to add other packages to your project.
+After installing a tool from the CrewAI AOP Tool Repository, you need to use the `crewai uv` command to add other packages to your project.
 Using pure `uv` commands will fail due to authentication to tool repository being handled by the CLI. By using the `crewai uv` command, you can add other packages to your project without having to worry about authentication.
 Any `uv` command can be used with the `crewai uv` command, making it a powerful tool for managing your project's dependencies without the hassle of managing authentication through environment variables or other methods.
 
-Say that you have installed a custom tool from the CrewAI AMP Tool Repository called "my-tool":
+Say that you have installed a custom tool from the CrewAI AOP Tool Repository called "my-tool":
 
 ```bash
 crewai tool install my-tool
@@ -131,7 +131,7 @@ crewai tool publish
 
 To delete a tool:
 
-1. Go to [CrewAI AMP](https://app.crewai.com)
+1. Go to [CrewAI AOP](https://app.crewai.com)
 2. Navigate to **Tools**
 3. Select the tool
 4. Click **Delete**
@@ -146,10 +146,8 @@ Every published version undergoes automated security checks, and are only availa
 
 You can check the security check status of a tool at:
 
-`CrewAI AMP > Tools > Your Tool > Versions`
+`CrewAI AOP > Tools > Your Tool > Versions`
 
 <Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
   Contact our support team for assistance with API integration or troubleshooting.
 </Card>
-
-

docs/en/enterprise/guides/update-crew.mdx

@@ -1,12 +1,12 @@
 ---
 title: "Update Crew"
-description: "Updating a Crew on CrewAI AMP"
+description: "Updating a Crew on CrewAI AOP"
 icon: "pencil"
 mode: "wide"
 ---
 
 <Note>
-After deploying your crew to CrewAI AMP, you may need to make updates to the code, security settings, or configuration.
+After deploying your crew to CrewAI AOP, you may need to make updates to the code, security settings, or configuration.
 This guide explains how to perform these common update operations.
 </Note>
 
@@ -23,7 +23,7 @@ There are several reasons you might want to update your crew deployment:
 
 When you've pushed new commits to your GitHub repository and want to update your deployment:
 
-1. Navigate to your crew in the CrewAI AMP platform
+1. Navigate to your crew in the CrewAI AOP platform
 2. Click on the `Re-deploy` button on your crew details page
 
 <Frame>
@@ -36,7 +36,7 @@ This will trigger an update that you can track using the progress bar. The syste
 
 If you need to generate a new bearer token (for example, if you suspect the current token might have been compromised):
 
-1. Navigate to your crew in the CrewAI AMP platform
+1. Navigate to your crew in the CrewAI AOP platform
 2. Find the `Bearer Token` section
 3. Click the `Reset` button next to your current token
 

docs/en/enterprise/guides/webhook-automation.mdx

@@ -1,17 +1,17 @@
 ---
 title: "Webhook Automation"
-description: "Automate CrewAI AMP workflows using webhooks with platforms like ActivePieces, Zapier, and Make.com"
+description: "Automate CrewAI AOP workflows using webhooks with platforms like ActivePieces, Zapier, and Make.com"
 icon: "webhook"
 mode: "wide"
 ---
 
-CrewAI AMP allows you to automate your workflow using webhooks. This article will guide you through the process of setting up and using webhooks to kickoff your crew execution, with a focus on integration with ActivePieces, a workflow automation platform similar to Zapier and Make.com.
+CrewAI AOP allows you to automate your workflow using webhooks. This article will guide you through the process of setting up and using webhooks to kickoff your crew execution, with a focus on integration with ActivePieces, a workflow automation platform similar to Zapier and Make.com.
 
 ## Setting Up Webhooks
 
 <Steps>
     <Step title="Accessing the Kickoff Interface">
-        - Navigate to the CrewAI AMP dashboard
+        - Navigate to the CrewAI AOP dashboard
         - Look for the `/kickoff` section, which is used to start the crew execution
             <Frame>
                 <img src="/images/enterprise/kickoff-interface.png" alt="Kickoff Interface" />
@@ -44,7 +44,7 @@ CrewAI AMP allows you to automate your workflow using webhooks. This article wil
         3. Add an HTTP action step
             - Set the action to `Send HTTP request`
             - Use `POST` as the method
-            - Set the URL to your CrewAI AMP kickoff endpoint
+            - Set the URL to your CrewAI AOP kickoff endpoint
             - Add necessary headers (e.g., `Bearer Token`)
                 <Frame>
                     <img src="/images/enterprise/activepieces-headers.png" alt="ActivePieces Headers" />

docs/en/enterprise/guides/zapier-trigger.mdx

@@ -5,11 +5,11 @@ icon: "bolt"
 mode: "wide"
 ---
 
-This guide will walk you through the process of setting up Zapier triggers for CrewAI AMP, allowing you to automate workflows between CrewAI AMP and other applications.
+This guide will walk you through the process of setting up Zapier triggers for CrewAI AOP, allowing you to automate workflows between CrewAI AOP and other applications.
 
 ## Prerequisites
 
-- A CrewAI AMP account
+- A CrewAI AOP account
 - A Zapier account
 - A Slack account (for this specific example)
 
@@ -32,7 +32,7 @@ This guide will walk you through the process of setting up Zapier triggers for C
         - Connect your Slack account if you haven't already.
     </Step>
 
-    <Step title="Configure the CrewAI AMP Action">
+    <Step title="Configure the CrewAI AOP Action">
         - Add a new action step to your Zap.
         - Choose CrewAI+ as your action app and Kickoff as the Action Event
 
@@ -41,8 +41,8 @@ This guide will walk you through the process of setting up Zapier triggers for C
         </Frame>
     </Step>
 
-    <Step title="Connect your CrewAI AMP account">
-        - Connect your CrewAI AMP account.
+    <Step title="Connect your CrewAI AOP account">
+        - Connect your CrewAI AOP account.
         - Select the appropriate Crew for your workflow.
 
         <Frame>
@@ -51,8 +51,8 @@ This guide will walk you through the process of setting up Zapier triggers for C
         - Configure the inputs for the Crew using the data from the Slack message.
     </Step>
 
-    <Step title="Format the CrewAI AMP Output">
-        - Add another action step to format the text output from CrewAI AMP.
+    <Step title="Format the CrewAI AOP Output">
+        - Add another action step to format the text output from CrewAI AOP.
         - Use Zapier's formatting tools to convert the Markdown output to HTML.
 
         <Frame>
@@ -67,7 +67,7 @@ This guide will walk you through the process of setting up Zapier triggers for C
         - Add a final action step to send the formatted output via email.
         - Choose your preferred email service (e.g., Gmail, Outlook).
         - Configure the email details, including recipient, subject, and body.
-        - Insert the formatted CrewAI AMP output into the email body.
+        - Insert the formatted CrewAI AOP output into the email body.
 
         <Frame>
             <img src="/images/enterprise/zapier-7.png" alt="Zapier 7" />
@@ -97,8 +97,8 @@ This guide will walk you through the process of setting up Zapier triggers for C
 
 ## Tips for Success
 
-- Ensure that your CrewAI AMP inputs are correctly mapped from the Slack message.
+- Ensure that your CrewAI AOP inputs are correctly mapped from the Slack message.
 - Test your Zap thoroughly before turning it on to catch any potential issues.
 - Consider adding error handling steps to manage potential failures in the workflow.
 
-By following these steps, you'll have successfully set up Zapier triggers for CrewAI AMP, allowing for automated workflows triggered by Slack messages and resulting in email notifications with CrewAI AMP output.
+By following these steps, you'll have successfully set up Zapier triggers for CrewAI AOP, allowing for automated workflows triggered by Slack messages and resulting in email notifications with CrewAI AOP output.

docs/en/enterprise/integrations/asana.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage tasks, projects, and team coordination through Asan
 
 Before using the Asana integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - An Asana account with appropriate permissions
 - Connected your Asana account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the Asana integration, ensure you have:
 
 ### 1. Connect Your Asana Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Asana** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for task and project management

docs/en/enterprise/integrations/box.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage files, folders, and documents through Box. Upload f
 
 Before using the Box integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Box account with appropriate permissions
 - Connected your Box account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the Box integration, ensure you have:
 
 ### 1. Connect Your Box Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Box** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for file and folder management

docs/en/enterprise/integrations/clickup.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage tasks, projects, and productivity workflows through
 
 Before using the ClickUp integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A ClickUp account with appropriate permissions
 - Connected your ClickUp account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the ClickUp integration, ensure you have:
 
 ### 1. Connect Your ClickUp Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **ClickUp** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for task and project management

docs/en/enterprise/integrations/github.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage repositories, issues, and releases through GitHub.
 
 Before using the GitHub integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A GitHub account with appropriate repository permissions
 - Connected your GitHub account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the GitHub integration, ensure you have:
 
 ### 1. Connect Your GitHub Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **GitHub** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for repository and issue management

docs/en/enterprise/integrations/gmail.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage emails, contacts, and drafts through Gmail. Send em
 
 Before using the Gmail integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Gmail account with appropriate permissions
 - Connected your Gmail account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the Gmail integration, ensure you have:
 
 ### 1. Connect Your Gmail Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Gmail** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for email and contact management

docs/en/enterprise/integrations/google_calendar.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage calendar events, schedules, and availability throug
 
 Before using the Google Calendar integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Google account with Google Calendar access
 - Connected your Google account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the Google Calendar integration, ensure you have:
 
 ### 1. Connect Your Google Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Google Calendar** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for calendar access

docs/en/enterprise/integrations/google_contacts.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage contacts and directory information through Google C
 
 Before using the Google Contacts integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Google account with Google Contacts access
 - Connected your Google account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the Google Contacts integration, ensure you have:
 
 ### 1. Connect Your Google Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Google Contacts** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for contacts and directory access

docs/en/enterprise/integrations/google_docs.mdx

@@ -13,7 +13,7 @@ Enable your agents to create, edit, and manage Google Docs documents with text m
 
 Before using the Google Docs integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Google account with Google Docs access
 - Connected your Google account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the Google Docs integration, ensure you have:
 
 ### 1. Connect Your Google Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Google Docs** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for document access

docs/en/enterprise/integrations/google_drive.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage files and folders through Google Drive. Upload, dow
 
 Before using the Google Drive integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Google account with Google Drive access
 - Connected your Google account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the Google Drive integration, ensure you have:
 
 ### 1. Connect Your Google Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Google Drive** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for file and folder management

docs/en/enterprise/integrations/google_sheets.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage spreadsheet data through Google Sheets. Read rows,
 
 Before using the Google Sheets integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Google account with Google Sheets access
 - Connected your Google account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 - Spreadsheets with proper column headers for data operations
@@ -22,7 +22,7 @@ Before using the Google Sheets integration, ensure you have:
 
 ### 1. Connect Your Google Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Google Sheets** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for spreadsheet access

docs/en/enterprise/integrations/google_slides.mdx

@@ -13,7 +13,7 @@ Enable your agents to create, edit, and manage Google Slides presentations. Crea
 
 Before using the Google Slides integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Google account with Google Slides access
 - Connected your Google account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the Google Slides integration, ensure you have:
 
 ### 1. Connect Your Google Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Google Slides** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for presentations, spreadsheets, and drive access

docs/en/enterprise/integrations/hubspot.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage companies and contacts within HubSpot. Create new r
 
 Before using the HubSpot integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription.
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription.
 - A HubSpot account with appropriate permissions.
 - Connected your HubSpot account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors).
 
@@ -21,7 +21,7 @@ Before using the HubSpot integration, ensure you have:
 
 ### 1. Connect Your HubSpot Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors).
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors).
 2. Find **HubSpot** in the Authentication Integrations section.
 3. Click **Connect** and complete the OAuth flow.
 4. Grant the necessary permissions for company and contact management.

docs/en/enterprise/integrations/jira.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage issues, projects, and workflows through Jira. Creat
 
 Before using the Jira integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Jira account with appropriate project permissions
 - Connected your Jira account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the Jira integration, ensure you have:
 
 ### 1. Connect Your Jira Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Jira** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for issue and project management

docs/en/enterprise/integrations/linear.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage issues, projects, and development workflows through
 
 Before using the Linear integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Linear account with appropriate workspace permissions
 - Connected your Linear account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the Linear integration, ensure you have:
 
 ### 1. Connect Your Linear Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Linear** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for issue and project management

docs/en/enterprise/integrations/microsoft_excel.mdx

@@ -13,7 +13,7 @@ Enable your agents to create and manage Excel workbooks, worksheets, tables, and
 
 Before using the Microsoft Excel integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Microsoft 365 account with Excel and OneDrive/SharePoint access
 - Connected your Microsoft account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the Microsoft Excel integration, ensure you have:
 
 ### 1. Connect Your Microsoft Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Microsoft Excel** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for files and Excel workbook access

docs/en/enterprise/integrations/microsoft_onedrive.mdx

@@ -13,7 +13,7 @@ Enable your agents to upload, download, and manage files and folders in Microsof
 
 Before using the Microsoft OneDrive integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Microsoft account with OneDrive access
 - Connected your Microsoft account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the Microsoft OneDrive integration, ensure you have:
 
 ### 1. Connect Your Microsoft Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Microsoft OneDrive** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for file access

docs/en/enterprise/integrations/microsoft_outlook.mdx

@@ -13,7 +13,7 @@ Enable your agents to access and manage Outlook emails, calendar events, and con
 
 Before using the Microsoft Outlook integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Microsoft account with Outlook access
 - Connected your Microsoft account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the Microsoft Outlook integration, ensure you have:
 
 ### 1. Connect Your Microsoft Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Microsoft Outlook** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for mail, calendar, and contact access

docs/en/enterprise/integrations/microsoft_sharepoint.mdx

@@ -13,7 +13,7 @@ Enable your agents to access and manage SharePoint sites, lists, and document li
 
 Before using the Microsoft SharePoint integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Microsoft 365 account with SharePoint access
 - Connected your Microsoft account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the Microsoft SharePoint integration, ensure you have:
 
 ### 1. Connect Your Microsoft Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Microsoft SharePoint** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for SharePoint sites and content access

docs/en/enterprise/integrations/microsoft_teams.mdx

@@ -13,7 +13,7 @@ Enable your agents to access Teams data, send messages, create meetings, and man
 
 Before using the Microsoft Teams integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Microsoft account with Teams access
 - Connected your Microsoft account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the Microsoft Teams integration, ensure you have:
 
 ### 1. Connect Your Microsoft Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Microsoft Teams** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for Teams access

docs/en/enterprise/integrations/microsoft_word.mdx

@@ -13,7 +13,7 @@ Enable your agents to create, read, and manage Word documents and text files in
 
 Before using the Microsoft Word integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Microsoft account with Word and OneDrive/SharePoint access
 - Connected your Microsoft account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the Microsoft Word integration, ensure you have:
 
 ### 1. Connect Your Microsoft Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Microsoft Word** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for file access

docs/en/enterprise/integrations/notion.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage users and create comments through Notion. Access wo
 
 Before using the Notion integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Notion account with appropriate workspace permissions
 - Connected your Notion account through the [Integrations page](https://app.crewai.com/crewai_plus/connectors)
 
@@ -21,7 +21,7 @@ Before using the Notion integration, ensure you have:
 
 ### 1. Connect Your Notion Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Notion** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for user access and comment creation

docs/en/enterprise/integrations/salesforce.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage customer relationships, sales processes, and data t
 
 Before using the Salesforce integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Salesforce account with appropriate permissions
 - Connected your Salesforce account through the [Integrations page](https://app.crewai.com/integrations)
 
@@ -21,7 +21,7 @@ Before using the Salesforce integration, ensure you have:
 
 ### 1. Connect Your Salesforce Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Salesforce** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for CRM and sales management

docs/en/enterprise/integrations/shopify.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage e-commerce operations through Shopify. Handle custo
 
 Before using the Shopify integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Shopify store with appropriate admin permissions
 - Connected your Shopify store through the [Integrations page](https://app.crewai.com/integrations)
 
@@ -21,7 +21,7 @@ Before using the Shopify integration, ensure you have:
 
 ### 1. Connect Your Shopify Store
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Shopify** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for store and product management

docs/en/enterprise/integrations/slack.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage team communication through Slack. Send messages, se
 
 Before using the Slack integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Slack workspace with appropriate permissions
 - Connected your Slack workspace through the [Integrations page](https://app.crewai.com/integrations)
 
@@ -21,7 +21,7 @@ Before using the Slack integration, ensure you have:
 
 ### 1. Connect Your Slack Workspace
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Slack** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for team communication

docs/en/enterprise/integrations/stripe.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage payments, subscriptions, and customer billing throu
 
 Before using the Stripe integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Stripe account with appropriate API permissions
 - Connected your Stripe account through the [Integrations page](https://app.crewai.com/integrations)
 
@@ -21,7 +21,7 @@ Before using the Stripe integration, ensure you have:
 
 ### 1. Connect Your Stripe Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Stripe** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for payment processing

docs/en/enterprise/integrations/zendesk.mdx

@@ -13,7 +13,7 @@ Enable your agents to manage customer support operations through Zendesk. Create
 
 Before using the Zendesk integration, ensure you have:
 
-- A [CrewAI AMP](https://app.crewai.com) account with an active subscription
+- A [CrewAI AOP](https://app.crewai.com) account with an active subscription
 - A Zendesk account with appropriate API permissions
 - Connected your Zendesk account through the [Integrations page](https://app.crewai.com/integrations)
 
@@ -21,7 +21,7 @@ Before using the Zendesk integration, ensure you have:
 
 ### 1. Connect Your Zendesk Account
 
-1. Navigate to [CrewAI AMP Integrations](https://app.crewai.com/crewai_plus/connectors)
+1. Navigate to [CrewAI AOP Integrations](https://app.crewai.com/crewai_plus/connectors)
 2. Find **Zendesk** in the Authentication Integrations section
 3. Click **Connect** and complete the OAuth flow
 4. Grant the necessary permissions for ticket and user management

docs/en/enterprise/introduction.mdx

@@ -1,5 +1,5 @@
 ---
-title: "CrewAI AMP"
+title: "CrewAI AOP"
 description: "Deploy, monitor, and scale your AI agent workflows"
 icon: "globe"
 mode: "wide"
@@ -7,13 +7,13 @@ mode: "wide"
 
 ## Introduction
 
-CrewAI AMP(Agent Management Platform) provides a platform for deploying, monitoring, and scaling your crews and agents in a production environment.
+CrewAI AOP(Agent Operations Platform) provides a platform for deploying, monitoring, and scaling your crews and agents in a production environment.
 
 <Frame>
-  <img src="/images/enterprise/crewai-enterprise-dashboard.png" alt="CrewAI AMP Dashboard" />
+  <img src="/images/enterprise/crewai-enterprise-dashboard.png" alt="CrewAI AOP Dashboard" />
 </Frame>
 
-CrewAI AMP extends the power of the open-source framework with features designed for production deployments, collaboration, and scalability. Deploy your crews to a managed infrastructure and monitor their execution in real-time.
+CrewAI AOP extends the power of the open-source framework with features designed for production deployments, collaboration, and scalability. Deploy your crews to a managed infrastructure and monitor their execution in real-time.
 
 ## Key Features
 

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

@@ -1,6 +1,6 @@
 ---
 title: FAQs
-description: "Frequently asked questions about CrewAI AMP"
+description: "Frequently asked questions about CrewAI AOP"
 icon: "circle-question"
 mode: "wide"
 ---

docs/en/installation.mdx

@@ -167,7 +167,7 @@ We recommend using the `YAML` template scaffolding for a structured approach to
 <Note type="info">
 For teams and organizations, CrewAI offers enterprise deployment options that eliminate setup complexity:
 
-### CrewAI AMP (SaaS)
+### CrewAI AOP (SaaS)
 - Zero installation required - just sign up for free at [app.crewai.com](https://app.crewai.com)
 - Automatic updates and maintenance
 - Managed infrastructure and scaling

docs/en/learn/create-custom-tools.mdx

@@ -66,5 +66,55 @@ def my_cache_strategy(arguments: dict, result: str) -> bool:
 cached_tool.cache_function = my_cache_strategy
 ```
 
+### Creating Async Tools
+
+CrewAI supports async tools for non-blocking I/O operations. This is useful when your tool needs to make HTTP requests, database queries, or other I/O-bound operations.
+
+#### Using the `@tool` Decorator with Async Functions
+
+The simplest way to create an async tool is using the `@tool` decorator with an async function:
+
+```python Code
+import aiohttp
+from crewai.tools import tool
+
+@tool("Async Web Fetcher")
+async def fetch_webpage(url: str) -> str:
+    """Fetch content from a webpage asynchronously."""
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as response:
+            return await response.text()
+```
+
+#### Subclassing `BaseTool` with Async Support
+
+For more control, subclass `BaseTool` and implement both `_run` (sync) and `_arun` (async) methods:
+
+```python Code
+import requests
+import aiohttp
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
+
+class WebFetcherInput(BaseModel):
+    """Input schema for WebFetcher."""
+    url: str = Field(..., description="The URL to fetch")
+
+class WebFetcherTool(BaseTool):
+    name: str = "Web Fetcher"
+    description: str = "Fetches content from a URL"
+    args_schema: type[BaseModel] = WebFetcherInput
+
+    def _run(self, url: str) -> str:
+        """Synchronous implementation."""
+        return requests.get(url).text
+
+    async def _arun(self, url: str) -> str:
+        """Asynchronous implementation for non-blocking I/O."""
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as response:
+                return await response.text()
+```
+
 By adhering to these guidelines and incorporating new functionalities and collaboration tools into your tool creation and management processes,
 you can leverage the full capabilities of the CrewAI framework, enhancing both the development experience and the efficiency of your AI agents.

docs/en/learn/kickoff-async.mdx

@@ -7,17 +7,28 @@ mode: "wide"
 
 ## Introduction
 
-CrewAI provides the ability to kickoff a crew asynchronously, allowing you to start the crew execution in a non-blocking manner. 
+CrewAI provides the ability to kickoff a crew asynchronously, allowing you to start the crew execution in a non-blocking manner.
 This feature is particularly useful when you want to run multiple crews concurrently or when you need to perform other tasks while the crew is executing.
 
-## Asynchronous Crew Execution
+CrewAI offers two approaches for async execution:
 
-To kickoff a crew asynchronously, use the `kickoff_async()` method. This method initiates the crew execution in a separate thread, allowing the main thread to continue executing other tasks.
+| Method | Type | Description |
+|--------|------|-------------|
+| `akickoff()` | Native async | True async/await throughout the entire execution chain |
+| `kickoff_async()` | Thread-based | Wraps synchronous execution in `asyncio.to_thread` |
+
+<Note>
+For high-concurrency workloads, `akickoff()` is recommended as it uses native async for task execution, memory operations, and knowledge retrieval.
+</Note>
+
+## Native Async Execution with `akickoff()`
+
+The `akickoff()` method provides true native async execution, using async/await throughout the entire execution chain including task execution, memory operations, and knowledge queries.
 
 ### Method Signature
 
 ```python Code
-def kickoff_async(self, inputs: dict) -> CrewOutput:
+async def akickoff(self, inputs: dict) -> CrewOutput:
 ```
 
 ### Parameters
@@ -28,23 +39,13 @@ def kickoff_async(self, inputs: dict) -> CrewOutput:
 
 - `CrewOutput`: An object representing the result of the crew execution.
 
-## Potential Use Cases
-
-- **Parallel Content Generation**: Kickoff multiple independent crews asynchronously, each responsible for generating content on different topics. For example, one crew might research and draft an article on AI trends, while another crew generates social media posts about a new product launch. Each crew operates independently, allowing content production to scale efficiently.
-
-- **Concurrent Market Research Tasks**: Launch multiple crews asynchronously to conduct market research in parallel. One crew might analyze industry trends, while another examines competitor strategies, and yet another evaluates consumer sentiment. Each crew independently completes its task, enabling faster and more comprehensive insights.
-
-- **Independent Travel Planning Modules**: Execute separate crews to independently plan different aspects of a trip. One crew might handle flight options, another handles accommodation, and a third plans activities. Each crew works asynchronously, allowing various components of the trip to be planned simultaneously and independently for faster results.
-
-## Example: Single Asynchronous Crew Execution
-
-Here's an example of how to kickoff a crew asynchronously using asyncio and awaiting the result:
+### Example: Native Async Crew Execution
 
 ```python Code
 import asyncio
 from crewai import Crew, Agent, Task
 
-# Create an agent with code execution enabled
+# Create an agent
 coding_agent = Agent(
     role="Python Data Analyst",
     goal="Analyze data and provide insights using Python",
@@ -52,37 +53,165 @@ coding_agent = Agent(
     allow_code_execution=True
 )
 
-# Create a task that requires code execution
+# Create a task
 data_analysis_task = Task(
     description="Analyze the given dataset and calculate the average age of participants. Ages: {ages}",
     agent=coding_agent,
     expected_output="The average age of the participants."
 )
 
-# Create a crew and add the task
+# Create a crew
 analysis_crew = Crew(
     agents=[coding_agent],
     tasks=[data_analysis_task]
 )
 
-# Async function to kickoff the crew asynchronously
-async def async_crew_execution():
-    result = await analysis_crew.kickoff_async(inputs={"ages": [25, 30, 35, 40, 45]})
+# Native async execution
+async def main():
+    result = await analysis_crew.akickoff(inputs={"ages": [25, 30, 35, 40, 45]})
     print("Crew Result:", result)
 
-# Run the async function
-asyncio.run(async_crew_execution())
+asyncio.run(main())
 ```
 
-## Example: Multiple Asynchronous Crew Executions
+### Example: Multiple Native Async Crews
 
-In this example, we'll show how to kickoff multiple crews asynchronously and wait for all of them to complete using `asyncio.gather()`:
+Run multiple crews concurrently using `asyncio.gather()` with native async:
+
+```python Code
+import asyncio
+from crewai import Crew, Agent, Task
+
+coding_agent = Agent(
+    role="Python Data Analyst",
+    goal="Analyze data and provide insights using Python",
+    backstory="You are an experienced data analyst with strong Python skills.",
+    allow_code_execution=True
+)
+
+task_1 = Task(
+    description="Analyze the first dataset and calculate the average age. Ages: {ages}",
+    agent=coding_agent,
+    expected_output="The average age of the participants."
+)
+
+task_2 = Task(
+    description="Analyze the second dataset and calculate the average age. Ages: {ages}",
+    agent=coding_agent,
+    expected_output="The average age of the participants."
+)
+
+crew_1 = Crew(agents=[coding_agent], tasks=[task_1])
+crew_2 = Crew(agents=[coding_agent], tasks=[task_2])
+
+async def main():
+    results = await asyncio.gather(
+        crew_1.akickoff(inputs={"ages": [25, 30, 35, 40, 45]}),
+        crew_2.akickoff(inputs={"ages": [20, 22, 24, 28, 30]})
+    )
+
+    for i, result in enumerate(results, 1):
+        print(f"Crew {i} Result:", result)
+
+asyncio.run(main())
+```
+
+### Example: Native Async for Multiple Inputs
+
+Use `akickoff_for_each()` to execute your crew against multiple inputs concurrently with native async:
+
+```python Code
+import asyncio
+from crewai import Crew, Agent, Task
+
+coding_agent = Agent(
+    role="Python Data Analyst",
+    goal="Analyze data and provide insights using Python",
+    backstory="You are an experienced data analyst with strong Python skills.",
+    allow_code_execution=True
+)
+
+data_analysis_task = Task(
+    description="Analyze the dataset and calculate the average age. Ages: {ages}",
+    agent=coding_agent,
+    expected_output="The average age of the participants."
+)
+
+analysis_crew = Crew(
+    agents=[coding_agent],
+    tasks=[data_analysis_task]
+)
+
+async def main():
+    datasets = [
+        {"ages": [25, 30, 35, 40, 45]},
+        {"ages": [20, 22, 24, 28, 30]},
+        {"ages": [30, 35, 40, 45, 50]}
+    ]
+
+    results = await analysis_crew.akickoff_for_each(datasets)
+
+    for i, result in enumerate(results, 1):
+        print(f"Dataset {i} Result:", result)
+
+asyncio.run(main())
+```
+
+## Thread-Based Async with `kickoff_async()`
+
+The `kickoff_async()` method provides async execution by wrapping the synchronous `kickoff()` in a thread. This is useful for simpler async integration or backward compatibility.
+
+### Method Signature
+
+```python Code
+async def kickoff_async(self, inputs: dict) -> CrewOutput:
+```
+
+### Parameters
+
+- `inputs` (dict): A dictionary containing the input data required for the tasks.
+
+### Returns
+
+- `CrewOutput`: An object representing the result of the crew execution.
+
+### Example: Thread-Based Async Execution
+
+```python Code
+import asyncio
+from crewai import Crew, Agent, Task
+
+coding_agent = Agent(
+    role="Python Data Analyst",
+    goal="Analyze data and provide insights using Python",
+    backstory="You are an experienced data analyst with strong Python skills.",
+    allow_code_execution=True
+)
+
+data_analysis_task = Task(
+    description="Analyze the given dataset and calculate the average age of participants. Ages: {ages}",
+    agent=coding_agent,
+    expected_output="The average age of the participants."
+)
+
+analysis_crew = Crew(
+    agents=[coding_agent],
+    tasks=[data_analysis_task]
+)
+
+async def async_crew_execution():
+    result = await analysis_crew.kickoff_async(inputs={"ages": [25, 30, 35, 40, 45]})
+    print("Crew Result:", result)
+
+asyncio.run(async_crew_execution())
+```
+
+### Example: Multiple Thread-Based Async Crews
 
 ```python Code
 import asyncio
 from crewai import Crew, Agent, Task
 
-# Create an agent with code execution enabled
 coding_agent = Agent(
     role="Python Data Analyst",
     goal="Analyze data and provide insights using Python",
@@ -90,7 +219,6 @@ coding_agent = Agent(
     allow_code_execution=True
 )
 
-# Create tasks that require code execution
 task_1 = Task(
     description="Analyze the first dataset and calculate the average age of participants. Ages: {ages}",
     agent=coding_agent,
@@ -103,22 +231,76 @@ task_2 = Task(
     expected_output="The average age of the participants."
 )
 
-# Create two crews and add tasks
 crew_1 = Crew(agents=[coding_agent], tasks=[task_1])
 crew_2 = Crew(agents=[coding_agent], tasks=[task_2])
 
-# Async function to kickoff multiple crews asynchronously and wait for all to finish
 async def async_multiple_crews():
-    # Create coroutines for concurrent execution
     result_1 = crew_1.kickoff_async(inputs={"ages": [25, 30, 35, 40, 45]})
     result_2 = crew_2.kickoff_async(inputs={"ages": [20, 22, 24, 28, 30]})
 
-    # Wait for both crews to finish
     results = await asyncio.gather(result_1, result_2)
 
     for i, result in enumerate(results, 1):
         print(f"Crew {i} Result:", result)
 
-# Run the async function
 asyncio.run(async_multiple_crews())
 ```
+
+## Async Streaming
+
+Both async methods support streaming when `stream=True` is set on the crew:
+
+```python Code
+import asyncio
+from crewai import Crew, Agent, Task
+
+agent = Agent(
+    role="Researcher",
+    goal="Research and summarize topics",
+    backstory="You are an expert researcher."
+)
+
+task = Task(
+    description="Research the topic: {topic}",
+    agent=agent,
+    expected_output="A comprehensive summary of the topic."
+)
+
+crew = Crew(
+    agents=[agent],
+    tasks=[task],
+    stream=True  # Enable streaming
+)
+
+async def main():
+    streaming_output = await crew.akickoff(inputs={"topic": "AI trends in 2024"})
+
+    # Async iteration over streaming chunks
+    async for chunk in streaming_output:
+        print(f"Chunk: {chunk.content}")
+
+    # Access final result after streaming completes
+    result = streaming_output.result
+    print(f"Final result: {result.raw}")
+
+asyncio.run(main())
+```
+
+## Potential Use Cases
+
+- **Parallel Content Generation**: Kickoff multiple independent crews asynchronously, each responsible for generating content on different topics. For example, one crew might research and draft an article on AI trends, while another crew generates social media posts about a new product launch.
+
+- **Concurrent Market Research Tasks**: Launch multiple crews asynchronously to conduct market research in parallel. One crew might analyze industry trends, while another examines competitor strategies, and yet another evaluates consumer sentiment.
+
+- **Independent Travel Planning Modules**: Execute separate crews to independently plan different aspects of a trip. One crew might handle flight options, another handles accommodation, and a third plans activities.
+
+## Choosing Between `akickoff()` and `kickoff_async()`
+
+| Feature | `akickoff()` | `kickoff_async()` |
+|---------|--------------|-------------------|
+| Execution model | Native async/await | Thread-based wrapper |
+| Task execution | Async with `aexecute_sync()` | Sync in thread pool |
+| Memory operations | Async | Sync in thread pool |
+| Knowledge retrieval | Async | Sync in thread pool |
+| Best for | High-concurrency, I/O-bound workloads | Simple async integration |
+| Streaming support | Yes | Yes |

docs/en/learn/llm-selection-guide.mdx

@@ -394,7 +394,7 @@ Rather than repeating the strategic framework, here's a tactical checklist for i
 
   <Step title="Validate with Enterprise Testing" icon="test-tube">
     **Once you deploy your agents to production:**
-    - Use [CrewAI AMP platform](https://app.crewai.com) to A/B test your model selections
+    - Use [CrewAI AOP platform](https://app.crewai.com) to A/B test your model selections
     - Run multiple iterations with real inputs to measure consistency and performance
     - Compare cost vs. performance across your optimized setup
     - Share results with your team for collaborative decision-making
@@ -541,7 +541,7 @@ Focus on understanding your requirements first, then select models that best mat
 
 ### Enterprise-Grade Model Validation
 
-For teams serious about optimizing their LLM selection, the **CrewAI AMP platform** provides sophisticated testing capabilities that go far beyond basic CLI testing. The platform enables comprehensive model evaluation that helps you make data-driven decisions about your LLM strategy.
+For teams serious about optimizing their LLM selection, the **CrewAI AOP platform** provides sophisticated testing capabilities that go far beyond basic CLI testing. The platform enables comprehensive model evaluation that helps you make data-driven decisions about your LLM strategy.
 
 <Frame>
   ![Enterprise Testing Interface](/images/enterprise/enterprise-testing.png)

docs/en/learn/streaming-crew-execution.mdx

@@ -0,0 +1,356 @@
+---
+title: Streaming Crew Execution
+description: Stream real-time output from your CrewAI crew execution
+icon: wave-pulse
+mode: "wide"
+---
+
+## Introduction
+
+CrewAI provides the ability to stream real-time output during crew execution, allowing you to display results as they're generated rather than waiting for the entire process to complete. This feature is particularly useful for building interactive applications, providing user feedback, and monitoring long-running processes.
+
+## How Streaming Works
+
+When streaming is enabled, CrewAI captures LLM responses and tool calls as they happen, packaging them into structured chunks that include context about which task and agent is executing. You can iterate over these chunks in real-time and access the final result once execution completes.
+
+## Enabling Streaming
+
+To enable streaming, set the `stream` parameter to `True` when creating your crew:
+
+```python Code
+from crewai import Agent, Crew, Task
+
+# Create your agents and tasks
+researcher = Agent(
+    role="Research Analyst",
+    goal="Gather comprehensive information on topics",
+    backstory="You are an experienced researcher with excellent analytical skills.",
+)
+
+task = Task(
+    description="Research the latest developments in AI",
+    expected_output="A detailed report on recent AI advancements",
+    agent=researcher,
+)
+
+# Enable streaming
+crew = Crew(
+    agents=[researcher],
+    tasks=[task],
+    stream=True  # Enable streaming output
+)
+```
+
+## Synchronous Streaming
+
+When you call `kickoff()` on a crew with streaming enabled, it returns a `CrewStreamingOutput` object that you can iterate over to receive chunks as they arrive:
+
+```python Code
+# Start streaming execution
+streaming = crew.kickoff(inputs={"topic": "artificial intelligence"})
+
+# Iterate over chunks as they arrive
+for chunk in streaming:
+    print(chunk.content, end="", flush=True)
+
+# Access the final result after streaming completes
+result = streaming.result
+print(f"\n\nFinal output: {result.raw}")
+```
+
+### Stream Chunk Information
+
+Each chunk provides rich context about the execution:
+
+```python Code
+streaming = crew.kickoff(inputs={"topic": "AI"})
+
+for chunk in streaming:
+    print(f"Task: {chunk.task_name} (index {chunk.task_index})")
+    print(f"Agent: {chunk.agent_role}")
+    print(f"Content: {chunk.content}")
+    print(f"Type: {chunk.chunk_type}")  # TEXT or TOOL_CALL
+    if chunk.tool_call:
+        print(f"Tool: {chunk.tool_call.tool_name}")
+        print(f"Arguments: {chunk.tool_call.arguments}")
+```
+
+### Accessing Streaming Results
+
+The `CrewStreamingOutput` object provides several useful properties:
+
+```python Code
+streaming = crew.kickoff(inputs={"topic": "AI"})
+
+# Iterate and collect chunks
+for chunk in streaming:
+    print(chunk.content, end="", flush=True)
+
+# After iteration completes
+print(f"\nCompleted: {streaming.is_completed}")
+print(f"Full text: {streaming.get_full_text()}")
+print(f"All chunks: {len(streaming.chunks)}")
+print(f"Final result: {streaming.result.raw}")
+```
+
+## Asynchronous Streaming
+
+For async applications, you can use either `akickoff()` (native async) or `kickoff_async()` (thread-based) with async iteration:
+
+### Native Async with `akickoff()`
+
+The `akickoff()` method provides true native async execution throughout the entire chain:
+
+```python Code
+import asyncio
+
+async def stream_crew():
+    crew = Crew(
+        agents=[researcher],
+        tasks=[task],
+        stream=True
+    )
+
+    # Start native async streaming
+    streaming = await crew.akickoff(inputs={"topic": "AI"})
+
+    # Async iteration over chunks
+    async for chunk in streaming:
+        print(chunk.content, end="", flush=True)
+
+    # Access final result
+    result = streaming.result
+    print(f"\n\nFinal output: {result.raw}")
+
+asyncio.run(stream_crew())
+```
+
+### Thread-Based Async with `kickoff_async()`
+
+For simpler async integration or backward compatibility:
+
+```python Code
+import asyncio
+
+async def stream_crew():
+    crew = Crew(
+        agents=[researcher],
+        tasks=[task],
+        stream=True
+    )
+
+    # Start thread-based async streaming
+    streaming = await crew.kickoff_async(inputs={"topic": "AI"})
+
+    # Async iteration over chunks
+    async for chunk in streaming:
+        print(chunk.content, end="", flush=True)
+
+    # Access final result
+    result = streaming.result
+    print(f"\n\nFinal output: {result.raw}")
+
+asyncio.run(stream_crew())
+```
+
+<Note>
+For high-concurrency workloads, `akickoff()` is recommended as it uses native async for task execution, memory operations, and knowledge retrieval. See the [Kickoff Crew Asynchronously](/en/learn/kickoff-async) guide for more details.
+</Note>
+
+## Streaming with kickoff_for_each
+
+When executing a crew for multiple inputs with `kickoff_for_each()`, streaming works differently depending on whether you use sync or async:
+
+### Synchronous kickoff_for_each
+
+With synchronous `kickoff_for_each()`, you get a list of `CrewStreamingOutput` objects, one for each input:
+
+```python Code
+crew = Crew(
+    agents=[researcher],
+    tasks=[task],
+    stream=True
+)
+
+inputs_list = [
+    {"topic": "AI in healthcare"},
+    {"topic": "AI in finance"}
+]
+
+# Returns list of streaming outputs
+streaming_outputs = crew.kickoff_for_each(inputs=inputs_list)
+
+# Iterate over each streaming output
+for i, streaming in enumerate(streaming_outputs):
+    print(f"\n=== Input {i + 1} ===")
+    for chunk in streaming:
+        print(chunk.content, end="", flush=True)
+
+    result = streaming.result
+    print(f"\n\nResult {i + 1}: {result.raw}")
+```
+
+### Asynchronous kickoff_for_each_async
+
+With async `kickoff_for_each_async()`, you get a single `CrewStreamingOutput` that yields chunks from all crews as they arrive concurrently:
+
+```python Code
+import asyncio
+
+async def stream_multiple_crews():
+    crew = Crew(
+        agents=[researcher],
+        tasks=[task],
+        stream=True
+    )
+
+    inputs_list = [
+        {"topic": "AI in healthcare"},
+        {"topic": "AI in finance"}
+    ]
+
+    # Returns single streaming output for all crews
+    streaming = await crew.kickoff_for_each_async(inputs=inputs_list)
+
+    # Chunks from all crews arrive as they're generated
+    async for chunk in streaming:
+        print(f"[{chunk.task_name}] {chunk.content}", end="", flush=True)
+
+    # Access all results
+    results = streaming.results  # List of CrewOutput objects
+    for i, result in enumerate(results):
+        print(f"\n\nResult {i + 1}: {result.raw}")
+
+asyncio.run(stream_multiple_crews())
+```
+
+## Stream Chunk Types
+
+Chunks can be of different types, indicated by the `chunk_type` field:
+
+### TEXT Chunks
+
+Standard text content from LLM responses:
+
+```python Code
+for chunk in streaming:
+    if chunk.chunk_type == StreamChunkType.TEXT:
+        print(chunk.content, end="", flush=True)
+```
+
+### TOOL_CALL Chunks
+
+Information about tool calls being made:
+
+```python Code
+for chunk in streaming:
+    if chunk.chunk_type == StreamChunkType.TOOL_CALL:
+        print(f"\nCalling tool: {chunk.tool_call.tool_name}")
+        print(f"Arguments: {chunk.tool_call.arguments}")
+```
+
+## Practical Example: Building a UI with Streaming
+
+Here's a complete example showing how to build an interactive application with streaming:
+
+```python Code
+import asyncio
+from crewai import Agent, Crew, Task
+from crewai.types.streaming import StreamChunkType
+
+async def interactive_research():
+    # Create crew with streaming enabled
+    researcher = Agent(
+        role="Research Analyst",
+        goal="Provide detailed analysis on any topic",
+        backstory="You are an expert researcher with broad knowledge.",
+    )
+
+    task = Task(
+        description="Research and analyze: {topic}",
+        expected_output="A comprehensive analysis with key insights",
+        agent=researcher,
+    )
+
+    crew = Crew(
+        agents=[researcher],
+        tasks=[task],
+        stream=True,
+        verbose=False
+    )
+
+    # Get user input
+    topic = input("Enter a topic to research: ")
+
+    print(f"\n{'='*60}")
+    print(f"Researching: {topic}")
+    print(f"{'='*60}\n")
+
+    # Start streaming execution
+    streaming = await crew.kickoff_async(inputs={"topic": topic})
+
+    current_task = ""
+    async for chunk in streaming:
+        # Show task transitions
+        if chunk.task_name != current_task:
+            current_task = chunk.task_name
+            print(f"\n[{chunk.agent_role}] Working on: {chunk.task_name}")
+            print("-" * 60)
+
+        # Display text chunks
+        if chunk.chunk_type == StreamChunkType.TEXT:
+            print(chunk.content, end="", flush=True)
+
+        # Display tool calls
+        elif chunk.chunk_type == StreamChunkType.TOOL_CALL and chunk.tool_call:
+            print(f"\n🔧 Using tool: {chunk.tool_call.tool_name}")
+
+    # Show final result
+    result = streaming.result
+    print(f"\n\n{'='*60}")
+    print("Analysis Complete!")
+    print(f"{'='*60}")
+    print(f"\nToken Usage: {result.token_usage}")
+
+asyncio.run(interactive_research())
+```
+
+## Use Cases
+
+Streaming is particularly valuable for:
+
+- **Interactive Applications**: Provide real-time feedback to users as agents work
+- **Long-Running Tasks**: Show progress for research, analysis, or content generation
+- **Debugging and Monitoring**: Observe agent behavior and decision-making in real-time
+- **User Experience**: Reduce perceived latency by showing incremental results
+- **Live Dashboards**: Build monitoring interfaces that display crew execution status
+
+## Important Notes
+
+- Streaming automatically enables LLM streaming for all agents in the crew
+- You must iterate through all chunks before accessing the `.result` property
+- For `kickoff_for_each_async()` with streaming, use `.results` (plural) to get all outputs
+- Streaming adds minimal overhead and can actually improve perceived performance
+- Each chunk includes full context (task, agent, chunk type) for rich UIs
+
+## Error Handling
+
+Handle errors during streaming execution:
+
+```python Code
+streaming = crew.kickoff(inputs={"topic": "AI"})
+
+try:
+    for chunk in streaming:
+        print(chunk.content, end="", flush=True)
+
+    result = streaming.result
+    print(f"\nSuccess: {result.raw}")
+
+except Exception as e:
+    print(f"\nError during streaming: {e}")
+    if streaming.is_completed:
+        print("Streaming completed but an error occurred")
+```
+
+By leveraging streaming, you can build more responsive and interactive applications with CrewAI, providing users with real-time visibility into agent execution and results.

docs/en/learn/streaming-flow-execution.mdx

@@ -0,0 +1,450 @@
+---
+title: Streaming Flow Execution
+description: Stream real-time output from your CrewAI flow execution
+icon: wave-pulse
+mode: "wide"
+---
+
+## Introduction
+
+CrewAI Flows support streaming output, allowing you to receive real-time updates as your flow executes. This feature enables you to build responsive applications that display results incrementally, provide live progress updates, and create better user experiences for long-running workflows.
+
+## How Flow Streaming Works
+
+When streaming is enabled on a Flow, CrewAI captures and streams output from any crews or LLM calls within the flow. The stream delivers structured chunks containing the content, task context, and agent information as execution progresses.
+
+## Enabling Streaming
+
+To enable streaming, set the `stream` attribute to `True` on your Flow class:
+
+```python Code
+from crewai.flow.flow import Flow, listen, start
+from crewai import Agent, Crew, Task
+
+class ResearchFlow(Flow):
+    stream = True  # Enable streaming for the entire flow
+
+    @start()
+    def initialize(self):
+        return {"topic": "AI trends"}
+
+    @listen(initialize)
+    def research_topic(self, data):
+        researcher = Agent(
+            role="Research Analyst",
+            goal="Research topics thoroughly",
+            backstory="Expert researcher with analytical skills",
+        )
+
+        task = Task(
+            description="Research {topic} and provide insights",
+            expected_output="Detailed research findings",
+            agent=researcher,
+        )
+
+        crew = Crew(
+            agents=[researcher],
+            tasks=[task],
+        )
+
+        return crew.kickoff(inputs=data)
+```
+
+## Synchronous Streaming
+
+When you call `kickoff()` on a flow with streaming enabled, it returns a `FlowStreamingOutput` object that you can iterate over:
+
+```python Code
+flow = ResearchFlow()
+
+# Start streaming execution
+streaming = flow.kickoff()
+
+# Iterate over chunks as they arrive
+for chunk in streaming:
+    print(chunk.content, end="", flush=True)
+
+# Access the final result after streaming completes
+result = streaming.result
+print(f"\n\nFinal output: {result}")
+```
+
+### Stream Chunk Information
+
+Each chunk provides context about where it originated in the flow:
+
+```python Code
+streaming = flow.kickoff()
+
+for chunk in streaming:
+    print(f"Agent: {chunk.agent_role}")
+    print(f"Task: {chunk.task_name}")
+    print(f"Content: {chunk.content}")
+    print(f"Type: {chunk.chunk_type}")  # TEXT or TOOL_CALL
+```
+
+### Accessing Streaming Properties
+
+The `FlowStreamingOutput` object provides useful properties and methods:
+
+```python Code
+streaming = flow.kickoff()
+
+# Iterate and collect chunks
+for chunk in streaming:
+    print(chunk.content, end="", flush=True)
+
+# After iteration completes
+print(f"\nCompleted: {streaming.is_completed}")
+print(f"Full text: {streaming.get_full_text()}")
+print(f"Total chunks: {len(streaming.chunks)}")
+print(f"Final result: {streaming.result}")
+```
+
+## Asynchronous Streaming
+
+For async applications, use `kickoff_async()` with async iteration:
+
+```python Code
+import asyncio
+
+async def stream_flow():
+    flow = ResearchFlow()
+
+    # Start async streaming
+    streaming = await flow.kickoff_async()
+
+    # Async iteration over chunks
+    async for chunk in streaming:
+        print(chunk.content, end="", flush=True)
+
+    # Access final result
+    result = streaming.result
+    print(f"\n\nFinal output: {result}")
+
+asyncio.run(stream_flow())
+```
+
+## Streaming with Multi-Step Flows
+
+Streaming works seamlessly across multiple flow steps, including flows that execute multiple crews:
+
+```python Code
+from crewai.flow.flow import Flow, listen, start
+from crewai import Agent, Crew, Task
+
+class MultiStepFlow(Flow):
+    stream = True
+
+    @start()
+    def research_phase(self):
+        """First crew: Research the topic."""
+        researcher = Agent(
+            role="Research Analyst",
+            goal="Gather comprehensive information",
+            backstory="Expert at finding relevant information",
+        )
+
+        task = Task(
+            description="Research AI developments in healthcare",
+            expected_output="Research findings on AI in healthcare",
+            agent=researcher,
+        )
+
+        crew = Crew(agents=[researcher], tasks=[task])
+        result = crew.kickoff()
+
+        self.state["research"] = result.raw
+        return result.raw
+
+    @listen(research_phase)
+    def analysis_phase(self, research_data):
+        """Second crew: Analyze the research."""
+        analyst = Agent(
+            role="Data Analyst",
+            goal="Analyze information and extract insights",
+            backstory="Expert at identifying patterns and trends",
+        )
+
+        task = Task(
+            description="Analyze this research: {research}",
+            expected_output="Key insights and trends",
+            agent=analyst,
+        )
+
+        crew = Crew(agents=[analyst], tasks=[task])
+        return crew.kickoff(inputs={"research": research_data})
+
+
+# Stream across both phases
+flow = MultiStepFlow()
+streaming = flow.kickoff()
+
+current_step = ""
+for chunk in streaming:
+    # Track which flow step is executing
+    if chunk.task_name != current_step:
+        current_step = chunk.task_name
+        print(f"\n\n=== {chunk.task_name} ===\n")
+
+    print(chunk.content, end="", flush=True)
+
+result = streaming.result
+print(f"\n\nFinal analysis: {result}")
+```
+
+## Practical Example: Progress Dashboard
+
+Here's a complete example showing how to build a progress dashboard with streaming:
+
+```python Code
+import asyncio
+from crewai.flow.flow import Flow, listen, start
+from crewai import Agent, Crew, Task
+from crewai.types.streaming import StreamChunkType
+
+class ResearchPipeline(Flow):
+    stream = True
+
+    @start()
+    def gather_data(self):
+        researcher = Agent(
+            role="Data Gatherer",
+            goal="Collect relevant information",
+            backstory="Skilled at finding quality sources",
+        )
+
+        task = Task(
+            description="Gather data on renewable energy trends",
+            expected_output="Collection of relevant data points",
+            agent=researcher,
+        )
+
+        crew = Crew(agents=[researcher], tasks=[task])
+        result = crew.kickoff()
+        self.state["data"] = result.raw
+        return result.raw
+
+    @listen(gather_data)
+    def analyze_data(self, data):
+        analyst = Agent(
+            role="Data Analyst",
+            goal="Extract meaningful insights",
+            backstory="Expert at data analysis",
+        )
+
+        task = Task(
+            description="Analyze: {data}",
+            expected_output="Key insights and trends",
+            agent=analyst,
+        )
+
+        crew = Crew(agents=[analyst], tasks=[task])
+        return crew.kickoff(inputs={"data": data})
+
+
+async def run_with_dashboard():
+    flow = ResearchPipeline()
+
+    print("="*60)
+    print("RESEARCH PIPELINE DASHBOARD")
+    print("="*60)
+
+    streaming = await flow.kickoff_async()
+
+    current_agent = ""
+    current_task = ""
+    chunk_count = 0
+
+    async for chunk in streaming:
+        chunk_count += 1
+
+        # Display phase transitions
+        if chunk.task_name != current_task:
+            current_task = chunk.task_name
+            current_agent = chunk.agent_role
+            print(f"\n\n📋 Phase: {current_task}")
+            print(f"👤 Agent: {current_agent}")
+            print("-" * 60)
+
+        # Display text output
+        if chunk.chunk_type == StreamChunkType.TEXT:
+            print(chunk.content, end="", flush=True)
+
+        # Display tool usage
+        elif chunk.chunk_type == StreamChunkType.TOOL_CALL and chunk.tool_call:
+            print(f"\n🔧 Tool: {chunk.tool_call.tool_name}")
+
+    # Show completion summary
+    result = streaming.result
+    print(f"\n\n{'='*60}")
+    print("PIPELINE COMPLETE")
+    print(f"{'='*60}")
+    print(f"Total chunks: {chunk_count}")
+    print(f"Final output length: {len(str(result))} characters")
+
+asyncio.run(run_with_dashboard())
+```
+
+## Streaming with State Management
+
+Streaming works naturally with Flow state management:
+
+```python Code
+from pydantic import BaseModel
+
+class AnalysisState(BaseModel):
+    topic: str = ""
+    research: str = ""
+    insights: str = ""
+
+class StatefulStreamingFlow(Flow[AnalysisState]):
+    stream = True
+
+    @start()
+    def research(self):
+        # State is available during streaming
+        topic = self.state.topic
+        print(f"Researching: {topic}")
+
+        researcher = Agent(
+            role="Researcher",
+            goal="Research topics thoroughly",
+            backstory="Expert researcher",
+        )
+
+        task = Task(
+            description=f"Research {topic}",
+            expected_output="Research findings",
+            agent=researcher,
+        )
+
+        crew = Crew(agents=[researcher], tasks=[task])
+        result = crew.kickoff()
+
+        self.state.research = result.raw
+        return result.raw
+
+    @listen(research)
+    def analyze(self, research):
+        # Access updated state
+        print(f"Analyzing {len(self.state.research)} chars of research")
+
+        analyst = Agent(
+            role="Analyst",
+            goal="Extract insights",
+            backstory="Expert analyst",
+        )
+
+        task = Task(
+            description="Analyze: {research}",
+            expected_output="Key insights",
+            agent=analyst,
+        )
+
+        crew = Crew(agents=[analyst], tasks=[task])
+        result = crew.kickoff(inputs={"research": research})
+
+        self.state.insights = result.raw
+        return result.raw
+
+
+# Run with streaming
+flow = StatefulStreamingFlow()
+streaming = flow.kickoff(inputs={"topic": "quantum computing"})
+
+for chunk in streaming:
+    print(chunk.content, end="", flush=True)
+
+result = streaming.result
+print(f"\n\nFinal state:")
+print(f"Topic: {flow.state.topic}")
+print(f"Research length: {len(flow.state.research)}")
+print(f"Insights length: {len(flow.state.insights)}")
+```
+
+## Use Cases
+
+Flow streaming is particularly valuable for:
+
+- **Multi-Stage Workflows**: Show progress across research, analysis, and synthesis phases
+- **Complex Pipelines**: Provide visibility into long-running data processing flows
+- **Interactive Applications**: Build responsive UIs that display intermediate results
+- **Monitoring and Debugging**: Observe flow execution and crew interactions in real-time
+- **Progress Tracking**: Show users which stage of the workflow is currently executing
+- **Live Dashboards**: Create monitoring interfaces for production flows
+
+## Stream Chunk Types
+
+Like crew streaming, flow chunks can be of different types:
+
+### TEXT Chunks
+
+Standard text content from LLM responses:
+
+```python Code
+for chunk in streaming:
+    if chunk.chunk_type == StreamChunkType.TEXT:
+        print(chunk.content, end="", flush=True)
+```
+
+### TOOL_CALL Chunks
+
+Information about tool calls within the flow:
+
+```python Code
+for chunk in streaming:
+    if chunk.chunk_type == StreamChunkType.TOOL_CALL and chunk.tool_call:
+        print(f"\nTool: {chunk.tool_call.tool_name}")
+        print(f"Args: {chunk.tool_call.arguments}")
+```
+
+## Error Handling
+
+Handle errors gracefully during streaming:
+
+```python Code
+flow = ResearchFlow()
+streaming = flow.kickoff()
+
+try:
+    for chunk in streaming:
+        print(chunk.content, end="", flush=True)
+
+    result = streaming.result
+    print(f"\nSuccess! Result: {result}")
+
+except Exception as e:
+    print(f"\nError during flow execution: {e}")
+    if streaming.is_completed:
+        print("Streaming completed but flow encountered an error")
+```
+
+## Important Notes
+
+- Streaming automatically enables LLM streaming for any crews used within the flow
+- You must iterate through all chunks before accessing the `.result` property
+- Streaming works with both structured and unstructured flow state
+- Flow streaming captures output from all crews and LLM calls in the flow
+- Each chunk includes context about which agent and task generated it
+- Streaming adds minimal overhead to flow execution
+
+## Combining with Flow Visualization
+
+You can combine streaming with flow visualization to provide a complete picture:
+
+```python Code
+# Generate flow visualization
+flow = ResearchFlow()
+flow.plot("research_flow")  # Creates HTML visualization
+
+# Run with streaming
+streaming = flow.kickoff()
+for chunk in streaming:
+    print(chunk.content, end="", flush=True)
+
+result = streaming.result
+print(f"\nFlow complete! View structure at: research_flow.html")
+```
+
+By leveraging flow streaming, you can build sophisticated, responsive applications that provide users with real-time visibility into complex multi-stage workflows, making your AI automations more transparent and engaging.

docs/en/mcp/dsl-integration.mdx

@@ -60,9 +60,9 @@ Use the `#` syntax to select specific tools from a server:
 "https://mcp.exa.ai/mcp?api_key=your_key#web_search_exa"
 ```
 
-### CrewAI AMP Marketplace
+### CrewAI AOP Marketplace
 
-Access tools from the CrewAI AMP marketplace:
+Access tools from the CrewAI AOP marketplace:
 
 ```python
 # Full service with all tools
@@ -97,7 +97,7 @@ multi_source_agent = Agent(
         "https://mcp.exa.ai/mcp?api_key=your_exa_key&profile=research",
         "https://weather.api.com/mcp#get_current_conditions",
 
-        # CrewAI AMP marketplace
+        # CrewAI AOP marketplace
         "crewai-amp:financial-insights",
         "crewai-amp:academic-research#pubmed_search",
         "crewai-amp:market-intelligence#competitor_analysis"

docs/en/mcp/overview.mdx

@@ -17,7 +17,7 @@ Use the `mcps` field directly on agents for seamless MCP tool integration. The D
 
 #### String-Based References (Quick Setup)
 
-Perfect for remote HTTPS servers and CrewAI AMP marketplace:
+Perfect for remote HTTPS servers and CrewAI AOP marketplace:
 
 ```python
 from crewai import Agent
@@ -29,7 +29,7 @@ agent = Agent(
     mcps=[
         "https://mcp.exa.ai/mcp?api_key=your_key",           # External MCP server
         "https://api.weather.com/mcp#get_forecast",          # Specific tool from server
-        "crewai-amp:financial-data",                         # CrewAI AMP marketplace
+        "crewai-amp:financial-data",                         # CrewAI AOP marketplace
         "crewai-amp:research-tools#pubmed_search"            # Specific AMP tool
     ]
 )
@@ -203,7 +203,7 @@ mcps=[
 ]
 ```
 
-#### CrewAI AMP Marketplace
+#### CrewAI AOP Marketplace
 
 ```python
 mcps=[

docs/en/observability/tracing.mdx

@@ -1,6 +1,6 @@
 ---
 title: CrewAI Tracing
-description: Built-in tracing for CrewAI Crews and Flows with the CrewAI AMP platform
+description: Built-in tracing for CrewAI Crews and Flows with the CrewAI AOP platform
 icon: magnifying-glass-chart
 mode: "wide"
 ---
@@ -9,7 +9,7 @@ mode: "wide"
 
 CrewAI provides built-in tracing capabilities that allow you to monitor and debug your Crews and Flows in real-time. This guide demonstrates how to enable tracing for both **Crews** and **Flows** using CrewAI's integrated observability platform.
 
-> **What is CrewAI Tracing?** CrewAI's built-in tracing provides comprehensive observability for your AI agents, including agent decisions, task execution timelines, tool usage, and LLM calls - all accessible through the [CrewAI AMP platform](https://app.crewai.com).
+> **What is CrewAI Tracing?** CrewAI's built-in tracing provides comprehensive observability for your AI agents, including agent decisions, task execution timelines, tool usage, and LLM calls - all accessible through the [CrewAI AOP platform](https://app.crewai.com).
 
 ![CrewAI Tracing Interface](/images/crewai-tracing.png)
 
@@ -17,7 +17,7 @@ CrewAI provides built-in tracing capabilities that allow you to monitor and debu
 
 Before you can use CrewAI tracing, you need:
 
-1. **CrewAI AMP Account**: Sign up for a free account at [app.crewai.com](https://app.crewai.com)
+1. **CrewAI AOP Account**: Sign up for a free account at [app.crewai.com](https://app.crewai.com)
 2. **CLI Authentication**: Use the CrewAI CLI to authenticate your local environment
 
 ```bash
@@ -26,9 +26,9 @@ crewai login
 
 ## Setup Instructions
 
-### Step 1: Create Your CrewAI AMP Account
+### Step 1: Create Your CrewAI AOP Account
 
-Visit [app.crewai.com](https://app.crewai.com) and create your free account. This will give you access to the CrewAI AMP platform where you can view traces, metrics, and manage your crews.
+Visit [app.crewai.com](https://app.crewai.com) and create your free account. This will give you access to the CrewAI AOP platform where you can view traces, metrics, and manage your crews.
 
 ### Step 2: Install CrewAI CLI and Authenticate
 
@@ -38,7 +38,7 @@ If you haven't already, install CrewAI with the CLI tools:
 uv add crewai[tools]
 ```
 
-Then authenticate your CLI with your CrewAI AMP account:
+Then authenticate your CLI with your CrewAI AOP account:
 
 ```bash
 crewai login
@@ -47,7 +47,7 @@ crewai login
 This command will:
 1. Open your browser to the authentication page
 2. Prompt you to enter a device code
-3. Authenticate your local environment with your CrewAI AMP account
+3. Authenticate your local environment with your CrewAI AOP account
 4. Enable tracing capabilities for your local development
 
 ### Step 3: Enable Tracing in Your Crew
@@ -147,9 +147,9 @@ flow = ExampleFlow(tracing=True)
 result = flow.kickoff()
 ```
 
-### Step 5: View Traces in the CrewAI AMP Dashboard
+### Step 5: View Traces in the CrewAI AOP Dashboard
 
-After running the crew or flow, you can view the traces generated by your CrewAI application in the CrewAI AMP dashboard. You should see detailed steps of the agent interactions, tool usages, and LLM calls.
+After running the crew or flow, you can view the traces generated by your CrewAI application in the CrewAI AOP dashboard. You should see detailed steps of the agent interactions, tool usages, and LLM calls.
 Just click on the link below to view the traces or head over to the traces tab in the dashboard [here](https://app.crewai.com/crewai_plus/trace_batches)
 ![CrewAI Tracing Interface](/images/view-traces.png)
 
@@ -172,7 +172,7 @@ When this environment variable is set, all Crews and Flows will automatically ha
 
 ## Viewing Your Traces
 
-### Access the CrewAI AMP Dashboard
+### Access the CrewAI AOP Dashboard
 
 1. Visit [app.crewai.com](https://app.crewai.com) and log in to your account
 2. Navigate to your project dashboard

docs/en/quickstart.mdx

@@ -209,9 +209,9 @@ Follow the steps below to get Crewing! 🚣‍♂️
   </Step>
 
   <Step title="Enterprise Alternative: Create in Crew Studio">
-  For CrewAI AMP users, you can create the same crew without writing code:
+  For CrewAI AOP users, you can create the same crew without writing code:
 
-  1. Log in to your CrewAI AMP account (create a free account at [app.crewai.com](https://app.crewai.com))
+  1. Log in to your CrewAI AOP account (create a free account at [app.crewai.com](https://app.crewai.com))
   2. Open Crew Studio
   3. Type what is the automation you're trying to build
   4. Create your tasks visually and connect them in sequence
@@ -219,8 +219,8 @@ Follow the steps below to get Crewing! 🚣‍♂️
 
   ![Crew Studio Quickstart](/images/enterprise/crew-studio-interface.png)
 
-  <Card title="Try CrewAI AMP" icon="rocket" href="https://app.crewai.com">
-    Start your free account at CrewAI AMP
+  <Card title="Try CrewAI AOP" icon="rocket" href="https://app.crewai.com">
+    Start your free account at CrewAI AOP
   </Card>
   </Step>
   <Step title="View your final report">
@@ -340,9 +340,9 @@ email_summarizer_task:
 
 ## Deploying Your Crew
 
-The easiest way to deploy your crew to production is through [CrewAI AMP](http://app.crewai.com).
+The easiest way to deploy your crew to production is through [CrewAI AOP](http://app.crewai.com).
 
-Watch this video tutorial for a step-by-step demonstration of deploying your crew to [CrewAI AMP](http://app.crewai.com) using the CLI.
+Watch this video tutorial for a step-by-step demonstration of deploying your crew to [CrewAI AOP](http://app.crewai.com) using the CLI.
 
 <iframe
   className="w-full aspect-video rounded-xl"
@@ -359,7 +359,7 @@ Watch this video tutorial for a step-by-step demonstration of deploying your cre
     icon="rocket"
     href="http://app.crewai.com"
   >
-    Get started with CrewAI AMP and deploy your crew in a production environment with just a few clicks.
+    Get started with CrewAI AOP and deploy your crew in a production environment with just a few clicks.
   </Card>
   <Card
     title="Join the Community"

docs/en/tools/ai-ml/ragtool.mdx

@@ -77,7 +77,7 @@ The `RagTool` accepts the following parameters:
 
 - **summarize**: Optional. Whether to summarize the retrieved content. Default is `False`.
 - **adapter**: Optional. A custom adapter for the knowledge base. If not provided, a CrewAIRagAdapter will be used.
-- **config**: Optional. Configuration for the underlying CrewAI RAG system.
+- **config**: Optional. Configuration for the underlying CrewAI RAG system. Accepts a `RagToolConfig` TypedDict with optional `embedding_model` (ProviderSpec) and `vectordb` (VectorDbConfig) keys. All configuration values provided programmatically take precedence over environment variables.
 
 ## Adding Content
 
@@ -127,26 +127,528 @@ You can customize the behavior of the `RagTool` by providing a configuration dic
 
 ```python Code
 from crewai_tools import RagTool
+from crewai_tools.tools.rag import RagToolConfig, VectorDbConfig, ProviderSpec
 
 # Create a RAG tool with custom configuration
-config = {
-    "vectordb": {
-        "provider": "qdrant",
-        "config": {
-            "collection_name": "my-collection"
-        }
-    },
-    "embedding_model": {
-        "provider": "openai",
-        "config": {
-            "model": "text-embedding-3-small"
-        }
+
+vectordb: VectorDbConfig = {
+    "provider": "qdrant",
+    "config": {
+        "collection_name": "my-collection"
     }
 }
 
+embedding_model: ProviderSpec = {
+    "provider": "openai",
+    "config": {
+        "model_name": "text-embedding-3-small"
+    }
+}
+
+config: RagToolConfig = {
+    "vectordb": vectordb,
+    "embedding_model": embedding_model
+}
+
 rag_tool = RagTool(config=config, summarize=True)
 ```
 
+## Embedding Model Configuration
+
+The `embedding_model` parameter accepts a `crewai.rag.embeddings.types.ProviderSpec` dictionary with the structure:
+
+```python
+{
+    "provider": "provider-name",  # Required
+    "config": {                    # Optional
+        # Provider-specific configuration
+    }
+}
+```
+
+### Supported Providers
+
+<AccordionGroup>
+  <Accordion title="OpenAI">
+    ```python main.py
+    from crewai.rag.embeddings.providers.openai.types import OpenAIProviderSpec
+
+    embedding_model: OpenAIProviderSpec = {
+        "provider": "openai",
+        "config": {
+            "api_key": "your-api-key",
+            "model_name": "text-embedding-ada-002",
+            "dimensions": 1536,
+            "organization_id": "your-org-id",
+            "api_base": "https://api.openai.com/v1",
+            "api_version": "v1",
+            "default_headers": {"Custom-Header": "value"}
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `api_key` (str): OpenAI API key
+    - `model_name` (str): Model to use. Default: `text-embedding-ada-002`. Options: `text-embedding-3-small`, `text-embedding-3-large`, `text-embedding-ada-002`
+    - `dimensions` (int): Number of dimensions for the embedding
+    - `organization_id` (str): OpenAI organization ID
+    - `api_base` (str): Custom API base URL
+    - `api_version` (str): API version
+    - `default_headers` (dict): Custom headers for API requests
+
+    **Environment Variables:**
+    - `OPENAI_API_KEY` or `EMBEDDINGS_OPENAI_API_KEY`: `api_key`
+    - `OPENAI_ORGANIZATION_ID` or `EMBEDDINGS_OPENAI_ORGANIZATION_ID`: `organization_id`
+    - `OPENAI_MODEL_NAME` or `EMBEDDINGS_OPENAI_MODEL_NAME`: `model_name`
+    - `OPENAI_API_BASE` or `EMBEDDINGS_OPENAI_API_BASE`: `api_base`
+    - `OPENAI_API_VERSION` or `EMBEDDINGS_OPENAI_API_VERSION`: `api_version`
+    - `OPENAI_DIMENSIONS` or `EMBEDDINGS_OPENAI_DIMENSIONS`: `dimensions`
+  </Accordion>
+
+  <Accordion title="Cohere">
+    ```python main.py
+    from crewai.rag.embeddings.providers.cohere.types import CohereProviderSpec
+
+    embedding_model: CohereProviderSpec = {
+        "provider": "cohere",
+        "config": {
+            "api_key": "your-api-key",
+            "model_name": "embed-english-v3.0"
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `api_key` (str): Cohere API key
+    - `model_name` (str): Model to use. Default: `large`. Options: `embed-english-v3.0`, `embed-multilingual-v3.0`, `large`, `small`
+
+    **Environment Variables:**
+    - `COHERE_API_KEY` or `EMBEDDINGS_COHERE_API_KEY`: `api_key`
+    - `EMBEDDINGS_COHERE_MODEL_NAME`: `model_name`
+  </Accordion>
+
+  <Accordion title="VoyageAI">
+    ```python main.py
+    from crewai.rag.embeddings.providers.voyageai.types import VoyageAIProviderSpec
+
+    embedding_model: VoyageAIProviderSpec = {
+        "provider": "voyageai",
+        "config": {
+            "api_key": "your-api-key",
+            "model": "voyage-3",
+            "input_type": "document",
+            "truncation": True,
+            "output_dtype": "float32",
+            "output_dimension": 1024,
+            "max_retries": 3,
+            "timeout": 60.0
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `api_key` (str): VoyageAI API key
+    - `model` (str): Model to use. Default: `voyage-2`. Options: `voyage-3`, `voyage-3-lite`, `voyage-code-3`, `voyage-large-2`
+    - `input_type` (str): Type of input. Options: `document` (for storage), `query` (for search)
+    - `truncation` (bool): Whether to truncate inputs that exceed max length. Default: `True`
+    - `output_dtype` (str): Output data type
+    - `output_dimension` (int): Dimension of output embeddings
+    - `max_retries` (int): Maximum number of retry attempts. Default: `0`
+    - `timeout` (float): Request timeout in seconds
+
+    **Environment Variables:**
+    - `VOYAGEAI_API_KEY` or `EMBEDDINGS_VOYAGEAI_API_KEY`: `api_key`
+    - `VOYAGEAI_MODEL` or `EMBEDDINGS_VOYAGEAI_MODEL`: `model`
+    - `VOYAGEAI_INPUT_TYPE` or `EMBEDDINGS_VOYAGEAI_INPUT_TYPE`: `input_type`
+    - `VOYAGEAI_TRUNCATION` or `EMBEDDINGS_VOYAGEAI_TRUNCATION`: `truncation`
+    - `VOYAGEAI_OUTPUT_DTYPE` or `EMBEDDINGS_VOYAGEAI_OUTPUT_DTYPE`: `output_dtype`
+    - `VOYAGEAI_OUTPUT_DIMENSION` or `EMBEDDINGS_VOYAGEAI_OUTPUT_DIMENSION`: `output_dimension`
+    - `VOYAGEAI_MAX_RETRIES` or `EMBEDDINGS_VOYAGEAI_MAX_RETRIES`: `max_retries`
+    - `VOYAGEAI_TIMEOUT` or `EMBEDDINGS_VOYAGEAI_TIMEOUT`: `timeout`
+  </Accordion>
+
+  <Accordion title="Ollama">
+    ```python main.py
+    from crewai.rag.embeddings.providers.ollama.types import OllamaProviderSpec
+
+    embedding_model: OllamaProviderSpec = {
+        "provider": "ollama",
+        "config": {
+            "model_name": "llama2",
+            "url": "http://localhost:11434/api/embeddings"
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `model_name` (str): Ollama model name (e.g., `llama2`, `mistral`, `nomic-embed-text`)
+    - `url` (str): Ollama API endpoint URL. Default: `http://localhost:11434/api/embeddings`
+
+    **Environment Variables:**
+    - `OLLAMA_MODEL` or `EMBEDDINGS_OLLAMA_MODEL`: `model_name`
+    - `OLLAMA_URL` or `EMBEDDINGS_OLLAMA_URL`: `url`
+  </Accordion>
+
+  <Accordion title="Amazon Bedrock">
+    ```python main.py
+    from crewai.rag.embeddings.providers.aws.types import BedrockProviderSpec
+
+    embedding_model: BedrockProviderSpec = {
+        "provider": "amazon-bedrock",
+        "config": {
+            "model_name": "amazon.titan-embed-text-v2:0",
+            "session": boto3_session
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `model_name` (str): Bedrock model ID. Default: `amazon.titan-embed-text-v1`. Options: `amazon.titan-embed-text-v1`, `amazon.titan-embed-text-v2:0`, `cohere.embed-english-v3`, `cohere.embed-multilingual-v3`
+    - `session` (Any): Boto3 session object for AWS authentication
+
+    **Environment Variables:**
+    - `AWS_ACCESS_KEY_ID`: AWS access key
+    - `AWS_SECRET_ACCESS_KEY`: AWS secret key
+    - `AWS_REGION`: AWS region (e.g., `us-east-1`)
+  </Accordion>
+
+  <Accordion title="Azure OpenAI">
+    ```python main.py
+    from crewai.rag.embeddings.providers.microsoft.types import AzureProviderSpec
+
+    embedding_model: AzureProviderSpec = {
+        "provider": "azure",
+        "config": {
+            "deployment_id": "your-deployment-id",
+            "api_key": "your-api-key",
+            "api_base": "https://your-resource.openai.azure.com",
+            "api_version": "2024-02-01",
+            "model_name": "text-embedding-ada-002",
+            "api_type": "azure"
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `deployment_id` (str): **Required** - Azure OpenAI deployment ID
+    - `api_key` (str): Azure OpenAI API key
+    - `api_base` (str): Azure OpenAI resource endpoint
+    - `api_version` (str): API version. Example: `2024-02-01`
+    - `model_name` (str): Model name. Default: `text-embedding-ada-002`
+    - `api_type` (str): API type. Default: `azure`
+    - `dimensions` (int): Output dimensions
+    - `default_headers` (dict): Custom headers
+
+    **Environment Variables:**
+    - `AZURE_OPENAI_API_KEY` or `EMBEDDINGS_AZURE_API_KEY`: `api_key`
+    - `AZURE_OPENAI_ENDPOINT` or `EMBEDDINGS_AZURE_API_BASE`: `api_base`
+    - `EMBEDDINGS_AZURE_DEPLOYMENT_ID`: `deployment_id`
+    - `EMBEDDINGS_AZURE_API_VERSION`: `api_version`
+    - `EMBEDDINGS_AZURE_MODEL_NAME`: `model_name`
+    - `EMBEDDINGS_AZURE_API_TYPE`: `api_type`
+    - `EMBEDDINGS_AZURE_DIMENSIONS`: `dimensions`
+  </Accordion>
+
+  <Accordion title="Google Generative AI">
+    ```python main.py
+    from crewai.rag.embeddings.providers.google.types import GenerativeAiProviderSpec
+
+    embedding_model: GenerativeAiProviderSpec = {
+        "provider": "google-generativeai",
+        "config": {
+            "api_key": "your-api-key",
+            "model_name": "gemini-embedding-001",
+            "task_type": "RETRIEVAL_DOCUMENT"
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `api_key` (str): Google AI API key
+    - `model_name` (str): Model name. Default: `gemini-embedding-001`. Options: `gemini-embedding-001`, `text-embedding-005`, `text-multilingual-embedding-002`
+    - `task_type` (str): Task type for embeddings. Default: `RETRIEVAL_DOCUMENT`. Options: `RETRIEVAL_DOCUMENT`, `RETRIEVAL_QUERY`
+
+    **Environment Variables:**
+    - `GOOGLE_API_KEY`, `GEMINI_API_KEY`, or `EMBEDDINGS_GOOGLE_API_KEY`: `api_key`
+    - `EMBEDDINGS_GOOGLE_GENERATIVE_AI_MODEL_NAME`: `model_name`
+    - `EMBEDDINGS_GOOGLE_GENERATIVE_AI_TASK_TYPE`: `task_type`
+  </Accordion>
+
+  <Accordion title="Google Vertex AI">
+    ```python main.py
+    from crewai.rag.embeddings.providers.google.types import VertexAIProviderSpec
+
+    embedding_model: VertexAIProviderSpec = {
+        "provider": "google-vertex",
+        "config": {
+            "model_name": "text-embedding-004",
+            "project_id": "your-project-id",
+            "region": "us-central1",
+            "api_key": "your-api-key"
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `model_name` (str): Model name. Default: `textembedding-gecko`. Options: `text-embedding-004`, `textembedding-gecko`, `textembedding-gecko-multilingual`
+    - `project_id` (str): Google Cloud project ID. Default: `cloud-large-language-models`
+    - `region` (str): Google Cloud region. Default: `us-central1`
+    - `api_key` (str): API key for authentication
+
+    **Environment Variables:**
+    - `GOOGLE_APPLICATION_CREDENTIALS`: Path to service account JSON file
+    - `GOOGLE_CLOUD_PROJECT` or `EMBEDDINGS_GOOGLE_VERTEX_PROJECT_ID`: `project_id`
+    - `EMBEDDINGS_GOOGLE_VERTEX_MODEL_NAME`: `model_name`
+    - `EMBEDDINGS_GOOGLE_VERTEX_REGION`: `region`
+    - `EMBEDDINGS_GOOGLE_VERTEX_API_KEY`: `api_key`
+  </Accordion>
+
+  <Accordion title="Jina AI">
+    ```python main.py
+    from crewai.rag.embeddings.providers.jina.types import JinaProviderSpec
+
+    embedding_model: JinaProviderSpec = {
+        "provider": "jina",
+        "config": {
+            "api_key": "your-api-key",
+            "model_name": "jina-embeddings-v3"
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `api_key` (str): Jina AI API key
+    - `model_name` (str): Model name. Default: `jina-embeddings-v2-base-en`. Options: `jina-embeddings-v3`, `jina-embeddings-v2-base-en`, `jina-embeddings-v2-small-en`
+
+    **Environment Variables:**
+    - `JINA_API_KEY` or `EMBEDDINGS_JINA_API_KEY`: `api_key`
+    - `EMBEDDINGS_JINA_MODEL_NAME`: `model_name`
+  </Accordion>
+
+  <Accordion title="HuggingFace">
+    ```python main.py
+    from crewai.rag.embeddings.providers.huggingface.types import HuggingFaceProviderSpec
+
+    embedding_model: HuggingFaceProviderSpec = {
+        "provider": "huggingface",
+        "config": {
+            "url": "https://api-inference.huggingface.co/models/sentence-transformers/all-MiniLM-L6-v2"
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `url` (str): Full URL to HuggingFace inference API endpoint
+
+    **Environment Variables:**
+    - `HUGGINGFACE_URL` or `EMBEDDINGS_HUGGINGFACE_URL`: `url`
+  </Accordion>
+
+  <Accordion title="Instructor">
+    ```python main.py
+    from crewai.rag.embeddings.providers.instructor.types import InstructorProviderSpec
+
+    embedding_model: InstructorProviderSpec = {
+        "provider": "instructor",
+        "config": {
+            "model_name": "hkunlp/instructor-xl",
+            "device": "cuda",
+            "instruction": "Represent the document"
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `model_name` (str): HuggingFace model ID. Default: `hkunlp/instructor-base`. Options: `hkunlp/instructor-xl`, `hkunlp/instructor-large`, `hkunlp/instructor-base`
+    - `device` (str): Device to run on. Default: `cpu`. Options: `cpu`, `cuda`, `mps`
+    - `instruction` (str): Instruction prefix for embeddings
+
+    **Environment Variables:**
+    - `EMBEDDINGS_INSTRUCTOR_MODEL_NAME`: `model_name`
+    - `EMBEDDINGS_INSTRUCTOR_DEVICE`: `device`
+    - `EMBEDDINGS_INSTRUCTOR_INSTRUCTION`: `instruction`
+  </Accordion>
+
+  <Accordion title="Sentence Transformer">
+    ```python main.py
+    from crewai.rag.embeddings.providers.sentence_transformer.types import SentenceTransformerProviderSpec
+
+    embedding_model: SentenceTransformerProviderSpec = {
+        "provider": "sentence-transformer",
+        "config": {
+            "model_name": "all-mpnet-base-v2",
+            "device": "cuda",
+            "normalize_embeddings": True
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `model_name` (str): Sentence Transformers model name. Default: `all-MiniLM-L6-v2`. Options: `all-mpnet-base-v2`, `all-MiniLM-L6-v2`, `paraphrase-multilingual-MiniLM-L12-v2`
+    - `device` (str): Device to run on. Default: `cpu`. Options: `cpu`, `cuda`, `mps`
+    - `normalize_embeddings` (bool): Whether to normalize embeddings. Default: `False`
+
+    **Environment Variables:**
+    - `EMBEDDINGS_SENTENCE_TRANSFORMER_MODEL_NAME`: `model_name`
+    - `EMBEDDINGS_SENTENCE_TRANSFORMER_DEVICE`: `device`
+    - `EMBEDDINGS_SENTENCE_TRANSFORMER_NORMALIZE_EMBEDDINGS`: `normalize_embeddings`
+  </Accordion>
+
+  <Accordion title="ONNX">
+    ```python main.py
+    from crewai.rag.embeddings.providers.onnx.types import ONNXProviderSpec
+
+    embedding_model: ONNXProviderSpec = {
+        "provider": "onnx",
+        "config": {
+            "preferred_providers": ["CUDAExecutionProvider", "CPUExecutionProvider"]
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `preferred_providers` (list[str]): List of ONNX execution providers in order of preference
+
+    **Environment Variables:**
+    - `EMBEDDINGS_ONNX_PREFERRED_PROVIDERS`: `preferred_providers` (comma-separated list)
+  </Accordion>
+
+  <Accordion title="OpenCLIP">
+    ```python main.py
+    from crewai.rag.embeddings.providers.openclip.types import OpenCLIPProviderSpec
+
+    embedding_model: OpenCLIPProviderSpec = {
+        "provider": "openclip",
+        "config": {
+            "model_name": "ViT-B-32",
+            "checkpoint": "laion2b_s34b_b79k",
+            "device": "cuda"
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `model_name` (str): OpenCLIP model architecture. Default: `ViT-B-32`. Options: `ViT-B-32`, `ViT-B-16`, `ViT-L-14`
+    - `checkpoint` (str): Pretrained checkpoint name. Default: `laion2b_s34b_b79k`. Options: `laion2b_s34b_b79k`, `laion400m_e32`, `openai`
+    - `device` (str): Device to run on. Default: `cpu`. Options: `cpu`, `cuda`
+
+    **Environment Variables:**
+    - `EMBEDDINGS_OPENCLIP_MODEL_NAME`: `model_name`
+    - `EMBEDDINGS_OPENCLIP_CHECKPOINT`: `checkpoint`
+    - `EMBEDDINGS_OPENCLIP_DEVICE`: `device`
+  </Accordion>
+
+  <Accordion title="Text2Vec">
+    ```python main.py
+    from crewai.rag.embeddings.providers.text2vec.types import Text2VecProviderSpec
+
+    embedding_model: Text2VecProviderSpec = {
+        "provider": "text2vec",
+        "config": {
+            "model_name": "shibing624/text2vec-base-multilingual"
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `model_name` (str): Text2Vec model name from HuggingFace. Default: `shibing624/text2vec-base-chinese`. Options: `shibing624/text2vec-base-multilingual`, `shibing624/text2vec-base-chinese`
+
+    **Environment Variables:**
+    - `EMBEDDINGS_TEXT2VEC_MODEL_NAME`: `model_name`
+  </Accordion>
+
+  <Accordion title="Roboflow">
+    ```python main.py
+    from crewai.rag.embeddings.providers.roboflow.types import RoboflowProviderSpec
+
+    embedding_model: RoboflowProviderSpec = {
+        "provider": "roboflow",
+        "config": {
+            "api_key": "your-api-key",
+            "api_url": "https://infer.roboflow.com"
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `api_key` (str): Roboflow API key. Default: `""` (empty string)
+    - `api_url` (str): Roboflow inference API URL. Default: `https://infer.roboflow.com`
+
+    **Environment Variables:**
+    - `ROBOFLOW_API_KEY` or `EMBEDDINGS_ROBOFLOW_API_KEY`: `api_key`
+    - `ROBOFLOW_API_URL` or `EMBEDDINGS_ROBOFLOW_API_URL`: `api_url`
+  </Accordion>
+
+  <Accordion title="WatsonX (IBM)">
+    ```python main.py
+    from crewai.rag.embeddings.providers.ibm.types import WatsonXProviderSpec
+
+    embedding_model: WatsonXProviderSpec = {
+        "provider": "watsonx",
+        "config": {
+            "model_id": "ibm/slate-125m-english-rtrvr",
+            "url": "https://us-south.ml.cloud.ibm.com",
+            "api_key": "your-api-key",
+            "project_id": "your-project-id",
+            "batch_size": 100,
+            "concurrency_limit": 10,
+            "persistent_connection": True
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `model_id` (str): WatsonX model identifier
+    - `url` (str): WatsonX API endpoint
+    - `api_key` (str): IBM Cloud API key
+    - `project_id` (str): WatsonX project ID
+    - `space_id` (str): WatsonX space ID (alternative to project_id)
+    - `batch_size` (int): Batch size for embeddings. Default: `100`
+    - `concurrency_limit` (int): Maximum concurrent requests. Default: `10`
+    - `persistent_connection` (bool): Use persistent connections. Default: `True`
+    - Plus 20+ additional authentication and configuration options
+
+    **Environment Variables:**
+    - `WATSONX_API_KEY` or `EMBEDDINGS_WATSONX_API_KEY`: `api_key`
+    - `WATSONX_URL` or `EMBEDDINGS_WATSONX_URL`: `url`
+    - `WATSONX_PROJECT_ID` or `EMBEDDINGS_WATSONX_PROJECT_ID`: `project_id`
+    - `EMBEDDINGS_WATSONX_MODEL_ID`: `model_id`
+    - `EMBEDDINGS_WATSONX_SPACE_ID`: `space_id`
+    - `EMBEDDINGS_WATSONX_BATCH_SIZE`: `batch_size`
+    - `EMBEDDINGS_WATSONX_CONCURRENCY_LIMIT`: `concurrency_limit`
+    - `EMBEDDINGS_WATSONX_PERSISTENT_CONNECTION`: `persistent_connection`
+  </Accordion>
+
+  <Accordion title="Custom">
+    ```python main.py
+    from crewai.rag.core.base_embeddings_callable import EmbeddingFunction
+    from crewai.rag.embeddings.providers.custom.types import CustomProviderSpec
+
+    class MyEmbeddingFunction(EmbeddingFunction):
+        def __call__(self, input):
+            # Your custom embedding logic
+            return embeddings
+
+    embedding_model: CustomProviderSpec = {
+        "provider": "custom",
+        "config": {
+            "embedding_callable": MyEmbeddingFunction
+        }
+    }
+    ```
+
+    **Config Options:**
+    - `embedding_callable` (type[EmbeddingFunction]): Custom embedding function class
+
+    **Note:** Custom embedding functions must implement the `EmbeddingFunction` protocol defined in `crewai.rag.core.base_embeddings_callable`. The `__call__` method should accept input data and return embeddings as a list of numpy arrays (or compatible format that will be normalized). The returned embeddings are automatically normalized and validated.
+  </Accordion>
+</AccordionGroup>
+
+### Notes
+- All config fields are optional unless marked as **Required**
+- API keys can typically be provided via environment variables instead of config
+- Default values are shown where applicable
+
 
 ## Conclusion
 The `RagTool` provides a powerful way to create and query knowledge bases from various data sources. By leveraging Retrieval-Augmented Generation, it enables agents to access and retrieve relevant information efficiently, enhancing their ability to provide accurate and contextually appropriate responses.

docs/en/tools/database-data/mysqltool.mdx

@@ -58,10 +58,10 @@ tool = MySQLSearchTool(
             ),
         ),
         embedder=dict(
-            provider="google",
+            provider="google-generativeai",
             config=dict(
-                model="models/embedding-001",
-                task_type="retrieval_document",
+                model_name="gemini-embedding-001",
+                task_type="RETRIEVAL_DOCUMENT",
                 # title="Embeddings",
             ),
         ),

docs/en/tools/database-data/pgsearchtool.mdx

@@ -71,10 +71,10 @@ tool = PGSearchTool(
             ),
         ),
         embedder=dict(
-            provider="google", # or openai, ollama, ...
+            provider="google-generativeai", # or openai, ollama, ...
             config=dict(
-                model="models/embedding-001",
-                task_type="retrieval_document",
+                model_name="gemini-embedding-001",
+                task_type="RETRIEVAL_DOCUMENT",
                 # title="Embeddings",
             ),
         ),

docs/en/tools/file-document/jsonsearchtool.mdx

@@ -64,10 +64,10 @@ tool = JSONSearchTool(
             },
         },
         "embedding_model": {
-            "provider": "google", # or openai, ollama, ...
+            "provider": "google-generativeai", # or openai, ollama, ...
             "config": {
-                "model": "models/embedding-001",
-                "task_type": "retrieval_document",
+                "model_name": "gemini-embedding-001",
+                "task_type": "RETRIEVAL_DOCUMENT",
                 # Further customization options can be added here.
             },
         },

docs/en/tools/file-document/pdfsearchtool.mdx

@@ -63,15 +63,15 @@ tool = PDFSearchTool(
             "config": {
                 # Model identifier for the chosen provider. "model" will be auto-mapped to "model_name" internally.
                 "model": "text-embedding-3-small",
-                # Optional: API key. If omitted, the tool will use provider-specific env vars when available
-                # (e.g., OPENAI_API_KEY for provider="openai").
+                # Optional: API key. If omitted, the tool will use provider-specific env vars
+                # (e.g., OPENAI_API_KEY or EMBEDDINGS_OPENAI_API_KEY for OpenAI).
                 # "api_key": "sk-...",
 
                 # Provider-specific examples:
                 # --- Google Generative AI ---
                 # (Set provider="google-generativeai" above)
-                # "model": "models/embedding-001",
-                # "task_type": "retrieval_document",
+                # "model_name": "gemini-embedding-001",
+                # "task_type": "RETRIEVAL_DOCUMENT",
                 # "title": "Embeddings",
 
                 # --- Cohere ---

docs/en/tools/file-document/txtsearchtool.mdx

@@ -66,9 +66,9 @@ tool = TXTSearchTool(
             "provider": "openai",  # or google-generativeai, cohere, ollama, ...
             "config": {
                 "model": "text-embedding-3-small",
-                # "api_key": "sk-...",  # optional if env var is set
+                # "api_key": "sk-...",  # optional if env var is set (e.g., OPENAI_API_KEY or EMBEDDINGS_OPENAI_API_KEY)
                 # Provider examples:
-                # Google → model: "models/embedding-001", task_type: "retrieval_document"
+                # Google → model_name: "gemini-embedding-001", task_type: "RETRIEVAL_DOCUMENT"
                 # Cohere → model: "embed-english-v3.0"
                 # Ollama → model: "nomic-embed-text"
             },

docs/en/tools/integration/mergeagenthandlertool.mdx

@@ -0,0 +1,367 @@
+---
+title: Merge Agent Handler Tool
+description: Enables CrewAI agents to securely access third-party integrations like Linear, GitHub, Slack, and more through Merge's Agent Handler platform
+icon: diagram-project
+mode: "wide"
+---
+
+# `MergeAgentHandlerTool`
+
+The `MergeAgentHandlerTool` enables CrewAI agents to securely access third-party integrations through [Merge's Agent Handler](https://www.merge.dev/products/merge-agent-handler) platform. Agent Handler provides pre-built, secure connectors to popular tools like Linear, GitHub, Slack, Notion, and hundreds more—all with built-in authentication, permissions, and monitoring.
+
+## Installation
+
+```bash
+uv pip install 'crewai[tools]'
+```
+
+## Requirements
+
+- Merge Agent Handler account with a configured Tool Pack
+- Agent Handler API key
+- At least one registered user linked to your Tool Pack
+- Third-party integrations configured in your Tool Pack
+
+## Getting Started with Agent Handler
+
+1. **Sign up** for a Merge Agent Handler account at [ah.merge.dev/signup](https://ah.merge.dev/signup)
+2. **Create a Tool Pack** and configure the integrations you need
+3. **Register users** who will authenticate with the third-party services
+4. **Get your API key** from the Agent Handler dashboard
+5. **Set environment variable**: `export AGENT_HANDLER_API_KEY='your-key-here'`
+6. **Start building** with the MergeAgentHandlerTool in CrewAI
+
+## Notes
+
+- Tool Pack IDs and Registered User IDs can be found in your Agent Handler dashboard or created via API
+- The tool uses the Model Context Protocol (MCP) for communication with Agent Handler
+- Session IDs are automatically generated but can be customized for context persistence
+- All tool calls are logged and auditable through the Agent Handler platform
+- Tool parameters are dynamically discovered from the Agent Handler API and validated automatically
+
+## Usage
+
+### Single Tool Usage
+
+Here's how to use a specific tool from your Tool Pack:
+
+```python {2, 4-9}
+from crewai import Agent, Task, Crew
+from crewai_tools import MergeAgentHandlerTool
+
+# Create a tool for Linear issue creation
+linear_create_tool = MergeAgentHandlerTool.from_tool_name(
+    tool_name="linear__create_issue",
+    tool_pack_id="134e0111-0f67-44f6-98f0-597000290bb3",
+    registered_user_id="91b2b905-e866-40c8-8be2-efe53827a0aa"
+)
+
+# Create a CrewAI agent that uses the tool
+project_manager = Agent(
+    role='Project Manager',
+    goal='Manage project tasks and issues efficiently',
+    backstory='I am an expert at tracking project work and creating actionable tasks.',
+    tools=[linear_create_tool],
+    verbose=True
+)
+
+# Create a task for the agent
+create_issue_task = Task(
+    description="Create a new high-priority issue in Linear titled 'Implement user authentication' with a detailed description of the requirements.",
+    agent=project_manager,
+    expected_output="Confirmation that the issue was created with its ID"
+)
+
+# Create a crew with the agent
+crew = Crew(
+    agents=[project_manager],
+    tasks=[create_issue_task],
+    verbose=True
+)
+
+# Run the crew
+result = crew.kickoff()
+print(result)
+```
+
+### Loading Multiple Tools from a Tool Pack
+
+You can load all available tools from your Tool Pack at once:
+
+```python {2, 4-8}
+from crewai import Agent, Task, Crew
+from crewai_tools import MergeAgentHandlerTool
+
+# Load all tools from the Tool Pack
+tools = MergeAgentHandlerTool.from_tool_pack(
+    tool_pack_id="134e0111-0f67-44f6-98f0-597000290bb3",
+    registered_user_id="91b2b905-e866-40c8-8be2-efe53827a0aa"
+)
+
+# Create an agent with access to all tools
+automation_expert = Agent(
+    role='Automation Expert',
+    goal='Automate workflows across multiple platforms',
+    backstory='I can work with any tool in the toolbox to get things done.',
+    tools=tools,
+    verbose=True
+)
+
+automation_task = Task(
+    description="Check for any high-priority issues in Linear and post a summary to Slack.",
+    agent=automation_expert
+)
+
+crew = Crew(
+    agents=[automation_expert],
+    tasks=[automation_task],
+    verbose=True
+)
+
+result = crew.kickoff()
+```
+
+### Loading Specific Tools Only
+
+Load only the tools you need:
+
+```python {2, 4-10}
+from crewai import Agent, Task, Crew
+from crewai_tools import MergeAgentHandlerTool
+
+# Load specific tools from the Tool Pack
+selected_tools = MergeAgentHandlerTool.from_tool_pack(
+    tool_pack_id="134e0111-0f67-44f6-98f0-597000290bb3",
+    registered_user_id="91b2b905-e866-40c8-8be2-efe53827a0aa",
+    tool_names=["linear__create_issue", "linear__get_issues", "slack__post_message"]
+)
+
+developer_assistant = Agent(
+    role='Developer Assistant',
+    goal='Help developers track and communicate about their work',
+    backstory='I help developers stay organized and keep the team informed.',
+    tools=selected_tools,
+    verbose=True
+)
+
+daily_update_task = Task(
+    description="Get all issues assigned to the current user in Linear and post a summary to the #dev-updates Slack channel.",
+    agent=developer_assistant
+)
+
+crew = Crew(
+    agents=[developer_assistant],
+    tasks=[daily_update_task],
+    verbose=True
+)
+
+result = crew.kickoff()
+```
+
+## Tool Arguments
+
+### `from_tool_name()` Method
+
+| Argument | Type | Required | Default | Description |
+|:---------|:-----|:---------|:--------|:------------|
+| **tool_name** | `str` | Yes | None | Name of the specific tool to use (e.g., "linear__create_issue") |
+| **tool_pack_id** | `str` | Yes | None | UUID of your Agent Handler Tool Pack |
+| **registered_user_id** | `str` | Yes | None | UUID or origin_id of the registered user |
+| **base_url** | `str` | No | "https://ah-api.merge.dev" | Base URL for Agent Handler API |
+| **session_id** | `str` | No | Auto-generated | MCP session ID for maintaining context |
+
+### `from_tool_pack()` Method
+
+| Argument | Type | Required | Default | Description |
+|:---------|:-----|:---------|:--------|:------------|
+| **tool_pack_id** | `str` | Yes | None | UUID of your Agent Handler Tool Pack |
+| **registered_user_id** | `str` | Yes | None | UUID or origin_id of the registered user |
+| **tool_names** | `list[str]` | No | None | Specific tool names to load. If None, loads all available tools |
+| **base_url** | `str` | No | "https://ah-api.merge.dev" | Base URL for Agent Handler API |
+
+## Environment Variables
+
+```bash
+AGENT_HANDLER_API_KEY=your_api_key_here  # Required for authentication
+```
+
+## Advanced Usage
+
+### Multi-Agent Workflow with Different Tool Access
+
+```python {2, 4-20}
+from crewai import Agent, Task, Crew, Process
+from crewai_tools import MergeAgentHandlerTool
+
+# Create specialized tools for different agents
+github_tools = MergeAgentHandlerTool.from_tool_pack(
+    tool_pack_id="134e0111-0f67-44f6-98f0-597000290bb3",
+    registered_user_id="91b2b905-e866-40c8-8be2-efe53827a0aa",
+    tool_names=["github__create_pull_request", "github__get_pull_requests"]
+)
+
+linear_tools = MergeAgentHandlerTool.from_tool_pack(
+    tool_pack_id="134e0111-0f67-44f6-98f0-597000290bb3",
+    registered_user_id="91b2b905-e866-40c8-8be2-efe53827a0aa",
+    tool_names=["linear__create_issue", "linear__update_issue"]
+)
+
+slack_tool = MergeAgentHandlerTool.from_tool_name(
+    tool_name="slack__post_message",
+    tool_pack_id="134e0111-0f67-44f6-98f0-597000290bb3",
+    registered_user_id="91b2b905-e866-40c8-8be2-efe53827a0aa"
+)
+
+# Create specialized agents
+code_reviewer = Agent(
+    role='Code Reviewer',
+    goal='Review pull requests and ensure code quality',
+    backstory='I am an expert at reviewing code changes and providing constructive feedback.',
+    tools=github_tools
+)
+
+task_manager = Agent(
+    role='Task Manager',
+    goal='Track and update project tasks based on code changes',
+    backstory='I keep the project board up to date with the latest development progress.',
+    tools=linear_tools
+)
+
+communicator = Agent(
+    role='Team Communicator',
+    goal='Keep the team informed about important updates',
+    backstory='I make sure everyone knows what is happening in the project.',
+    tools=[slack_tool]
+)
+
+# Create sequential tasks
+review_task = Task(
+    description="Review all open pull requests in the 'api-service' repository and identify any that need attention.",
+    agent=code_reviewer,
+    expected_output="List of pull requests that need review or have issues"
+)
+
+update_task = Task(
+    description="Update Linear issues based on the pull request review findings. Mark completed PRs as done.",
+    agent=task_manager,
+    expected_output="Summary of updated Linear issues"
+)
+
+notify_task = Task(
+    description="Post a summary of today's code review and task updates to the #engineering Slack channel.",
+    agent=communicator,
+    expected_output="Confirmation that the message was posted"
+)
+
+# Create a crew with sequential processing
+crew = Crew(
+    agents=[code_reviewer, task_manager, communicator],
+    tasks=[review_task, update_task, notify_task],
+    process=Process.sequential,
+    verbose=True
+)
+
+result = crew.kickoff()
+```
+
+### Custom Session Management
+
+Maintain context across multiple tool calls using session IDs:
+
+```python {2, 4-17}
+from crewai import Agent, Task, Crew
+from crewai_tools import MergeAgentHandlerTool
+
+# Create tools with the same session ID to maintain context
+session_id = "project-sprint-planning-2024"
+
+create_tool = MergeAgentHandlerTool(
+    name="linear_create_issue",
+    description="Creates a new issue in Linear",
+    tool_name="linear__create_issue",
+    tool_pack_id="134e0111-0f67-44f6-98f0-597000290bb3",
+    registered_user_id="91b2b905-e866-40c8-8be2-efe53827a0aa",
+    session_id=session_id
+)
+
+update_tool = MergeAgentHandlerTool(
+    name="linear_update_issue",
+    description="Updates an existing issue in Linear",
+    tool_name="linear__update_issue",
+    tool_pack_id="134e0111-0f67-44f6-98f0-597000290bb3",
+    registered_user_id="91b2b905-e866-40c8-8be2-efe53827a0aa",
+    session_id=session_id
+)
+
+sprint_planner = Agent(
+    role='Sprint Planner',
+    goal='Plan and organize sprint tasks',
+    backstory='I help teams plan effective sprints with well-defined tasks.',
+    tools=[create_tool, update_tool],
+    verbose=True
+)
+
+planning_task = Task(
+    description="Create 5 sprint tasks for the authentication feature and set their priorities based on dependencies.",
+    agent=sprint_planner
+)
+
+crew = Crew(
+    agents=[sprint_planner],
+    tasks=[planning_task],
+    verbose=True
+)
+
+result = crew.kickoff()
+```
+
+## Use Cases
+
+### Unified Integration Access
+- Access hundreds of third-party tools through a single unified API without managing multiple SDKs
+- Enable agents to work with Linear, GitHub, Slack, Notion, Jira, Asana, and more from one integration point
+- Reduce integration complexity by letting Agent Handler manage authentication and API versioning
+
+### Secure Enterprise Workflows
+- Leverage built-in authentication and permission management for all third-party integrations
+- Maintain enterprise security standards with centralized access control and audit logging
+- Enable agents to access company tools without exposing API keys or credentials in code
+
+### Cross-Platform Automation
+- Build workflows that span multiple platforms (e.g., create GitHub issues from Linear tasks, sync Notion pages to Slack)
+- Enable seamless data flow between different tools in your tech stack
+- Create intelligent automation that understands context across different platforms
+
+### Dynamic Tool Discovery
+- Load all available tools at runtime without hardcoding integration logic
+- Enable agents to discover and use new tools as they're added to your Tool Pack
+- Build flexible agents that can adapt to changing tool availability
+
+### User-Specific Tool Access
+- Different users can have different tool permissions and access levels
+- Enable multi-tenant workflows where agents act on behalf of specific users
+- Maintain proper attribution and permissions for all tool actions
+
+## Available Integrations
+
+Merge Agent Handler supports hundreds of integrations across multiple categories:
+
+- **Project Management**: Linear, Jira, Asana, Monday.com, ClickUp
+- **Code Management**: GitHub, GitLab, Bitbucket
+- **Communication**: Slack, Microsoft Teams, Discord
+- **Documentation**: Notion, Confluence, Google Docs
+- **CRM**: Salesforce, HubSpot, Pipedrive
+- **And many more...**
+
+Visit the [Merge Agent Handler documentation](https://docs.ah.merge.dev/) for a complete list of available integrations.
+
+## Error Handling
+
+The tool provides comprehensive error handling:
+
+- **Authentication Errors**: Invalid or missing API keys
+- **Permission Errors**: User lacks permission for the requested action
+- **API Errors**: Issues communicating with Agent Handler or third-party services
+- **Validation Errors**: Invalid parameters passed to tool methods
+
+All errors are wrapped in `MergeAgentHandlerToolError` for consistent error handling.

docs/en/tools/integration/overview.mdx

@@ -10,6 +10,10 @@ Integration tools let your agents hand off work to other automation platforms an
 ## **Available Tools**
 
 <CardGroup cols={2}>
+  <Card title="Merge Agent Handler Tool" icon="diagram-project" href="/en/tools/integration/mergeagenthandlertool">
+    Securely access hundreds of third-party tools like Linear, GitHub, Slack, and more through Merge's unified API.
+  </Card>
+
   <Card title="CrewAI Run Automation Tool" icon="robot" href="/en/tools/integration/crewaiautomationtool">
     Invoke live CrewAI Platform automations, pass custom inputs, and poll for results directly from your agent.
   </Card>

docs/en/tools/search-research/codedocssearchtool.mdx

@@ -73,10 +73,10 @@ tool = CodeDocsSearchTool(
             ),
         ),
         embedder=dict(
-            provider="google", # or openai, ollama, ...
+            provider="google-generativeai", # or openai, ollama, ...
             config=dict(
-                model="models/embedding-001",
-                task_type="retrieval_document",
+                model_name="gemini-embedding-001",
+                task_type="RETRIEVAL_DOCUMENT",
                 # title="Embeddings",
             ),
         ),

docs/en/tools/search-research/githubsearchtool.mdx

@@ -75,10 +75,10 @@ tool = GithubSearchTool(
             ),
         ),
         embedder=dict(
-            provider="google", # or openai, ollama, ...
+            provider="google-generativeai", # or openai, ollama, ...
             config=dict(
-                model="models/embedding-001",
-                task_type="retrieval_document",
+                model_name="gemini-embedding-001",
+                task_type="RETRIEVAL_DOCUMENT",
                 # title="Embeddings",
             ),
         ),

docs/en/tools/search-research/websitesearchtool.mdx

@@ -66,10 +66,10 @@ tool = WebsiteSearchTool(
             ),
         ),
         embedder=dict(
-            provider="google", # or openai, ollama, ...
+            provider="google-generativeai", # or openai, ollama, ...
             config=dict(
-                model="models/embedding-001",
-                task_type="retrieval_document",
+                model_name="gemini-embedding-001",
+                task_type="RETRIEVAL_DOCUMENT",
                 # title="Embeddings",
             ),
         ),

docs/en/tools/search-research/youtubechannelsearchtool.mdx

@@ -106,10 +106,10 @@ youtube_channel_tool = YoutubeChannelSearchTool(
             ),
         ),
         embedder=dict(
-            provider="google", # or openai, ollama, ...
+            provider="google-generativeai", # or openai, ollama, ...
             config=dict(
-                model="models/embedding-001",
-                task_type="retrieval_document",
+                model_name="gemini-embedding-001",
+                task_type="RETRIEVAL_DOCUMENT",
                 # title="Embeddings",
             ),
         ),

docs/en/tools/search-research/youtubevideosearchtool.mdx

@@ -108,10 +108,10 @@ youtube_search_tool = YoutubeVideoSearchTool(
             ),
         ),
         embedder=dict(
-            provider="google", # or openai, ollama, ...
+            provider="google-generativeai", # or openai, ollama, ...
             config=dict(
-                model="models/embedding-001",
-                task_type="retrieval_document",
+                model_name="gemini-embedding-001",
+                task_type="RETRIEVAL_DOCUMENT",
                 # title="Embeddings",
             ),
         ),

docs/enterprise-api.base.yaml

@@ -1,12 +1,12 @@
 openapi: 3.0.3
 info:
-  title: CrewAI AMP API
+  title: CrewAI AOP API
   description: |
-    REST API for interacting with your deployed CrewAI crews on CrewAI AMP.
+    REST API for interacting with your deployed CrewAI crews on CrewAI AOP.
 
     ## Getting Started
 
-    1. **Find your crew URL**: Get your unique crew URL from the CrewAI AMP dashboard
+    1. **Find your crew URL**: Get your unique crew URL from the CrewAI AOP dashboard
     2. **Copy examples**: Use the code examples from each endpoint page as templates
     3. **Replace placeholders**: Update URLs and tokens with your actual values
     4. **Test with your tools**: Use cURL, Postman, or your preferred API client
@@ -18,7 +18,7 @@ info:
     - **Bearer Token**: Organization-level token for full crew operations
     - **User Bearer Token**: User-scoped token for individual access with limited permissions
 
-    You can find your bearer tokens in the Status tab of your crew's detail page in the CrewAI AMP dashboard.
+    You can find your bearer tokens in the Status tab of your crew's detail page in the CrewAI AOP dashboard.
 
     ## Reference Documentation
 
@@ -43,7 +43,7 @@ info:
     url: https://crewai.com
 servers:
   - url: https://your-actual-crew-name.crewai.com
-    description: Replace with your actual deployed crew URL from the CrewAI AMP dashboard
+    description: Replace with your actual deployed crew URL from the CrewAI AOP dashboard
   - url: https://my-travel-crew.crewai.com
     description: Example travel planning crew (replace with your URL)
   - url: https://content-creation-crew.crewai.com
@@ -412,7 +412,7 @@ components:
       description: |
         **📋 Reference Documentation** - *The tokens shown in examples are placeholders for reference only.*
 
-        Use your actual Bearer Token or User Bearer Token from the CrewAI AMP dashboard for real API calls.
+        Use your actual Bearer Token or User Bearer Token from the CrewAI AOP dashboard for real API calls.
 
         **Bearer Token**: Organization-level access for full crew operations
         **User Bearer Token**: User-scoped access with limited permissions

docs/enterprise-api.en.yaml

@@ -1,12 +1,12 @@
 openapi: 3.0.3
 info:
-  title: CrewAI AMP API
+  title: CrewAI AOP API
   description: |
-    REST API for interacting with your deployed CrewAI crews on CrewAI AMP.
+    REST API for interacting with your deployed CrewAI crews on CrewAI AOP.
 
     ## Getting Started
 
-    1. **Find your crew URL**: Get your unique crew URL from the CrewAI AMP dashboard
+    1. **Find your crew URL**: Get your unique crew URL from the CrewAI AOP dashboard
     2. **Copy examples**: Use the code examples from each endpoint page as templates
     3. **Replace placeholders**: Update URLs and tokens with your actual values
     4. **Test with your tools**: Use cURL, Postman, or your preferred API client
@@ -18,7 +18,7 @@ info:
     - **Bearer Token**: Organization-level token for full crew operations
     - **User Bearer Token**: User-scoped token for individual access with limited permissions
 
-    You can find your bearer tokens in the Status tab of your crew's detail page in the CrewAI AMP dashboard.
+    You can find your bearer tokens in the Status tab of your crew's detail page in the CrewAI AOP dashboard.
 
     ## Reference Documentation
 
@@ -43,7 +43,7 @@ info:
     url: https://crewai.com
 servers:
   - url: https://your-actual-crew-name.crewai.com
-    description: Replace with your actual deployed crew URL from the CrewAI AMP dashboard
+    description: Replace with your actual deployed crew URL from the CrewAI AOP dashboard
   - url: https://my-travel-crew.crewai.com
     description: Example travel planning crew (replace with your URL)
   - url: https://content-creation-crew.crewai.com
@@ -412,7 +412,7 @@ components:
       description: |
         **📋 Reference Documentation** - *The tokens shown in examples are placeholders for reference only.*
 
-        Use your actual Bearer Token or User Bearer Token from the CrewAI AMP dashboard for real API calls.
+        Use your actual Bearer Token or User Bearer Token from the CrewAI AOP dashboard for real API calls.
 
         **Bearer Token**: Organization-level access for full crew operations
         **User Bearer Token**: User-scoped access with limited permissions

docs/enterprise-api.ko.yaml

@@ -2,7 +2,7 @@ openapi: 3.0.3
 info:
   title: CrewAI 엔터프라이즈 API
   description: |
-    CrewAI AMP에 배포된 crew와 상호작용하기 위한 REST API입니다.
+    CrewAI AOP에 배포된 crew와 상호작용하기 위한 REST API입니다.
 
     ## 시작하기
     1. **Crew URL 확인**: 대시보드에서 고유한 crew URL을 확인하세요

docs/enterprise-api.pt-BR.yaml

@@ -1,12 +1,12 @@
 openapi: 3.0.3
 info:
-  title: CrewAI AMP API
+  title: CrewAI AOP API
   description: |
-    REST API para interagir com suas crews implantadas no CrewAI AMP.
+    REST API para interagir com suas crews implantadas no CrewAI AOP.
 
     ## Introdução
 
-    1. **Encontre a URL da sua crew**: Obtenha sua URL única no painel do CrewAI AMP
+    1. **Encontre a URL da sua crew**: Obtenha sua URL única no painel do CrewAI AOP
     2. **Copie os exemplos**: Use os exemplos de cada endpoint como modelo
     3. **Substitua os placeholders**: Atualize URLs e tokens com seus valores reais
     4. **Teste com suas ferramentas**: Use cURL, Postman ou seu cliente preferido
@@ -18,7 +18,7 @@ info:
     - **Bearer Token**: Token em nível de organização para operações completas
     - **User Bearer Token**: Token com escopo de usuário com permissões limitadas
 
-    Você encontra os tokens na aba Status da sua crew no painel do CrewAI AMP.
+    Você encontra os tokens na aba Status da sua crew no painel do CrewAI AOP.
 
     ## Documentação de Referência
 
@@ -43,7 +43,7 @@ info:
     url: https://crewai.com
 servers:
   - url: https://your-actual-crew-name.crewai.com
-    description: Substitua pela URL real da sua crew no painel do CrewAI AMP
+    description: Substitua pela URL real da sua crew no painel do CrewAI AOP
 security:
   - BearerAuth: []
 paths:
@@ -291,7 +291,7 @@ components:
       scheme: bearer
       description: |
         **📋 Referência** - *Os tokens mostrados são apenas exemplos.*
-        Use seus tokens reais do painel do CrewAI AMP.
+        Use seus tokens reais do painel do CrewAI AOP.
 
   schemas:
     ExecutionRunning:

docs/ko/api-reference/introduction.mdx

@@ -1,6 +1,6 @@
 ---
 title: "소개"
-description: "CrewAI AMP REST API에 대한 완벽한 참고 자료"
+description: "CrewAI AOP REST API에 대한 완벽한 참고 자료"
 icon: "code"
 mode: "wide"
 ---
@@ -13,7 +13,7 @@ CrewAI 엔터프라이즈 API 참고 자료에 오신 것을 환영합니다.
 
 <Steps>
   <Step title="API 자격 증명 받기">
-    CrewAI AMP 대시보드에서 자신의 crew 상세 페이지로 이동하여 Status 탭에서 Bearer Token을 복사하세요.
+    CrewAI AOP 대시보드에서 자신의 crew 상세 페이지로 이동하여 Status 탭에서 Bearer Token을 복사하세요.
   </Step>
 
   <Step title="필수 입력값 확인하기">
@@ -46,7 +46,7 @@ curl -H "Authorization: Bearer YOUR_CREW_TOKEN" \
 | **User Bearer Token** | 사용자 범위 접근 | 제한된 권한, 사용자별 작업에 적합 |
 
 <Tip>
-두 토큰 유형 모두 CrewAI AMP 대시보드의 crew 상세 페이지 Status 탭에서 확인할 수 있습니다.
+두 토큰 유형 모두 CrewAI AOP 대시보드의 crew 상세 페이지 Status 탭에서 확인할 수 있습니다.
 </Tip>
 
 ## 기본 URL
@@ -82,7 +82,7 @@ API는 표준 HTTP 상태 코드를 사용합니다:
 ## 인터랙티브 테스트
 
 <Info>
-**왜 "전송" 버튼이 없나요?** 각 CrewAI AMP 사용자는 고유한 crew URL을 가지므로, 혼동을 피하기 위해 인터랙티브 플레이그라운드 대신 **참조 모드**를 사용합니다. 이를 통해 비작동 전송 버튼 없이 요청이 어떻게 생겼는지 정확히 보여줍니다.
+**왜 "전송" 버튼이 없나요?** 각 CrewAI AOP 사용자는 고유한 crew URL을 가지므로, 혼동을 피하기 위해 인터랙티브 플레이그라운드 대신 **참조 모드**를 사용합니다. 이를 통해 비작동 전송 버튼 없이 요청이 어떻게 생겼는지 정확히 보여줍니다.
 </Info>
 
 각 엔드포인트 페이지에서는 다음을 확인할 수 있습니다:

docs/ko/concepts/agents.mdx

@@ -20,7 +20,7 @@ CrewAI 프레임워크에서 `Agent`는 다음과 같은 역할을 수행하는
 </Tip>
 
 <Note type="info" title="엔터프라이즈 확장: 시각적 에이전트 빌더">
-CrewAI AMP에는 코드를 작성하지 않고도 에이전트 생성 및 구성을 간편하게 할 수 있는 시각적 에이전트 빌더가 포함되어 있습니다. 에이전트를 시각적으로 설계하고 실시간으로 테스트하세요.
+CrewAI AOP에는 코드를 작성하지 않고도 에이전트 생성 및 구성을 간편하게 할 수 있는 시각적 에이전트 빌더가 포함되어 있습니다. 에이전트를 시각적으로 설계하고 실시간으로 테스트하세요.
 
 ![Visual Agent Builder Screenshot](/images/enterprise/crew-studio-interface.png)
 

docs/ko/concepts/cli.mdx

@@ -5,7 +5,7 @@ icon: terminal
 mode: "wide"
 ---
 
-<Warning>릴리즈 0.140.0부터 CrewAI AMP는 로그인 제공자 마이그레이션 프로세스를 시작했습니다. 이에 따라 CLI를 통한 인증 흐름이 업데이트되었습니다. Google을 통해 로그인하거나 2025년 7월 3일 이후에 계정을 생성한 사용자는 이전 버전의 `crewai` 라이브러리로는 로그인할 수 없습니다.</Warning>
+<Warning>릴리즈 0.140.0부터 CrewAI AOP는 로그인 제공자 마이그레이션 프로세스를 시작했습니다. 이에 따라 CLI를 통한 인증 흐름이 업데이트되었습니다. Google을 통해 로그인하거나 2025년 7월 3일 이후에 계정을 생성한 사용자는 이전 버전의 `crewai` 라이브러리로는 로그인할 수 없습니다.</Warning>
 
 ## 개요
 
@@ -186,9 +186,9 @@ def crew(self) -> Crew:
 
 ### 10. 배포
 
-crew 또는 flow를 [CrewAI AMP](https://app.crewai.com)에 배포하세요.
+crew 또는 flow를 [CrewAI AOP](https://app.crewai.com)에 배포하세요.
 
-- **인증**: CrewAI AMP에 배포하려면 인증이 필요합니다.
+- **인증**: CrewAI AOP에 배포하려면 인증이 필요합니다.
     아래 명령어로 로그인하거나 계정을 생성할 수 있습니다:
     ```shell Terminal
     crewai login
@@ -203,7 +203,7 @@ crew 또는 flow를 [CrewAI AMP](https://app.crewai.com)에 배포하세요.
 
 ### 11. 조직 관리
 
-CrewAI AMP 조직을 관리합니다.
+CrewAI AOP 조직을 관리합니다.
 
 ```shell Terminal
 crewai org [COMMAND] [OPTIONS]
@@ -227,17 +227,17 @@ crewai org switch <organization_id>
 ```
 
 <Note>
-이러한 조직 관리 명령어를 사용하려면 CrewAI AMP에 인증되어 있어야 합니다.
+이러한 조직 관리 명령어를 사용하려면 CrewAI AOP에 인증되어 있어야 합니다.
 </Note>
 
 - **배포 생성** (계속):
     - 배포를 해당 원격 GitHub 저장소에 연결합니다 (일반적으로 자동으로 감지됩니다).
 
-- **Crew 배포**: 인증이 완료되면 crew 또는 flow를 CrewAI AMP에 배포할 수 있습니다.
+- **Crew 배포**: 인증이 완료되면 crew 또는 flow를 CrewAI AOP에 배포할 수 있습니다.
     ```shell Terminal
     crewai deploy push
     ```
-    - CrewAI AMP 플랫폼에서 배포 프로세스를 시작합니다.
+    - CrewAI AOP 플랫폼에서 배포 프로세스를 시작합니다.
     - 성공적으로 시작되면, Deployment created successfully! 메시지와 함께 Deployment Name 및 고유한 Deployment ID(UUID)가 출력됩니다.
 
 - **배포 상태**: 배포 상태를 확인하려면 다음을 사용합니다:
@@ -262,7 +262,7 @@ crewai org switch <organization_id>
     ```shell Terminal
     crewai deploy remove
     ```
-    이 명령은 CrewAI AMP 플랫폼에서 배포를 삭제합니다.
+    이 명령은 CrewAI AOP 플랫폼에서 배포를 삭제합니다.
 
 - **도움말 명령어**: CLI에 대한 도움말을 보려면 다음을 사용합니다:
     ```shell Terminal
@@ -270,7 +270,7 @@ crewai org switch <organization_id>
     ```
     이 명령은 CrewAI Deploy CLI에 대한 도움말 메시지를 표시합니다.
 
-CLI를 사용하여 [CrewAI AMP](http://app.crewai.com)에 crew를 배포하는 단계별 시연은 아래 비디오 튜토리얼을 참조하십시오.
+CLI를 사용하여 [CrewAI AOP](http://app.crewai.com)에 crew를 배포하는 단계별 시연은 아래 비디오 튜토리얼을 참조하십시오.
 
 <iframe
   className="w-full aspect-video rounded-xl"
@@ -336,7 +336,7 @@ crewai config reset
 
 #### 사용 가능한 구성 파라미터
 
-- `enterprise_base_url`: CrewAI AMP 인스턴스의 기본 URL
+- `enterprise_base_url`: CrewAI AOP 인스턴스의 기본 URL
 - `oauth2_provider`: 인증에 사용되는 OAuth2 공급자 (예: workos, okta, auth0)
 - `oauth2_audience`: OAuth2 audience 값으로, 일반적으로 대상 API 또는 리소스를 식별하는 데 사용됨
 - `oauth2_client_id`: 인증 요청 시 사용되는 공급자가 발급한 OAuth2 클라이언트 ID
@@ -353,7 +353,7 @@ crewai config list
 
 | 설정                 | 값                      | 설명                                                                 |
 | :------------------- | :---------------------- | :------------------------------------------------------------------- |
-| enterprise_base_url  | https://app.crewai.com | CrewAI AMP 인스턴스의 기본 URL                                |
+| enterprise_base_url  | https://app.crewai.com | CrewAI AOP 인스턴스의 기본 URL                                |
 | org_name             | Not set                 | 현재 활성화된 조직의 이름                                            |
 | org_uuid             | Not set                 | 현재 활성화된 조직의 UUID                                            |
 | oauth2_provider      | workos                  | 인증에 사용되는 OAuth2 제공자 (예: workos, okta, auth0)              |

docs/ko/concepts/crews.mdx

@@ -33,6 +33,7 @@ crewAI에서 crew는 일련의 작업을 달성하기 위해 함께 협력하는
 | **Planning** *(선택사항)*              | `planning`             | Crew에 계획 수립 기능을 추가. 활성화하면 각 Crew 반복 전에 모든 Crew 데이터를 AgentPlanner로 전송하여 작업계획을 세우고, 이 계획이 각 작업 설명에 추가됨.                                                     |
 | **Planning LLM** *(선택사항)*          | `planning_llm`         | 계획 과정에서 AgentPlanner가 사용하는 언어 모델.                                                                                                                                                                 |
 | **Knowledge Sources** _(선택사항)_     | `knowledge_sources`    | crew 수준에서 사용 가능한 지식 소스. 모든 agent가 접근 가능.                                                                                                                                                             |
+| **Stream** _(선택사항)_                | `stream`               | 스트리밍 출력을 활성화하여 crew 실행 중 실시간 업데이트를 받을 수 있습니다. 청크를 반복할 수 있는 `CrewStreamingOutput` 객체를 반환합니다. 기본값은 `False`.                                                                    |
 
 <Tip>
 **Crew Max RPM**: `max_rpm` 속성은 crew가 분당 처리할 수 있는 최대 요청 수를 설정하며, 개별 agent의 `max_rpm` 설정을 crew 단위로 지정할 경우 오버라이드합니다.
@@ -306,12 +307,27 @@ print(result)
 
 ### Crew를 시작하는 다양한 방법
 
-crew가 구성되면, 적절한 시작 방법으로 workflow를 시작하세요. CrewAI는 kickoff 프로세스를 더 잘 제어할 수 있도록 여러 방법을 제공합니다: `kickoff()`, `kickoff_for_each()`, `kickoff_async()`, 그리고 `kickoff_for_each_async()`.
+crew가 구성되면, 적절한 시작 방법으로 workflow를 시작하세요. CrewAI는 kickoff 프로세스를 더 잘 제어할 수 있도록 여러 방법을 제공합니다.
+
+#### 동기 메서드
 
 - `kickoff()`: 정의된 process flow에 따라 실행 프로세스를 시작합니다.
 - `kickoff_for_each()`: 입력 이벤트나 컬렉션 내 각 항목에 대해 순차적으로 task를 실행합니다.
-- `kickoff_async()`: 비동기적으로 workflow를 시작합니다.
-- `kickoff_for_each_async()`: 입력 이벤트나 각 항목에 대해 비동기 처리를 활용하여 task를 동시에 실행합니다.
+
+#### 비동기 메서드
+
+CrewAI는 비동기 실행을 위해 두 가지 접근 방식을 제공합니다:
+
+| 메서드 | 타입 | 설명 |
+|--------|------|-------------|
+| `akickoff()` | 네이티브 async | 전체 실행 체인에서 진정한 async/await 사용 |
+| `akickoff_for_each()` | 네이티브 async | 리스트의 각 입력에 대해 네이티브 async 실행 |
+| `kickoff_async()` | 스레드 기반 | 동기 실행을 `asyncio.to_thread`로 래핑 |
+| `kickoff_for_each_async()` | 스레드 기반 | 리스트의 각 입력에 대해 스레드 기반 async |
+
+<Note>
+고동시성 워크로드의 경우 `akickoff()` 및 `akickoff_for_each()`가 권장됩니다. 이들은 작업 실행, 메모리 작업, 지식 검색에 네이티브 async를 사용합니다.
+</Note>
 
 ```python Code
 # Start the crew's task execution
@@ -324,19 +340,53 @@ results = my_crew.kickoff_for_each(inputs=inputs_array)
 for result in results:
     print(result)
 
-# Example of using kickoff_async
+# Example of using native async with akickoff
+inputs = {'topic': 'AI in healthcare'}
+async_result = await my_crew.akickoff(inputs=inputs)
+print(async_result)
+
+# Example of using native async with akickoff_for_each
+inputs_array = [{'topic': 'AI in healthcare'}, {'topic': 'AI in finance'}]
+async_results = await my_crew.akickoff_for_each(inputs=inputs_array)
+for async_result in async_results:
+    print(async_result)
+
+# Example of using thread-based kickoff_async
 inputs = {'topic': 'AI in healthcare'}
 async_result = await my_crew.kickoff_async(inputs=inputs)
 print(async_result)
 
-# Example of using kickoff_for_each_async
+# Example of using thread-based kickoff_for_each_async
 inputs_array = [{'topic': 'AI in healthcare'}, {'topic': 'AI in finance'}]
 async_results = await my_crew.kickoff_for_each_async(inputs=inputs_array)
 for async_result in async_results:
     print(async_result)
 ```
 
-이러한 메서드는 crew 내에서 task를 관리하고 실행하는 데 유연성을 제공하며, 동기 및 비동기 workflow 모두 필요에 맞게 사용할 수 있도록 지원합니다.
+이러한 메서드는 crew 내에서 task를 관리하고 실행하는 데 유연성을 제공하며, 동기 및 비동기 workflow 모두 필요에 맞게 사용할 수 있도록 지원합니다. 자세한 비동기 예제는 [Crew 비동기 시작](/ko/learn/kickoff-async) 가이드를 참조하세요.
+
+### 스트리밍 Crew 실행
+
+crew 실행을 실시간으로 확인하려면 스트리밍을 활성화하여 출력이 생성되는 대로 받을 수 있습니다:
+
+```python Code
+# 스트리밍 활성화
+crew = Crew(
+    agents=[researcher],
+    tasks=[task],
+    stream=True
+)
+
+# 스트리밍 출력을 반복
+streaming = crew.kickoff(inputs={"topic": "AI"})
+for chunk in streaming:
+    print(chunk.content, end="", flush=True)
+
+# 최종 결과 접근
+result = streaming.result
+```
+
+스트리밍에 대한 자세한 내용은 [스트리밍 Crew 실행](/ko/learn/streaming-crew-execution) 가이드를 참조하세요.
 
 ### 특정 Task에서 다시 실행하기