Fix lint issues: suppress unused chromadb import warnings and update remaining external memory test

Co-Authored-By: João <joao@crewai.com>

.github/workflows/linter.yml

@@ -30,7 +30,4 @@ jobs:
       - name: Run Ruff on Changed Files
         if: ${{ steps.changed-files.outputs.files != '' }}
         run: |
-          echo "${{ steps.changed-files.outputs.files }}" \
-            | tr ' ' '\n' \
-            | grep -v 'src/crewai/cli/templates/' \
-            | xargs -I{} ruff check "{}"
+          echo "${{ steps.changed-files.outputs.files }}" | tr " " "\n" | xargs -I{} ruff check "{}"

.github/workflows/tests.yml

@@ -14,7 +14,7 @@ jobs:
     timeout-minutes: 15
     strategy:
       matrix:
-        python-version: ['3.10', '3.11', '3.12', '3.13']
+        python-version: ['3.10', '3.11', '3.12']
     steps:
       - name: Checkout code
         uses: actions/checkout@v4

README.md

@@ -161,7 +161,7 @@ To get started with CrewAI, follow these simple steps:
 
 ### 1. Installation
 
-Ensure you have Python >=3.10 <3.14 installed on your system. CrewAI uses [UV](https://docs.astral.sh/uv/) for dependency management and package handling, offering a seamless setup and execution experience.
+Ensure you have Python >=3.10 <3.13 installed on your system. CrewAI uses [UV](https://docs.astral.sh/uv/) for dependency management and package handling, offering a seamless setup and execution experience.
 
 First, install CrewAI:
 
@@ -403,7 +403,7 @@ In addition to the sequential process, you can use the hierarchical process, whi
 
 ## Key Features
 
-CrewAI stands apart as a lean, standalone, high-performance multi-AI Agent framework delivering simplicity, flexibility, and precise control—free from the complexity and limitations found in other agent frameworks.
+CrewAI stands apart as a lean, standalone, high-performance framework delivering simplicity, flexibility, and precise control—free from the complexity and limitations found in other agent frameworks.
 
 - **Standalone & Lean**: Completely independent from other frameworks like LangChain, offering faster execution and lighter resource demands.
 - **Flexible & Precise**: Easily orchestrate autonomous agents through intuitive [Crews](https://docs.crewai.com/concepts/crews) or precise [Flows](https://docs.crewai.com/concepts/flows), achieving perfect balance for your needs.

docs/docs.json

@@ -85,12 +85,7 @@
           {
             "group": "MCP Integration",
             "pages": [
-              "mcp/overview",
-              "mcp/stdio",
-              "mcp/sse",
-              "mcp/streamable-http",
-              "mcp/multiple-servers",
-              "mcp/security"
+              "mcp/crewai-mcp-integration"
             ]
           },
           {

docs/installation.mdx

@@ -22,7 +22,7 @@ Watch this video tutorial for a step-by-step demonstration of the installation p
 <Note>
   **Python Version Requirements**
 
-  CrewAI requires `Python >=3.10 and <=3.13`. Here's how to check your version:
+  CrewAI requires `Python >=3.10 and <3.13`. Here's how to check your version:
   ```bash
   python3 --version
   ```

docs/mcp/crewai-mcp-integration.mdx

@@ -0,0 +1,243 @@
+---
+title: 'MCP Servers as Tools in CrewAI'
+description: 'Learn how to integrate MCP servers as tools in your CrewAI agents using the `crewai-tools` library.'
+icon: 'plug'
+---
+
+## Overview
+
+The [Model Context Protocol](https://modelcontextprotocol.io/introduction) (MCP) provides a standardized way for AI agents to provide context to LLMs by communicating with external services, known as MCP Servers. 
+The `crewai-tools` library extends CrewAI's capabilities by allowing you to seamlessly integrate tools from these MCP servers into your agents. 
+This gives your crews access to a vast ecosystem of functionalities. For now, we support **Standard Input/Output** (Stdio) and **Server-Sent Events** (SSE) transport mechanisms. 
+
+<Info>
+We will also be integrating **Streamable HTTP** transport in the near future. 
+Streamable HTTP is designed for efficient, bi-directional communication over a single HTTP connection.
+</Info>
+
+## Video Tutorial
+Watch this video tutorial for a comprehensive guide on MCP integration with CrewAI:
+
+<iframe
+  width="100%"
+  height="400"
+  src="https://www.youtube.com/embed/TpQ45lAZh48"
+  title="CrewAI MCP Integration Guide"
+  frameborder="0"
+  style={{ borderRadius: '10px' }}
+  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+  allowfullscreen
+></iframe>
+
+## Installation
+
+Before you start using MCP with `crewai-tools`, you need to install the `mcp` extra `crewai-tools` dependency with the following command:
+
+```shell
+uv pip install 'crewai-tools[mcp]'
+```
+
+### Integrating MCP Tools with `MCPServerAdapter`
+
+The `MCPServerAdapter` class from `crewai-tools` is the primary way to connect to an MCP server and make its tools available to your CrewAI agents. 
+It supports different transport mechanisms, primarily **Stdio** (for local servers) and **SSE** (Server-Sent Events).You have two main options for managing the connection lifecycle:
+
+### Option 1: Fully Managed Connection (Recommended)
+
+Using a Python context manager (`with` statement) is the recommended approach. It automatically handles starting and stopping the connection to the MCP server.
+
+**For a local Stdio-based MCP server:**
+
+```python
+from crewai import Agent, Task, Crew
+from crewai_tools import MCPServerAdapter
+from mcp import StdioServerParameters
+import os
+
+server_params=StdioServerParameters(
+    command="uxv", # Or your python3 executable i.e. "python3"
+    args=["mock_server.py"],
+    env={"UV_PYTHON": "3.12", **os.environ},
+)
+
+with MCPServerAdapter(server_params) as tools:
+    print(f"Available tools from Stdio MCP server: {[tool.name for tool in tools]}")
+
+    # Example: Using the tools from the Stdio MCP server in a CrewAI Agent
+    agent = Agent(
+        role="Web Information Retriever",
+        goal="Scrape content from a specified URL.",
+        backstory="An AI that can fetch and process web page data via an MCP tool.",
+        tools=tools,
+        verbose=True,
+    )
+    task = Task(
+        description="Scrape content from a specified URL.",
+        expected_output="Scraped content from the specified URL.",
+        agent=agent,
+    )
+    crew = Crew(
+        agents=[agent],
+        tasks=[task],
+        verbose=True,
+    )
+    result = crew.kickoff()
+    print(result)
+```
+
+**For a remote SSE-based MCP server:**
+
+```python
+from crewai_tools import MCPServerAdapter
+from crewai import Agent, Task, Crew
+
+server_params = {"url": "http://localhost:8000/sse"}
+
+with MCPServerAdapter(server_params) as tools:
+    print(f"Available tools from SSE MCP server: {[tool.name for tool in tools]}")
+
+    # Example: Using the tools from the SSE MCP server in a CrewAI Agent
+    agent = Agent(
+        role="Web Information Retriever",
+        goal="Scrape content from a specified URL.",
+        backstory="An AI that can fetch and process web page data via an MCP tool.",
+        tools=tools,
+        verbose=True,
+    )
+    task = Task(
+        description="Scrape content from a specified URL.",
+        expected_output="Scraped content from the specified URL.",
+        agent=agent,
+    )
+    crew = Crew(
+        agents=[agent],
+        tasks=[task],
+        verbose=True,
+    )
+    result = crew.kickoff()
+    print(result)
+```
+
+### Option 2: More control over the MCP server connection lifecycle
+
+If you need finer-grained control over the MCP server connection lifecycle, you can instantiate `MCPServerAdapter` directly and manage its `start()` and `stop()` methods.
+
+<Info>
+You **MUST** call `mcp_server_adapter.stop()` to ensure the connection is closed and resources are released. Using a `try...finally` block is highly recommended.
+</Info>
+
+#### Stdio Transport Example (Manual)
+
+```python
+from mcp import StdioServerParameters
+from crewai_tools import MCPServerAdapter
+from crewai import Agent, Task, Crew
+import os
+
+stdio_params = StdioServerParameters(
+    command="uvx", # Or your python3 executable i.e. "python3"
+    args=["--quiet", "your-mcp-server@0.1.3"],
+    env={"UV_PYTHON": "3.12", **os.environ},
+)
+
+mcp_server_adapter = MCPServerAdapter(server_params=stdio_params)
+try:
+    mcp_server_adapter.start() # Manually start the connection
+    tools = mcp_server_adapter.tools
+    print(f"Available tools (manual Stdio): {[tool.name for tool in tools]}")
+
+    # Use 'tools' with your Agent, Task, Crew setup as in Option 1
+    agent = Agent(
+        role="Medical Researcher", 
+        goal="Find recent studies on a given topic using PubMed.", 
+        backstory="An AI assistant specialized in biomedical literature research.", 
+        tools=tools,
+        verbose=True 
+    )
+    
+    task = Task(
+        description="Search for recent articles on 'crispr gene editing'.",
+        expected_output="A summary of the top 3 recent articles.",
+        agent=agent
+    )
+    
+    crew = Crew(
+        agents=[agent],
+        tasks=[task],
+        verbose=True,
+        process=Process.sequential
+    )
+    
+    result = crew.kickoff()
+    print(result)
+finally:
+    print("Stopping Stdio MCP server connection (manual)...")
+    mcp_server_adapter.stop() # **Crucial: Ensure stop is called**
+```
+
+
+#### SSE Transport Example (Manual)
+
+```python
+from crewai_tools import MCPServerAdapter
+from crewai import Agent, Task, Crew, Process
+from mcp import StdioServerParameters
+
+
+server_params = {"url": "http://localhost:8000/sse"}
+
+try:
+    mcp_server_adapter = MCPServerAdapter(server_params)
+    mcp_server_adapter.start()
+    tools = mcp_server_adapter.tools
+    print(f"Available tools (manual SSE): {[tool.name for tool in tools]}")
+
+    agent = Agent(
+        role="Medical Researcher", 
+        goal="Find recent studies on a given topic using PubMed.", 
+        backstory="An AI assistant specialized in biomedical literature research.", 
+        tools=tools,
+        verbose=True 
+    )
+    
+    task = Task(
+        description="Search for recent articles on 'crispr gene editing'.",
+        expected_output="A summary of the top 3 recent articles.",
+        agent=agent
+    )
+    
+    crew = Crew(
+        agents=[agent],
+        tasks=[task],
+        verbose=True,
+        process=Process.sequential
+    )
+    
+    result = crew.kickoff()
+    print(result)
+finally:
+    print("Stopping SSE MCP server connection (manual)...")
+    mcp_server_adapter.stop() # **Crucial: Ensure stop is called**
+```
+
+## Staying Safe with MCP
+<Warning>
+Always ensure that you trust an MCP Server before using it.
+</Warning>
+
+#### Security Warning: DNS Rebinding Attacks
+SSE transports can be vulnerable to DNS rebinding attacks if not properly secured. 
+To prevent this:
+
+1. **Always validate Origin headers** on incoming SSE connections to ensure they come from expected sources
+2. **Avoid binding servers to all network interfaces** (0.0.0.0) when running locally - bind only to localhost (127.0.0.1) instead
+3. **Implement proper authentication** for all SSE connections
+
+Without these protections, attackers could use DNS rebinding to interact with local MCP servers from remote websites.
+
+For more details, see the [MCP Transport Security](https://modelcontextprotocol.io/docs/concepts/transports#security-considerations) documentation.
+
+### Limitations
+*   **Supported Primitives**: Currently, `MCPServerAdapter` primarily supports adapting MCP `tools`. 
+Other MCP primitives like `prompts` or `resources` are not directly integrated as CrewAI components through this adapter at this time.
+*   **Output Handling**: The adapter typically processes the primary text output from an MCP tool (e.g., `.content[0].text`). Complex or multi-modal outputs might require custom handling if not fitting this pattern.

docs/mcp/multiple-servers.mdx

@@ -1,64 +0,0 @@
----
-title: Connecting to Multiple MCP Servers
-description: Learn how to use MCPServerAdapter in CrewAI to connect to multiple MCP servers simultaneously and aggregate their tools.
-icon: layer-group
----
-
-## Overview
-
-`MCPServerAdapter` in `crewai-tools` allows you to connect to multiple MCP servers concurrently. This is useful when your agents need to access tools distributed across different services or environments. The adapter aggregates tools from all specified servers, making them available to your CrewAI agents.
-
-## Configuration
-
-To connect to multiple servers, you provide a list of server parameter dictionaries to `MCPServerAdapter`. Each dictionary in the list should define the parameters for one MCP server.
-
-Supported transport types for each server in the list include `stdio`, `sse`, and `streamable-http`.
-
-```python
-from crewai import Agent, Task, Crew, Process
-from crewai_tools import MCPServerAdapter
-from mcp import StdioServerParameters # Needed for Stdio example
-
-# Define parameters for multiple MCP servers
-server_params_list = [
-    # Streamable HTTP Server
-    {
-        "url": "http://localhost:8001/mcp", 
-        "transport": "streamable-http"
-    },
-    # SSE Server
-    {
-        "url": "http://localhost:8000/sse",
-        "transport": "sse"
-    },
-    # StdIO Server
-    StdioServerParameters(
-        command="python3",
-        args=["servers/your_stdio_server.py"],
-        env={"UV_PYTHON": "3.12", **os.environ},
-    )
-]
-
-try:
-    with MCPServerAdapter(server_params_list) as aggregated_tools:
-        print(f"Available aggregated tools: {[tool.name for tool in aggregated_tools]}")
-
-        multi_server_agent = Agent(
-            role="Versatile Assistant",
-            goal="Utilize tools from local Stdio, remote SSE, and remote HTTP MCP servers.",
-            backstory="An AI agent capable of leveraging a diverse set of tools from multiple sources.",
-            tools=aggregated_tools, # All tools are available here
-            verbose=True,
-        )
-
-        ... # Your other agent, tasks, and crew code here
-
-except Exception as e:
-    print(f"Error connecting to or using multiple MCP servers (Managed): {e}")
-    print("Ensure all MCP servers are running and accessible with correct configurations.")
-
-```
-
-## Connection Management
-
-When using the context manager (`with` statement), `MCPServerAdapter` handles the lifecycle (start and stop) of all connections to the configured MCP servers. This simplifies resource management and ensures that all connections are properly closed when the context is exited.

docs/mcp/overview.mdx

@@ -1,164 +0,0 @@
----
-title: 'MCP Servers as Tools in CrewAI'
-description: 'Learn how to integrate MCP servers as tools in your CrewAI agents using the `crewai-tools` library.'
-icon: plug
----
-
-## Overview
-
-The [Model Context Protocol](https://modelcontextprotocol.io/introduction) (MCP) provides a standardized way for AI agents to provide context to LLMs by communicating with external services, known as MCP Servers. 
-The `crewai-tools` library extends CrewAI's capabilities by allowing you to seamlessly integrate tools from these MCP servers into your agents. 
-This gives your crews access to a vast ecosystem of functionalities. 
-
-We currently support the following transport mechanisms: 
-
-- **Stdio**: for local servers (communication via standard input/output between processes on the same machine)
-- **Server-Sent Events (SSE)**: for remote servers (unidirectional, real-time data streaming from server to client over HTTP)
-- **Streamable HTTP**: for remote servers (flexible, potentially bi-directional communication over HTTP, often utilizing SSE for server-to-client streams)
-
-## Video Tutorial
-Watch this video tutorial for a comprehensive guide on MCP integration with CrewAI:
-
-<iframe
-  width="100%"
-  height="400"
-  src="https://www.youtube.com/embed/TpQ45lAZh48"
-  title="CrewAI MCP Integration Guide"
-  frameborder="0"
-  style={{ borderRadius: '10px' }}
-  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
-  allowfullscreen
-></iframe>
-
-## Installation
-
-Before you start using MCP with `crewai-tools`, you need to install the `mcp` extra `crewai-tools` dependency with the following command:
-
-```shell
-uv pip install 'crewai-tools[mcp]'
-```
-
-## Key Concepts & Getting Started
-
-The `MCPServerAdapter` class from `crewai-tools` is the primary way to connect to an MCP server and make its tools available to your CrewAI agents. It supports different transport mechanisms and simplifies connection management.
-
-Using a Python context manager (`with` statement) is the **recommended approach** for `MCPServerAdapter`. It automatically handles starting and stopping the connection to the MCP server.
-
-```python
-from crewai import Agent
-from crewai_tools import MCPServerAdapter
-from mcp import StdioServerParameters # For Stdio Server
-
-# Example server_params (choose one based on your server type):
-# 1. Stdio Server:
-server_params=StdioServerParameters(
-    command="python3", 
-    args=["servers/your_server.py"],
-    env={"UV_PYTHON": "3.12", **os.environ},
-)
-
-# 2. SSE Server:
-server_params = {
-    "url": "http://localhost:8000/sse", 
-    "transport": "sse"
-}
-
-# 3. Streamable HTTP Server:
-server_params = {
-    "url": "http://localhost:8001/mcp", 
-    "transport": "streamable-http"
-}
-
-# Example usage (uncomment and adapt once server_params is set):
-with MCPServerAdapter(server_params) as mcp_tools:
-    print(f"Available tools: {[tool.name for tool in mcp_tools]}")
-    
-    my_agent = Agent(
-        role="MCP Tool User",
-        goal="Utilize tools from an MCP server.",
-        backstory="I can connect to MCP servers and use their tools.",
-        tools=mcp_tools, # Pass the loaded tools to your agent
-        reasoning=True,
-        verbose=True
-    )
-    # ... rest of your crew setup ...
-```
-This general pattern shows how to integrate tools. For specific examples tailored to each transport, refer to the detailed guides below.
-
-## Explore MCP Integrations
-
-<CardGroup cols={2}>
-  <Card 
-    title="Stdio Transport" 
-    icon="server" 
-    href="/mcp/stdio"
-    color="#3B82F6"
-  >
-    Connect to local MCP servers via standard input/output. Ideal for scripts and local executables.
-  </Card>
-  <Card 
-    title="SSE Transport" 
-    icon="wifi" 
-    href="/mcp/sse"
-    color="#10B981"
-  >
-    Integrate with remote MCP servers using Server-Sent Events for real-time data streaming.
-  </Card>
-  <Card 
-    title="Streamable HTTP Transport" 
-    icon="globe" 
-    href="/mcp/streamable-http"
-    color="#F59E0B"
-  >
-    Utilize flexible Streamable HTTP for robust communication with remote MCP servers.
-  </Card>
-  <Card 
-    title="Connecting to Multiple Servers" 
-    icon="layer-group" 
-    href="/mcp/multiple-servers"
-    color="#8B5CF6"
-  >
-    Aggregate tools from several MCP servers simultaneously using a single adapter.
-  </Card>
-  <Card 
-    title="Security Considerations" 
-    icon="lock" 
-    href="/mcp/security"
-    color="#EF4444"
-  >
-    Review important security best practices for MCP integration to keep your agents safe.
-  </Card>
-</CardGroup>
-
-Checkout this repository for full demos and examples of MCP integration with CrewAI! 👇
-
-<Card 
-title="GitHub Repository"
-icon="github"
-href="https://github.com/tonykipkemboi/crewai-mcp-demo"
-target="_blank"
->
-CrewAI MCP Demo
-</Card>
-
-## Staying Safe with MCP
-<Warning>
-Always ensure that you trust an MCP Server before using it.
-</Warning>
-
-#### Security Warning: DNS Rebinding Attacks
-SSE transports can be vulnerable to DNS rebinding attacks if not properly secured. 
-To prevent this:
-
-1. **Always validate Origin headers** on incoming SSE connections to ensure they come from expected sources
-2. **Avoid binding servers to all network interfaces** (0.0.0.0) when running locally - bind only to localhost (127.0.0.1) instead
-3. **Implement proper authentication** for all SSE connections
-
-Without these protections, attackers could use DNS rebinding to interact with local MCP servers from remote websites.
-
-For more details, see the [Anthropic's MCP Transport Security docs](https://modelcontextprotocol.io/docs/concepts/transports#security-considerations).
-
-### Limitations
-*   **Supported Primitives**: Currently, `MCPServerAdapter` primarily supports adapting MCP `tools`. 
-Other MCP primitives like `prompts` or `resources` are not directly integrated as CrewAI components through this adapter at this time.
-*   **Output Handling**: The adapter typically processes the primary text output from an MCP tool (e.g., `.content[0].text`). Complex or multi-modal outputs might require custom handling if not fitting this pattern.

docs/mcp/security.mdx

@@ -1,166 +0,0 @@
----
-title: MCP Security Considerations
-description: Learn about important security best practices when integrating MCP servers with your CrewAI agents.
-icon: lock
----
-
-## Overview
-
-<Warning>
-The most critical aspect of MCP security is **trust**. You should **only** connect your CrewAI agents to MCP servers that you fully trust.
-</Warning>
-
-When integrating external services like MCP (Model Context Protocol) servers into your CrewAI agents, security is paramount. 
-MCP servers can execute code, access data, or interact with other systems based on the tools they expose. 
-It's crucial to understand the implications and follow best practices to protect your applications and data.
-
-### Risks
-
-- Execute arbitrary code on the machine where the agent is running (especially with `Stdio` transport if the server can control the command executed).
-- Expose sensitive data from your agent or its environment.
-- Manipulate your agent's behavior in unintended ways, including making unauthorized API calls on your behalf.
-- Hijack your agent's reasoning process through sophisticated prompt injection techniques (see below).
-
-### 1. Trusting MCP Servers
-
-<Warning>
-**Only connect to MCP servers that you trust.**
-</Warning>
-
-Before configuring `MCPServerAdapter` to connect to an MCP server, ensure you know:
-- **Who operates the server?** Is it a known, reputable service, or an internal server under your control?
-- **What tools does it expose?** Understand the capabilities of the tools. Could they be misused if an attacker gained control or if the server itself is malicious?
-- **What data does it access or process?** Be aware of any sensitive information that might be sent to or handled by the MCP server.
-
-Avoid connecting to unknown or unverified MCP servers, especially if your agents handle sensitive tasks or data.
-
-### 2. Secure Prompt Injection via Tool Metadata: The "Model Control Protocol" Risk
-
-A significant and subtle risk is the potential for prompt injection through tool metadata. Here's how it works:
-
-1.  When your CrewAI agent connects to an MCP server, it typically requests a list of available tools.
-2.  The MCP server responds with metadata for each tool, including its name, description, and parameter descriptions.
-3.  Your agent's underlying Language Model (LLM) uses this metadata to understand how and when to use the tools. This metadata is often incorporated into the LLM's system prompt or context.
-4.  A malicious MCP server can craft its tool metadata (names, descriptions) to include hidden or overt instructions. These instructions can act as a prompt injection, effectively telling your LLM to behave in a certain way, reveal sensitive information, or perform malicious actions.
-
-**Crucially, this attack can occur simply by connecting to a malicious server and listing its tools, even if your agent never explicitly decides to *use* any of those tools.** The mere exposure to the malicious metadata can be enough to compromise the agent's behavior.
-
-**Mitigation:**
-
-*   **Extreme Caution with Untrusted Servers:** Reiterate: *Do not connect to MCP servers you do not fully trust.* The risk of metadata injection makes this paramount.
-
-### Stdio Transport Security
-
-Stdio (Standard Input/Output) transport is typically used for local MCP servers running on the same machine as your CrewAI application.
-
-- **Process Isolation**: While generally safer as it doesn't involve network exposure by default, ensure the script or command run by `StdioServerParameters` is from a trusted source and has appropriate file system permissions. A malicious Stdio server script could still harm your local system.
-- **Input Sanitization**: If your Stdio server script takes complex inputs derived from agent interactions, ensure the script itself sanitizes these inputs to prevent command injection or other vulnerabilities within the script's logic.
-- **Resource Limits**: Be mindful that a local Stdio server process consumes local resources (CPU, memory). Ensure it's well-behaved and won't exhaust system resources.
-
-### Confused Deputy Attacks
-
-The [Confused Deputy Problem](https://en.wikipedia.org/wiki/Confused_deputy_problem) is a classic security vulnerability that can manifest in MCP integrations, especially when an MCP server acts as a proxy to other third-party services (e.g., Google Calendar, GitHub) that use OAuth 2.0 for authorization.
-
-**Scenario:**
-
-1.  An MCP server (let's call it `MCP-Proxy`) allows your agent to interact with `ThirdPartyAPI`.
-2.  `MCP-Proxy` uses its own single, static `client_id` when talking to `ThirdPartyAPI`'s authorization server.
-3.  You, as the user, legitimately authorize `MCP-Proxy` to access `ThirdPartyAPI` on your behalf. During this, `ThirdPartyAPI`'s auth server might set a cookie in your browser indicating your consent for `MCP-Proxy`'s `client_id`.
-4.  An attacker crafts a malicious link. This link initiates an OAuth flow with `MCP-Proxy`, but is designed to trick `ThirdPartyAPI`'s auth server.
-5.  If you click this link, and `ThirdPartyAPI`'s auth server sees your existing consent cookie for `MCP-Proxy`'s `client_id`, it might *skip* asking for your consent again.
-6.  `MCP-Proxy` might then be tricked into forwarding an authorization code (for `ThirdPartyAPI`) to the attacker, or an MCP authorization code that the attacker can use to impersonate you to `MCP-Proxy`.
-
-**Mitigation (Primarily for MCP Server Developers):**
-
-*   MCP proxy servers using static client IDs for downstream services **must** obtain explicit user consent for *each client application or agent* connecting to them *before* initiating an OAuth flow with the third-party service. This means `MCP-Proxy` itself should show a consent screen.
-
-**CrewAI User Implication:**
-
-*   Be cautious if an MCP server redirects you for multiple OAuth authentications, especially if it seems unexpected or if the permissions requested are overly broad.
-*   Prefer MCP servers that clearly delineate their own identity versus the third-party services they might proxy.
-
-### Remote Transport Security (SSE & Streamable HTTP)
-
-When connecting to remote MCP servers via Server-Sent Events (SSE) or Streamable HTTP, standard web security practices are essential.
-
-### SSE Security Considerations
-
-### a. DNS Rebinding Attacks (Especially for SSE)
-
-<Critical>
-**Protect against DNS Rebinding Attacks.**
-</Critical>
-
-DNS rebinding allows an attacker-controlled website to bypass the same-origin policy and make requests to servers on the user's local network (e.g., `localhost`) or intranet. This is particularly risky if you run an MCP server locally (e.g., for development) and an agent in a browser-like environment (though less common for typical CrewAI backend setups) or if the MCP server is on an internal network.
-
-**Mitigation Strategies for MCP Server Implementers:**
-- **Validate `Origin` and `Host` Headers**: MCP servers (especially SSE ones) should validate the `Origin` and/or `Host` HTTP headers to ensure requests are coming from expected domains/clients.
-- **Bind to `localhost` (127.0.0.1)**: When running MCP servers locally for development, bind them to `127.0.0.1` instead of `0.0.0.0`. This prevents them from being accessible from other machines on the network.
-- **Authentication**: Require authentication for all connections to your MCP server if it's not intended for public anonymous access.
-
-### b. Use HTTPS
-
-- **Encrypt Data in Transit**: Always use HTTPS (HTTP Secure) for the URLs of remote MCP servers. This encrypts the communication between your CrewAI application and the MCP server, protecting against eavesdropping and man-in-the-middle attacks. `MCPServerAdapter` will respect the scheme (`http` or `https`) provided in the URL.
-
-### c. Token Passthrough (Anti-Pattern)
-
-This is primarily a concern for MCP server developers but understanding it helps in choosing secure servers.
-
-"Token passthrough" is when an MCP server accepts an access token from your CrewAI agent (which might be a token for a *different* service, say `ServiceA`) and simply passes it through to another downstream API (`ServiceB`) without proper validation. Specifically, `ServiceB` (or the MCP server itself) should only accept tokens that were explicitly issued *for them* (i.e., the 'audience' claim in the token matches the server/service).
-
-**Risks:**
-
-*   Bypasses security controls (like rate limiting or fine-grained permissions) on the MCP server or the downstream API.
-*   Breaks audit trails and accountability.
-*   Allows misuse of stolen tokens.
-
-**Mitigation (For MCP Server Developers):**
-
-*   MCP servers **MUST NOT** accept tokens that were not explicitly issued for them. They must validate the token's audience claim.
-
-**CrewAI User Implication:**
-
-*   While not directly controllable by the user, this highlights the importance of connecting to well-designed MCP servers that adhere to security best practices.
-
-#### Authentication and Authorization
-
-- **Verify Identity**: If the MCP server provides sensitive tools or access to private data, it MUST implement strong authentication mechanisms to verify the identity of the client (your CrewAI application). This could involve API keys, OAuth tokens, or other standard methods.
-- **Principle of Least Privilege**: Ensure the credentials used by `MCPServerAdapter` (if any) have only the necessary permissions to access the required tools.
-
-### d. Input Validation and Sanitization
-
-- **Input Validation is Critical**: MCP servers **must** rigorously validate all inputs received from agents *before* processing them or passing them to tools. This is a primary defense against many common vulnerabilities:
-    - **Command Injection:** If a tool constructs shell commands, SQL queries, or other interpreted language statements based on input, the server must meticulously sanitize this input to prevent malicious commands from being injected and executed.
-    - **Path Traversal:** If a tool accesses files based on input parameters, the server must validate and sanitize these paths to prevent access to unauthorized files or directories (e.g., by blocking `../` sequences).
-    - **Data Type & Range Checks:** Servers must ensure that input data conforms to the expected data types (e.g., string, number, boolean) and falls within acceptable ranges or adheres to defined formats (e.g., regex for URLs).
-    - **JSON Schema Validation:** All tool parameters should be strictly validated against their defined JSON schema. This helps catch malformed requests early.
-- **Client-Side Awareness**: While server-side validation is paramount, as a CrewAI user, be mindful of the data your agents are constructed to send to MCP tools, especially if interacting with less-trusted or new MCP servers.
-
-### e. Rate Limiting and Resource Management
-
-- **Prevent Abuse**: MCP servers should implement rate limiting to prevent abuse, whether intentional (Denial of Service attacks) or unintentional (e.g., a misconfigured agent making too many requests).
-- **Client-Side Retries**: Implement sensible retry logic in your CrewAI tasks if transient network issues or server rate limits are expected, but avoid aggressive retries that could exacerbate server load.
-
-## 4. Secure MCP Server Implementation Advice (For Developers)
-
-If you are developing an MCP server that CrewAI agents might connect to, consider these best practices in addition to the points above:
-
-- **Follow Secure Coding Practices**: Adhere to standard secure coding principles for your chosen language and framework (e.g., OWASP Top 10).
-- **Principle of Least Privilege**: Ensure the process running the MCP server (especially for `Stdio`) has only the minimum necessary permissions. Tools themselves should also operate with the least privilege required to perform their function.
-- **Dependency Management**: Keep all server-side dependencies, including operating system packages, language runtimes, and third-party libraries, up-to-date to patch known vulnerabilities. Use tools to scan for vulnerable dependencies.
-- **Secure Defaults**: Design your server and its tools to be secure by default. For example, features that could be risky should be off by default or require explicit opt-in with clear warnings.
-- **Access Control for Tools**: Implement robust mechanisms to control which authenticated and authorized agents or users can access specific tools, especially those that are powerful, sensitive, or incur costs.
-- **Secure Error Handling**: Servers should not expose detailed internal error messages, stack traces, or debugging information to the client, as these can reveal internal workings or potential vulnerabilities. Log errors comprehensively on the server-side for diagnostics.
-- **Comprehensive Logging and Monitoring**: Implement detailed logging of security-relevant events (e.g., authentication attempts, tool invocations, errors, authorization changes). Monitor these logs for suspicious activity or abuse patterns.
-- **Adherence to MCP Authorization Spec**: If implementing authentication and authorization, strictly follow the [MCP Authorization specification](https://modelcontextprotocol.io/specification/draft/basic/authorization) and relevant [OAuth 2.0 security best practices](https://datatracker.ietf.org/doc/html/rfc9700).
-- **Regular Security Audits**: If your MCP server handles sensitive data, performs critical operations, or is publicly exposed, consider periodic security audits by qualified professionals.
-
-## 5. Further Reading
-
-For more detailed information on MCP security, refer to the official documentation:
-- **[MCP Transport Security](https://modelcontextprotocol.io/docs/concepts/transports#security-considerations)**
-
-By understanding these security considerations and implementing best practices, you can safely leverage the power of MCP servers in your CrewAI projects. 
-These are by no means exhaustive, but they cover the most common and critical security concerns. 
-The threats will continue to evolve, so it's important to stay informed and adapt your security measures accordingly.
-

docs/mcp/sse.mdx

@@ -1,150 +0,0 @@
----
-title: SSE Transport
-description: Learn how to connect CrewAI to remote MCP servers using Server-Sent Events (SSE) for real-time communication.
-icon: wifi
----
-
-## Overview
-
-Server-Sent Events (SSE) provide a standard way for a web server to send updates to a client over a single, long-lived HTTP connection. In the context of MCP, SSE is used for remote servers to stream data (like tool responses) to your CrewAI application in real-time.
-
-## Key Concepts
-
-- **Remote Servers**: SSE is suitable for MCP servers hosted remotely.
-- **Unidirectional Stream**: Typically, SSE is a one-way communication channel from server to client.
-- **`MCPServerAdapter` Configuration**: For SSE, you'll provide the server's URL and specify the transport type.
-
-## Connecting via SSE
-
-You can connect to an SSE-based MCP server using two main approaches for managing the connection lifecycle:
-
-### 1. Fully Managed Connection (Recommended)
-
-Using a Python context manager (`with` statement) is the recommended approach. It automatically handles establishing and closing the connection to the SSE MCP server.
-
-```python
-from crewai import Agent, Task, Crew, Process
-from crewai_tools import MCPServerAdapter
-
-server_params = {
-    "url": "http://localhost:8000/sse", # Replace with your actual SSE server URL
-    "transport": "sse" 
-}
-
-# Using MCPServerAdapter with a context manager
-try:
-    with MCPServerAdapter(server_params) as tools:
-        print(f"Available tools from SSE MCP server: {[tool.name for tool in tools]}")
-
-        # Example: Using a tool from the SSE MCP server
-        sse_agent = Agent(
-            role="Remote Service User",
-            goal="Utilize a tool provided by a remote SSE MCP server.",
-            backstory="An AI agent that connects to external services via SSE.",
-            tools=tools,
-            reasoning=True,
-            verbose=True,
-        )
-
-        sse_task = Task(
-            description="Fetch real-time stock updates for 'AAPL' using an SSE tool.",
-            expected_output="The latest stock price for AAPL.",
-            agent=sse_agent,
-            markdown=True
-        )
-
-        sse_crew = Crew(
-            agents=[sse_agent],
-            tasks=[sse_task],
-            verbose=True,
-            process=Process.sequential
-        )
-        
-        if tools: # Only kickoff if tools were loaded
-            result = sse_crew.kickoff() # Add inputs={'stock_symbol': 'AAPL'} if tool requires it
-            print("\nCrew Task Result (SSE - Managed):\n", result)
-        else:
-            print("Skipping crew kickoff as tools were not loaded (check server connection).")
-
-except Exception as e:
-    print(f"Error connecting to or using SSE MCP server (Managed): {e}")
-    print("Ensure the SSE MCP server is running and accessible at the specified URL.")
-
-```
-
-<Note>
-Replace `"http://localhost:8000/sse"` with the actual URL of your SSE MCP server.
-</Note>
-
-### 2. Manual Connection Lifecycle
-
-If you need finer-grained control, you can manage the `MCPServerAdapter` connection lifecycle manually.
-
-<Info>
-You **MUST** call `mcp_server_adapter.stop()` to ensure the connection is closed and resources are released. Using a `try...finally` block is highly recommended.
-</Info>
-
-```python
-from crewai import Agent, Task, Crew, Process
-from crewai_tools import MCPServerAdapter
-
-server_params = {
-    "url": "http://localhost:8000/sse", # Replace with your actual SSE server URL
-    "transport": "sse"
-}
-
-mcp_server_adapter = None 
-try:
-    mcp_server_adapter = MCPServerAdapter(server_params)
-    mcp_server_adapter.start()
-    tools = mcp_server_adapter.tools
-    print(f"Available tools (manual SSE): {[tool.name for tool in tools]}")
-
-    manual_sse_agent = Agent(
-        role="Remote Data Analyst",
-        goal="Analyze data fetched from a remote SSE MCP server using manual connection management.",
-        backstory="An AI skilled in handling SSE connections explicitly.",
-        tools=tools,
-        verbose=True
-    )
-    
-    analysis_task = Task(
-        description="Fetch and analyze the latest user activity trends from the SSE server.",
-        expected_output="A summary report of user activity trends.",
-        agent=manual_sse_agent
-    )
-    
-    analysis_crew = Crew(
-        agents=[manual_sse_agent],
-        tasks=[analysis_task],
-        verbose=True,
-        process=Process.sequential
-    )
-    
-    result = analysis_crew.kickoff()
-    print("\nCrew Task Result (SSE - Manual):\n", result)
-
-except Exception as e:
-    print(f"An error occurred during manual SSE MCP integration: {e}")
-    print("Ensure the SSE MCP server is running and accessible.")
-finally:
-    if mcp_server_adapter and mcp_server_adapter.is_connected:
-        print("Stopping SSE MCP server connection (manual)...")
-        mcp_server_adapter.stop()  # **Crucial: Ensure stop is called**
-    elif mcp_server_adapter:
-        print("SSE MCP server adapter was not connected. No stop needed or start failed.")
-
-```
-
-## Security Considerations for SSE
-
-<Warning>
-**DNS Rebinding Attacks**: SSE transports can be vulnerable to DNS rebinding attacks if the MCP server is not properly secured. This could allow malicious websites to interact with local or intranet-based MCP servers.
-</Warning>
-
-To mitigate this risk:
-- MCP server implementations should **validate `Origin` headers** on incoming SSE connections.
-- When running local SSE MCP servers for development, **bind only to `localhost` (`127.0.0.1`)** rather than all network interfaces (`0.0.0.0`).
-- Implement **proper authentication** for all SSE connections if they expose sensitive tools or data.
-
-For a comprehensive overview of security best practices, please refer to our [Security Considerations](./security.mdx) page and the official [MCP Transport Security documentation](https://modelcontextprotocol.io/docs/concepts/transports#security-considerations).

docs/mcp/stdio.mdx

@@ -1,134 +0,0 @@
----
-title: Stdio Transport
-description: Learn how to connect CrewAI to local MCP servers using the Stdio (Standard Input/Output) transport mechanism.
-icon: server
----
-
-## Overview
-
-The Stdio (Standard Input/Output) transport is designed for connecting `MCPServerAdapter` to local MCP servers that communicate over their standard input and output streams. This is typically used when the MCP server is a script or executable running on the same machine as your CrewAI application.
-
-## Key Concepts
-
-- **Local Execution**: Stdio transport manages a locally running process for the MCP server.
-- **`StdioServerParameters`**: This class from the `mcp` library is used to configure the command, arguments, and environment variables for launching the Stdio server.
-
-## Connecting via Stdio
-
-You can connect to an Stdio-based MCP server using two main approaches for managing the connection lifecycle:
-
-### 1. Fully Managed Connection (Recommended)
-
-Using a Python context manager (`with` statement) is the recommended approach. It automatically handles starting the MCP server process and stopping it when the context is exited.
-
-```python
-from crewai import Agent, Task, Crew, Process
-from crewai_tools import MCPServerAdapter
-from mcp import StdioServerParameters
-import os
-
-# Create a StdioServerParameters object
-server_params=StdioServerParameters(
-    command="python3", 
-    args=["servers/your_stdio_server.py"],
-    env={"UV_PYTHON": "3.12", **os.environ},
-)
-
-with MCPServerAdapter(server_params) as tools:
-    print(f"Available tools from Stdio MCP server: {[tool.name for tool in tools]}")
-
-    # Example: Using the tools from the Stdio MCP server in a CrewAI Agent
-    research_agent = Agent(
-        role="Local Data Processor",
-        goal="Process data using a local Stdio-based tool.",
-        backstory="An AI that leverages local scripts via MCP for specialized tasks.",
-        tools=tools,
-        reasoning=True,
-        verbose=True,
-    )
-    
-    processing_task = Task(
-        description="Process the input data file 'data.txt' and summarize its contents.",
-        expected_output="A summary of the processed data.",
-        agent=research_agent,
-        markdown=True
-    )
-    
-    data_crew = Crew(
-        agents=[research_agent],
-        tasks=[processing_task],
-        verbose=True,
-        process=Process.sequential 
-    )
-   
-    result = data_crew.kickoff()
-    print("\nCrew Task Result (Stdio - Managed):\n", result)
-
-```
-
-### 2. Manual Connection Lifecycle
-
-If you need finer-grained control over when the Stdio MCP server process is started and stopped, you can manage the `MCPServerAdapter` lifecycle manually.
-
-<Info>
-You **MUST** call `mcp_server_adapter.stop()` to ensure the server process is terminated and resources are released. Using a `try...finally` block is highly recommended.
-</Info>
-
-```python
-from crewai import Agent, Task, Crew, Process
-from crewai_tools import MCPServerAdapter
-from mcp import StdioServerParameters
-import os
-
-# Create a StdioServerParameters object
-stdio_params=StdioServerParameters(
-    command="python3", 
-    args=["servers/your_stdio_server.py"],
-    env={"UV_PYTHON": "3.12", **os.environ},
-)
-
-mcp_server_adapter = MCPServerAdapter(server_params=stdio_params)
-try:
-    mcp_server_adapter.start()  # Manually start the connection and server process
-    tools = mcp_server_adapter.tools
-    print(f"Available tools (manual Stdio): {[tool.name for tool in tools]}")
-
-    # Example: Using the tools with your Agent, Task, Crew setup
-    manual_agent = Agent(
-        role="Local Task Executor",
-        goal="Execute a specific local task using a manually managed Stdio tool.",
-        backstory="An AI proficient in controlling local processes via MCP.",
-        tools=tools,
-        verbose=True
-    )
-    
-    manual_task = Task(
-        description="Execute the 'perform_analysis' command via the Stdio tool.",
-        expected_output="Results of the analysis.",
-        agent=manual_agent
-    )
-    
-    manual_crew = Crew(
-        agents=[manual_agent],
-        tasks=[manual_task],
-        verbose=True,
-        process=Process.sequential
-    )
-        
-       
-    result = manual_crew.kickoff() # Actual inputs depend on your tool
-    print("\nCrew Task Result (Stdio - Manual):\n", result)
-            
-except Exception as e:
-    print(f"An error occurred during manual Stdio MCP integration: {e}")
-finally:
-    if mcp_server_adapter and mcp_server_adapter.is_connected: # Check if connected before stopping
-        print("Stopping Stdio MCP server connection (manual)...")
-        mcp_server_adapter.stop()  # **Crucial: Ensure stop is called**
-    elif mcp_server_adapter: # If adapter exists but not connected (e.g. start failed)
-        print("Stdio MCP server adapter was not connected. No stop needed or start failed.")
-
-```
-
-Remember to replace placeholder paths and commands with your actual Stdio server details. The `env` parameter in `StdioServerParameters` can 
-be used to set environment variables for the server process, which can be useful for configuring its behavior or providing necessary paths (like `PYTHONPATH`).

docs/mcp/streamable-http.mdx

@@ -1,135 +0,0 @@
----
-title: Streamable HTTP Transport
-description: Learn how to connect CrewAI to remote MCP servers using the flexible Streamable HTTP transport.
-icon: globe
----
-
-## Overview
-
-Streamable HTTP transport provides a flexible way to connect to remote MCP servers. It's often built upon HTTP and can support various communication patterns, including request-response and streaming, sometimes utilizing Server-Sent Events (SSE) for server-to-client streams within a broader HTTP interaction.
-
-## Key Concepts
-
-- **Remote Servers**: Designed for MCP servers hosted remotely.
-- **Flexibility**: Can support more complex interaction patterns than plain SSE, potentially including bi-directional communication if the server implements it.
-- **`MCPServerAdapter` Configuration**: You'll need to provide the server's base URL for MCP communication and specify `"streamable-http"` as the transport type.
-
-## Connecting via Streamable HTTP
-
-You have two primary methods for managing the connection lifecycle with a Streamable HTTP MCP server:
-
-### 1. Fully Managed Connection (Recommended)
-
-The recommended approach is to use a Python context manager (`with` statement), which handles the connection's setup and teardown automatically.
-
-```python
-from crewai import Agent, Task, Crew, Process
-from crewai_tools import MCPServerAdapter
-
-server_params = {
-    "url": "http://localhost:8001/mcp", # Replace with your actual Streamable HTTP server URL
-    "transport": "streamable-http"
-}
-
-try:
-    with MCPServerAdapter(server_params) as tools:
-        print(f"Available tools from Streamable HTTP MCP server: {[tool.name for tool in tools]}")
-
-        http_agent = Agent(
-            role="HTTP Service Integrator",
-            goal="Utilize tools from a remote MCP server via Streamable HTTP.",
-            backstory="An AI agent adept at interacting with complex web services.",
-            tools=tools,
-            verbose=True,
-        )
-
-        http_task = Task(
-            description="Perform a complex data query using a tool from the Streamable HTTP server.",
-            expected_output="The result of the complex data query.",
-            agent=http_agent,
-        )
-
-        http_crew = Crew(
-            agents=[http_agent],
-            tasks=[http_task],
-            verbose=True,
-            process=Process.sequential
-        )
-        
-        result = http_crew.kickoff() 
-        print("\nCrew Task Result (Streamable HTTP - Managed):\n", result)
-
-except Exception as e:
-    print(f"Error connecting to or using Streamable HTTP MCP server (Managed): {e}")
-    print("Ensure the Streamable HTTP MCP server is running and accessible at the specified URL.")
-
-```
-**Note:** Replace `"http://localhost:8001/mcp"` with the actual URL of your Streamable HTTP MCP server.
-
-### 2. Manual Connection Lifecycle
-
-For scenarios requiring more explicit control, you can manage the `MCPServerAdapter` connection manually.
-
-<Info>
-It is **critical** to call `mcp_server_adapter.stop()` when you are done to close the connection and free up resources. A `try...finally` block is the safest way to ensure this.
-</Info>
-
-```python
-from crewai import Agent, Task, Crew, Process
-from crewai_tools import MCPServerAdapter
-
-server_params = {
-    "url": "http://localhost:8001/mcp", # Replace with your actual Streamable HTTP server URL
-    "transport": "streamable-http"
-}
-
-mcp_server_adapter = None 
-try:
-    mcp_server_adapter = MCPServerAdapter(server_params)
-    mcp_server_adapter.start()
-    tools = mcp_server_adapter.tools
-    print(f"Available tools (manual Streamable HTTP): {[tool.name for tool in tools]}")
-
-    manual_http_agent = Agent(
-        role="Advanced Web Service User",
-        goal="Interact with an MCP server using manually managed Streamable HTTP connections.",
-        backstory="An AI specialist in fine-tuning HTTP-based service integrations.",
-        tools=tools,
-        verbose=True
-    )
-    
-    data_processing_task = Task(
-        description="Submit data for processing and retrieve results via Streamable HTTP.",
-        expected_output="Processed data or confirmation.",
-        agent=manual_http_agent
-    )
-    
-    data_crew = Crew(
-        agents=[manual_http_agent],
-        tasks=[data_processing_task],
-        verbose=True,
-        process=Process.sequential
-    )
-    
-    result = data_crew.kickoff()
-    print("\nCrew Task Result (Streamable HTTP - Manual):\n", result)
-
-except Exception as e:
-    print(f"An error occurred during manual Streamable HTTP MCP integration: {e}")
-    print("Ensure the Streamable HTTP MCP server is running and accessible.")
-finally:
-    if mcp_server_adapter and mcp_server_adapter.is_connected:
-        print("Stopping Streamable HTTP MCP server connection (manual)...")
-        mcp_server_adapter.stop()  # **Crucial: Ensure stop is called**
-    elif mcp_server_adapter:
-        print("Streamable HTTP MCP server adapter was not connected. No stop needed or start failed.")
-```
-
-## Security Considerations
-
-When using Streamable HTTP transport, general web security best practices are paramount:
-- **Use HTTPS**: Always prefer HTTPS (HTTP Secure) for your MCP server URLs to encrypt data in transit.
-- **Authentication**: Implement robust authentication mechanisms if your MCP server exposes sensitive tools or data.
-- **Input Validation**: Ensure your MCP server validates all incoming requests and parameters.
-
-For a comprehensive guide on securing your MCP integrations, please refer to our [Security Considerations](./security.mdx) page and the official [MCP Transport Security documentation](https://modelcontextprotocol.io/docs/concepts/transports#security-considerations).

docs/observability/portkey.mdx

@@ -7,818 +7,196 @@ icon: key
 <img src="https://raw.githubusercontent.com/siddharthsambharia-portkey/Portkey-Product-Images/main/Portkey-CrewAI.png" alt="Portkey CrewAI Header Image" width="70%" />
 
 
+[Portkey](https://portkey.ai/?utm_source=crewai&utm_medium=crewai&utm_campaign=crewai) is a 2-line upgrade to make your CrewAI agents reliable, cost-efficient, and fast.
 
-## Introduction
+Portkey adds 4 core production capabilities to any CrewAI agent:
+1. Routing to **200+ LLMs**
+2. Making each LLM call more robust
+3. Full-stack tracing & cost, performance analytics
+4. Real-time guardrails to enforce behavior
 
-Portkey enhances CrewAI with production-readiness features, turning your experimental agent crews into robust systems by providing:
-
-- **Complete observability** of every agent step, tool use, and interaction
-- **Built-in reliability** with fallbacks, retries, and load balancing
-- **Cost tracking and optimization** to manage your AI spend
-- **Access to 200+ LLMs** through a single integration
-- **Guardrails** to keep agent behavior safe and compliant
-- **Version-controlled prompts** for consistent agent performance
-
-
-### Installation & Setup
+## Getting Started
 
 <Steps>
-<Step title="Install the required packages">
-```bash
-pip install -U crewai portkey-ai
-```
-</Step>
+    <Step title="Install CrewAI and Portkey">
+    ```bash
+    pip install -qU crewai portkey-ai
+    ```
+    </Step>
+    <Step title="Configure the LLM Client">
+    To build CrewAI Agents with Portkey, you'll need two keys:
+    - **Portkey API Key**: Sign up on the [Portkey app](https://app.portkey.ai/?utm_source=crewai&utm_medium=crewai&utm_campaign=crewai) and copy your API key
+    - **Virtual Key**: Virtual Keys securely manage your LLM API keys in one place. Store your LLM provider API keys securely in Portkey's vault
 
-<Step title="Generate API Key" icon="lock">
-Create a Portkey API key with optional budget/rate limits from the [Portkey dashboard](https://app.portkey.ai/). You can also attach configurations for reliability, caching, and more to this key. More on this later.
-</Step>
+    ```python
+    from crewai import LLM
+    from portkey_ai import createHeaders, PORTKEY_GATEWAY_URL
 
-<Step title="Configure CrewAI with Portkey">
-The integration is simple - you just need to update the LLM configuration in your CrewAI setup:
-
-```python
-from crewai import LLM
-from portkey_ai import createHeaders, PORTKEY_GATEWAY_URL
-
-# Create an LLM instance with Portkey integration
-gpt_llm = LLM(
-    model="gpt-4o",
-    base_url=PORTKEY_GATEWAY_URL,
-    api_key="dummy",  # We are using a Virtual key, so this is a placeholder
-    extra_headers=createHeaders(
-        api_key="YOUR_PORTKEY_API_KEY",
-        virtual_key="YOUR_LLM_VIRTUAL_KEY",
-        trace_id="unique-trace-id",               # Optional, for request tracing
+    gpt_llm = LLM(
+        model="gpt-4",
+        base_url=PORTKEY_GATEWAY_URL,
+        api_key="dummy", # We are using Virtual key
+        extra_headers=createHeaders(
+            api_key="YOUR_PORTKEY_API_KEY",
+            virtual_key="YOUR_VIRTUAL_KEY", # Enter your Virtual key from Portkey
+        )
     )
-)
+    ```
+    </Step>
+    <Step title="Create and Run Your First Agent">
+    ```python
+    from crewai import Agent, Task, Crew
 
-#Use them in your Crew Agents like this:
+    # Define your agents with roles and goals
+    coder = Agent(
+        role='Software developer',
+        goal='Write clear, concise code on demand',
+        backstory='An expert coder with a keen eye for software trends.',
+        llm=gpt_llm
+    )
 
-	@agent
-	def lead_market_analyst(self) -> Agent:
-		return Agent(
-			config=self.agents_config['lead_market_analyst'],
-			verbose=True,
-			memory=False,
-			llm=gpt_llm
-		)
+    # Create tasks for your agents
+    task1 = Task(
+        description="Define the HTML for making a simple website with heading- Hello World! Portkey is working!",
+        expected_output="A clear and concise HTML code",
+        agent=coder
+    )
 
-```
+    # Instantiate your crew
+    crew = Crew(
+        agents=[coder],
+        tasks=[task1],
+    )
 
-<Info>
-**What are Virtual Keys?** Virtual keys in Portkey securely store your LLM provider API keys (OpenAI, Anthropic, etc.) in an encrypted vault. They allow for easier key rotation and budget management. [Learn more about virtual keys here](https://portkey.ai/docs/product/ai-gateway/virtual-keys).
-</Info>
-</Step>
+    result = crew.kickoff()
+    print(result)
+    ```
+    </Step>
 </Steps>
 
-## Production Features
+## Key Features
 
-### 1. Enhanced Observability
+| Feature | Description |
+|:--------|:------------|
+| 🌐 Multi-LLM Support | Access OpenAI, Anthropic, Gemini, Azure, and 250+ providers through a unified interface |
+| 🛡️ Production Reliability | Implement retries, timeouts, load balancing, and fallbacks |
+| 📊 Advanced Observability | Track 40+ metrics including costs, tokens, latency, and custom metadata |
+| 🔍 Comprehensive Logging | Debug with detailed execution traces and function call logs |
+| 🚧 Security Controls | Set budget limits and implement role-based access control |
+| 🔄 Performance Analytics | Capture and analyze feedback for continuous improvement |
+| 💾 Intelligent Caching | Reduce costs and latency with semantic or simple caching |
 
-Portkey provides comprehensive observability for your CrewAI agents, helping you understand exactly what's happening during each execution.
 
-<Tabs>
-  <Tab title="Traces">
+## Production Features with Portkey Configs
+
+All features mentioned below are through Portkey's Config system. Portkey's Config system allows you to define routing strategies using simple JSON objects in your LLM API calls. You can create and manage Configs directly in your code or through the Portkey Dashboard. Each Config has a unique ID for easy reference.
+
 <Frame>
-    <img src="https://raw.githubusercontent.com/siddharthsambharia-portkey/Portkey-Product-Images/refs/heads/main/CrewAI%20Product%2011.1.webp"/>
+    <img src="https://raw.githubusercontent.com/Portkey-AI/docs-core/refs/heads/main/images/libraries/libraries-3.avif"/>
 </Frame>
 
-Traces provide a hierarchical view of your crew's execution, showing the sequence of LLM calls, tool invocations, and state transitions.
+
+### 1. Use 250+ LLMs
+Access various LLMs like Anthropic, Gemini, Mistral, Azure OpenAI, and more with minimal code changes. Switch between providers or use them together seamlessly. [Learn more about Universal API](https://portkey.ai/docs/product/ai-gateway/universal-api)
+
+
+Easily switch between different LLM providers:
 
 ```python
-# Add trace_id to enable hierarchical tracing in Portkey
-portkey_llm = LLM(
-    model="gpt-4o",
-    base_url=PORTKEY_GATEWAY_URL,
-    api_key="dummy",
-    extra_headers=createHeaders(
-        api_key="YOUR_PORTKEY_API_KEY",
-        virtual_key="YOUR_OPENAI_VIRTUAL_KEY",
-        trace_id="unique-session-id"  # Add unique trace ID
-    )
-)
-```
-  </Tab>
-
-  <Tab title="Logs">
-<Frame>
-    <img src="https://raw.githubusercontent.com/siddharthsambharia-portkey/Portkey-Product-Images/refs/heads/main/CrewAI%20Portkey%20Docs%20Metadata.png"/>
-</Frame>
-
-Portkey logs every interaction with LLMs, including:
-
-- Complete request and response payloads
-- Latency and token usage metrics
-- Cost calculations
-- Tool calls and function executions
-
-All logs can be filtered by metadata, trace IDs, models, and more, making it easy to debug specific crew runs.
-  </Tab>
-
-  <Tab title="Metrics & Dashboards">
-<Frame>
-    <img src="https://raw.githubusercontent.com/siddharthsambharia-portkey/Portkey-Product-Images/refs/heads/main/CrewAI%20Dashboard.png"/>
-</Frame>
-
-Portkey provides built-in dashboards that help you:
-
-- Track cost and token usage across all crew runs
-- Analyze performance metrics like latency and success rates
-- Identify bottlenecks in your agent workflows
-- Compare different crew configurations and LLMs
-
-You can filter and segment all metrics by custom metadata to analyze specific crew types, user groups, or use cases.
-  </Tab>
-
-  <Tab title="Metadata Filtering">
-<Frame>
-  <img src="https://raw.githubusercontent.com/siddharthsambharia-portkey/Portkey-Product-Images/refs/heads/main/Metadata%20Filters%20from%20CrewAI.png" alt="Analytics with metadata filters" />
-</Frame>
-
-Add custom metadata to your CrewAI LLM configuration to enable powerful filtering and segmentation:
-
-```python
-portkey_llm = LLM(
-    model="gpt-4o",
-    base_url=PORTKEY_GATEWAY_URL,
-    api_key="dummy",
-    extra_headers=createHeaders(
-        api_key="YOUR_PORTKEY_API_KEY",
-        virtual_key="YOUR_OPENAI_VIRTUAL_KEY",
-        metadata={
-            "crew_type": "research_crew",
-            "environment": "production",
-            "_user": "user_123",   # Special _user field for user analytics
-            "request_source": "mobile_app"
-        }
-    )
-)
-```
-
-This metadata can be used to filter logs, traces, and metrics on the Portkey dashboard, allowing you to analyze specific crew runs, users, or environments.
-  </Tab>
-</Tabs>
-
-### 2. Reliability - Keep Your Crews Running Smoothly
-
-When running crews in production, things can go wrong - API rate limits, network issues, or provider outages. Portkey's reliability features ensure your agents keep running smoothly even when problems occur.
-
-It's simple to enable fallback in your CrewAI setup by using a Portkey Config:
-
-```python
-from crewai import LLM
-from portkey_ai import createHeaders, PORTKEY_GATEWAY_URL
-
-# Create LLM with fallback configuration
-portkey_llm = LLM(
-    model="gpt-4o",
-    max_tokens=1000,
-    base_url=PORTKEY_GATEWAY_URL,
-    api_key="dummy",
-    extra_headers=createHeaders(
-        api_key="YOUR_PORTKEY_API_KEY",
-        config={
-            "strategy": {
-                "mode": "fallback"
-            },
-            "targets": [
-                {
-                    "provider": "openai",
-                    "api_key": "YOUR_OPENAI_API_KEY",
-                    "override_params": {"model": "gpt-4o"}
-                },
-                {
-                    "provider": "anthropic",
-                    "api_key": "YOUR_ANTHROPIC_API_KEY",
-                    "override_params": {"model": "claude-3-opus-20240229"}
-                }
-            ]
-        }
-    )
-)
-
-# Use this LLM configuration with your agents
-```
-
-This configuration will automatically try Claude if the GPT-4o request fails, ensuring your crew can continue operating.
-
-<CardGroup cols="2">
-  <Card title="Automatic Retries" icon="rotate" href="https://portkey.ai/docs/product/ai-gateway/automatic-retries">
-    Handles temporary failures automatically. If an LLM call fails, Portkey will retry the same request for the specified number of times - perfect for rate limits or network blips.
-  </Card>
-  <Card title="Request Timeouts" icon="clock" href="https://portkey.ai/docs/product/ai-gateway/request-timeouts">
-    Prevent your agents from hanging. Set timeouts to ensure you get responses (or can fail gracefully) within your required timeframes.
-  </Card>
-  <Card title="Conditional Routing" icon="route" href="https://portkey.ai/docs/product/ai-gateway/conditional-routing">
-    Send different requests to different providers. Route complex reasoning to GPT-4, creative tasks to Claude, and quick responses to Gemini based on your needs.
-  </Card>
-  <Card title="Fallbacks" icon="shield" href="https://portkey.ai/docs/product/ai-gateway/fallbacks">
-    Keep running even if your primary provider fails. Automatically switch to backup providers to maintain availability.
-  </Card>
-  <Card title="Load Balancing" icon="scale-balanced" href="https://portkey.ai/docs/product/ai-gateway/load-balancing">
-    Spread requests across multiple API keys or providers. Great for high-volume crew operations and staying within rate limits.
-  </Card>
-</CardGroup>
-
-### 3. Prompting in CrewAI
-
-Portkey's Prompt Engineering Studio helps you create, manage, and optimize the prompts used in your CrewAI agents. Instead of hardcoding prompts or instructions, use Portkey's prompt rendering API to dynamically fetch and apply your versioned prompts.
-
-<Frame caption="Manage prompts in Portkey's Prompt Library">
-![Prompt Playground Interface](https://raw.githubusercontent.com/siddharthsambharia-portkey/Portkey-Product-Images/refs/heads/main/CrewAI%20Portkey%20Docs.webp)
-</Frame>
-
-<Tabs>
-  <Tab title="Prompt Playground">
-Prompt Playground is a place to compare, test and deploy perfect prompts for your AI application. It's where you experiment with different models, test variables, compare outputs, and refine your prompt engineering strategy before deploying to production. It allows you to:
-
-1. Iteratively develop prompts before using them in your agents
-2. Test prompts with different variables and models
-3. Compare outputs between different prompt versions
-4. Collaborate with team members on prompt development
-
-This visual environment makes it easier to craft effective prompts for each step in your CrewAI agents' workflow.
-  </Tab>
-
-  <Tab title="Using Prompt Templates">
-The Prompt Render API retrieves your prompt templates with all parameters configured:
-
-```python
-from crewai import Agent, LLM
-from portkey_ai import createHeaders, PORTKEY_GATEWAY_URL, Portkey
-
-# Initialize Portkey admin client
-portkey_admin = Portkey(api_key="YOUR_PORTKEY_API_KEY")
-
-# Retrieve prompt using the render API
-prompt_data = portkey_client.prompts.render(
-    prompt_id="YOUR_PROMPT_ID",
-    variables={
-        "agent_role": "Senior Research Scientist",
-    }
-)
-
-backstory_agent_prompt=prompt_data.data.messages[0]["content"]
-
-
-# Set up LLM with Portkey integration
-portkey_llm = LLM(
-    model="gpt-4o",
-    base_url=PORTKEY_GATEWAY_URL,
-    api_key="dummy",
-    extra_headers=createHeaders(
-        api_key="YOUR_PORTKEY_API_KEY",
-        virtual_key="YOUR_OPENAI_VIRTUAL_KEY"
-    )
-)
-
-# Create agent using the rendered prompt
-researcher = Agent(
-    role="Senior Research Scientist",
-    goal="Discover groundbreaking insights about the assigned topic",
-    backstory=backstory_agent,  # Use the rendered prompt
-    verbose=True,
-    llm=portkey_llm
-)
-```
-  </Tab>
-
-  <Tab title="Prompt Versioning">
-You can:
-- Create multiple versions of the same prompt
-- Compare performance between versions
-- Roll back to previous versions if needed
-- Specify which version to use in your code:
-
-```python
-# Use a specific prompt version
-prompt_data = portkey_admin.prompts.render(
-    prompt_id="YOUR_PROMPT_ID@version_number",
-    variables={
-        "agent_role": "Senior Research Scientist",
-        "agent_goal": "Discover groundbreaking insights"
-    }
-)
-```
-  </Tab>
-
-  <Tab title="Mustache Templating for variables">
-Portkey prompts use Mustache-style templating for easy variable substitution:
-
-```
-You are a {{agent_role}} with expertise in {{domain}}.
-
-Your mission is to {{agent_goal}} by leveraging your knowledge
-and experience in the field.
-
-Always maintain a {{tone}} tone and focus on providing {{focus_area}}.
-```
-
-When rendering, simply pass the variables:
-
-```python
-prompt_data = portkey_admin.prompts.render(
-    prompt_id="YOUR_PROMPT_ID",
-    variables={
-        "agent_role": "Senior Research Scientist",
-        "domain": "artificial intelligence",
-        "agent_goal": "discover groundbreaking insights",
-        "tone": "professional",
-        "focus_area": "practical applications"
-    }
-)
-```
-  </Tab>
-</Tabs>
-
-<Card title="Prompt Engineering Studio" icon="wand-magic-sparkles" href="https://portkey.ai/docs/product/prompt-library">
-  Learn more about Portkey's prompt management features
-</Card>
-
-### 4. Guardrails for Safe Crews
-
-Guardrails ensure your CrewAI agents operate safely and respond appropriately in all situations.
-
-**Why Use Guardrails?**
-
-CrewAI agents can experience various failure modes:
-- Generating harmful or inappropriate content
-- Leaking sensitive information like PII
-- Hallucinating incorrect information
-- Generating outputs in incorrect formats
-
-Portkey's guardrails add protections for both inputs and outputs.
-
-**Implementing Guardrails**
-
-```python
-from crewai import Agent, LLM
-from portkey_ai import createHeaders, PORTKEY_GATEWAY_URL
-
-# Create LLM with guardrails
-portkey_llm = LLM(
-    model="gpt-4o",
-    base_url=PORTKEY_GATEWAY_URL,
-    api_key="dummy",
-    extra_headers=createHeaders(
-        api_key="YOUR_PORTKEY_API_KEY",
-        virtual_key="YOUR_OPENAI_VIRTUAL_KEY",
-        config={
-            "input_guardrails": ["guardrails-id-xxx", "guardrails-id-yyy"],
-            "output_guardrails": ["guardrails-id-zzz"]
-        }
-    )
-)
-
-# Create agent with guardrailed LLM
-researcher = Agent(
-    role="Senior Research Scientist",
-    goal="Discover groundbreaking insights about the assigned topic",
-    backstory="You are an expert researcher with deep domain knowledge.",
-    verbose=True,
-    llm=portkey_llm
-)
-```
-
-Portkey's guardrails can:
-- Detect and redact PII in both inputs and outputs
-- Filter harmful or inappropriate content
-- Validate response formats against schemas
-- Check for hallucinations against ground truth
-- Apply custom business logic and rules
-
-<Card title="Learn More About Guardrails" icon="shield-check" href="https://portkey.ai/docs/product/guardrails">
-  Explore Portkey's guardrail features to enhance agent safety
-</Card>
-
-### 5. User Tracking with Metadata
-
-Track individual users through your CrewAI agents using Portkey's metadata system.
-
-**What is Metadata in Portkey?**
-
-Metadata allows you to associate custom data with each request, enabling filtering, segmentation, and analytics. The special `_user` field is specifically designed for user tracking.
-
-```python
-from crewai import Agent, LLM
-from portkey_ai import createHeaders, PORTKEY_GATEWAY_URL
-
-# Configure LLM with user tracking
-portkey_llm = LLM(
-    model="gpt-4o",
-    base_url=PORTKEY_GATEWAY_URL,
-    api_key="dummy",
-    extra_headers=createHeaders(
-        api_key="YOUR_PORTKEY_API_KEY",
-        virtual_key="YOUR_OPENAI_VIRTUAL_KEY",
-        metadata={
-            "_user": "user_123",  # Special _user field for user analytics
-            "user_tier": "premium",
-            "user_company": "Acme Corp",
-            "session_id": "abc-123"
-        }
-    )
-)
-
-# Create agent with tracked LLM
-researcher = Agent(
-    role="Senior Research Scientist",
-    goal="Discover groundbreaking insights about the assigned topic",
-    backstory="You are an expert researcher with deep domain knowledge.",
-    verbose=True,
-    llm=portkey_llm
-)
-```
-
-**Filter Analytics by User**
-
-With metadata in place, you can filter analytics by user and analyze performance metrics on a per-user basis:
-
-<Frame caption="Filter analytics by user">
-  <img src="https://raw.githubusercontent.com/siddharthsambharia-portkey/Portkey-Product-Images/refs/heads/main/Metadata%20Filters%20from%20CrewAI.png"/>
-</Frame>
-
-This enables:
-- Per-user cost tracking and budgeting
-- Personalized user analytics
-- Team or organization-level metrics
-- Environment-specific monitoring (staging vs. production)
-
-<Card title="Learn More About Metadata" icon="tags" href="https://portkey.ai/docs/product/observability/metadata">
-  Explore how to use custom metadata to enhance your analytics
-</Card>
-
-### 6. Caching for Efficient Crews
-
-Implement caching to make your CrewAI agents more efficient and cost-effective:
-
-<Tabs>
-  <Tab title="Simple Caching">
-```python
-from crewai import Agent, LLM
-from portkey_ai import createHeaders, PORTKEY_GATEWAY_URL
-
-# Configure LLM with simple caching
-portkey_llm = LLM(
-    model="gpt-4o",
-    base_url=PORTKEY_GATEWAY_URL,
-    api_key="dummy",
-    extra_headers=createHeaders(
-        api_key="YOUR_PORTKEY_API_KEY",
-        virtual_key="YOUR_OPENAI_VIRTUAL_KEY",
-        config={
-            "cache": {
-                "mode": "simple"
-            }
-        }
-    )
-)
-
-# Create agent with cached LLM
-researcher = Agent(
-    role="Senior Research Scientist",
-    goal="Discover groundbreaking insights about the assigned topic",
-    backstory="You are an expert researcher with deep domain knowledge.",
-    verbose=True,
-    llm=portkey_llm
-)
-```
-
-Simple caching performs exact matches on input prompts, caching identical requests to avoid redundant model executions.
-  </Tab>
-
-  <Tab title="Semantic Caching">
-```python
-from crewai import Agent, LLM
-from portkey_ai import createHeaders, PORTKEY_GATEWAY_URL
-
-# Configure LLM with semantic caching
-portkey_llm = LLM(
-    model="gpt-4o",
-    base_url=PORTKEY_GATEWAY_URL,
-    api_key="dummy",
-    extra_headers=createHeaders(
-        api_key="YOUR_PORTKEY_API_KEY",
-        virtual_key="YOUR_OPENAI_VIRTUAL_KEY",
-        config={
-            "cache": {
-                "mode": "semantic"
-            }
-        }
-    )
-)
-
-# Create agent with semantically cached LLM
-researcher = Agent(
-    role="Senior Research Scientist",
-    goal="Discover groundbreaking insights about the assigned topic",
-    backstory="You are an expert researcher with deep domain knowledge.",
-    verbose=True,
-    llm=portkey_llm
-)
-```
-
-Semantic caching considers the contextual similarity between input requests, caching responses for semantically similar inputs.
-  </Tab>
-</Tabs>
-
-### 7. Model Interoperability
-
-CrewAI supports multiple LLM providers, and Portkey extends this capability by providing access to over 200 LLMs through a unified interface. You can easily switch between different models without changing your core agent logic:
-
-```python
-from crewai import Agent, LLM
-from portkey_ai import createHeaders, PORTKEY_GATEWAY_URL
-
-# Set up LLMs with different providers
-openai_llm = LLM(
-    model="gpt-4o",
-    base_url=PORTKEY_GATEWAY_URL,
-    api_key="dummy",
-    extra_headers=createHeaders(
-        api_key="YOUR_PORTKEY_API_KEY",
-        virtual_key="YOUR_OPENAI_VIRTUAL_KEY"
-    )
-)
-
+# Anthropic Configuration
 anthropic_llm = LLM(
     model="claude-3-5-sonnet-latest",
-    max_tokens=1000,
     base_url=PORTKEY_GATEWAY_URL,
     api_key="dummy",
     extra_headers=createHeaders(
         api_key="YOUR_PORTKEY_API_KEY",
-        virtual_key="YOUR_ANTHROPIC_VIRTUAL_KEY"
+        virtual_key="YOUR_ANTHROPIC_VIRTUAL_KEY", #You don't need provider when using Virtual keys
+        trace_id="anthropic_agent"
     )
 )
 
-# Choose which LLM to use for each agent based on your needs
-researcher = Agent(
-    role="Senior Research Scientist",
-    goal="Discover groundbreaking insights about the assigned topic",
-    backstory="You are an expert researcher with deep domain knowledge.",
-    verbose=True,
-    llm=openai_llm  # Use anthropic_llm for Anthropic
-)
-```
-
-Portkey provides access to LLMs from providers including:
-
-- OpenAI (GPT-4o, GPT-4 Turbo, etc.)
-- Anthropic (Claude 3.5 Sonnet, Claude 3 Opus, etc.)
-- Mistral AI (Mistral Large, Mistral Medium, etc.)
-- Google Vertex AI (Gemini 1.5 Pro, etc.)
-- Cohere (Command, Command-R, etc.)
-- AWS Bedrock (Claude, Titan, etc.)
-- Local/Private Models
-
-<Card title="Supported Providers" icon="server" href="https://portkey.ai/docs/integrations/llms">
-  See the full list of LLM providers supported by Portkey
-</Card>
-
-## Set Up Enterprise Governance for CrewAI
-
-**Why Enterprise Governance?**
-If you are using CrewAI inside your organization, you need to consider several governance aspects:
-- **Cost Management**: Controlling and tracking AI spending across teams
-- **Access Control**: Managing which teams can use specific models
-- **Usage Analytics**: Understanding how AI is being used across the organization
-- **Security & Compliance**: Maintaining enterprise security standards
-- **Reliability**: Ensuring consistent service across all users
-
-Portkey adds a comprehensive governance layer to address these enterprise needs. Let's implement these controls step by step.
-
-<Steps>
-<Step title="Create Virtual Key">
-Virtual Keys are Portkey's secure way to manage your LLM provider API keys. They provide essential controls like:
-- Budget limits for API usage
-- Rate limiting capabilities
-- Secure API key storage
-
-To create a virtual key:
-Go to [Virtual Keys](https://app.portkey.ai/virtual-keys) in the Portkey App. Save and copy the virtual key ID
-
-<Frame>
-<img src="https://raw.githubusercontent.com/siddharthsambharia-portkey/Portkey-Product-Images/refs/heads/main/Virtual%20Key%20from%20Portkey%20Docs.png" width="500"/>
-</Frame>
-
-<Note>
-Save your virtual key ID - you'll need it for the next step.
-</Note>
-</Step>
-
-<Step title="Create Default Config">
-Configs in Portkey define how your requests are routed, with features like advanced routing, fallbacks, and retries.
-
-To create your config:
-1. Go to [Configs](https://app.portkey.ai/configs) in Portkey dashboard
-2. Create new config with:
-    ```json
-    {
-        "virtual_key": "YOUR_VIRTUAL_KEY_FROM_STEP1",
-       	"override_params": {
-          "model": "gpt-4o" // Your preferred model name
-        }
-    }
-    ```
-3. Save and note the Config name for the next step
-
-<Frame>
-<img src="https://raw.githubusercontent.com/siddharthsambharia-portkey/Portkey-Product-Images/refs/heads/main/CrewAI%20Portkey%20Docs%20Config.png" width="500"/>
-
-</Frame>
-</Step>
-
-<Step title="Configure Portkey API Key">
-Now create a Portkey API key and attach the config you created in Step 2:
-
-1. Go to [API Keys](https://app.portkey.ai/api-keys) in Portkey and Create new API key
-2. Select your config from `Step 2`
-3. Generate and save your API key
-
-<Frame>
-<img src="https://raw.githubusercontent.com/siddharthsambharia-portkey/Portkey-Product-Images/refs/heads/main/CrewAI%20API%20Key.png" width="500"/>
-
-</Frame>
-</Step>
-
-<Step title="Connect to CrewAI">
-After setting up your Portkey API key with the attached config, connect it to your CrewAI agents:
-
-```python
-from crewai import Agent, LLM
-from portkey_ai import PORTKEY_GATEWAY_URL
-
-# Configure LLM with your API key
-portkey_llm = LLM(
-    model="gpt-4o",
+# Azure OpenAI Configuration
+azure_llm = LLM(
+    model="gpt-4",
     base_url=PORTKEY_GATEWAY_URL,
-    api_key="YOUR_PORTKEY_API_KEY"
-)
-
-# Create agent with Portkey-enabled LLM
-researcher = Agent(
-    role="Senior Research Scientist",
-    goal="Discover groundbreaking insights about the assigned topic",
-    backstory="You are an expert researcher with deep domain knowledge.",
-    verbose=True,
-    llm=portkey_llm
+    api_key="dummy",
+    extra_headers=createHeaders(
+        api_key="YOUR_PORTKEY_API_KEY",
+        virtual_key="YOUR_AZURE_VIRTUAL_KEY", #You don't need provider when using Virtual keys
+        trace_id="azure_agent"
+    )
 )
 ```
-</Step>
-</Steps>
 
-<AccordionGroup>
-  <Accordion title="Step 1: Implement Budget Controls & Rate Limits">
-### Step 1: Implement Budget Controls & Rate Limits
 
-Virtual Keys enable granular control over LLM access at the team/department level. This helps you:
-- Set up [budget limits](https://portkey.ai/docs/product/ai-gateway/virtual-keys/budget-limits)
-- Prevent unexpected usage spikes using Rate limits
-- Track departmental spending
+### 2. Caching
+Improve response times and reduce costs with two powerful caching modes:
+- **Simple Cache**: Perfect for exact matches
+- **Semantic Cache**: Matches responses for requests that are semantically similar
+[Learn more about Caching](https://portkey.ai/docs/product/ai-gateway/cache-simple-and-semantic)
 
-#### Setting Up Department-Specific Controls:
-1. Navigate to [Virtual Keys](https://app.portkey.ai/virtual-keys) in Portkey dashboard
-2. Create new Virtual Key for each department with budget limits and rate limits
-3. Configure department-specific limits
-
-<Frame>
-<img src="https://raw.githubusercontent.com/siddharthsambharia-portkey/Portkey-Product-Images/refs/heads/main/Virtual%20Key%20from%20Portkey%20Docs.png" width="500"/>
-</Frame>
-  </Accordion>
-
-  <Accordion title="Step 2: Define Model Access Rules">
-### Step 2: Define Model Access Rules
-
-As your AI usage scales, controlling which teams can access specific models becomes crucial. Portkey Configs provide this control layer with features like:
-
-#### Access Control Features:
-- **Model Restrictions**: Limit access to specific models
-- **Data Protection**: Implement guardrails for sensitive data
-- **Reliability Controls**: Add fallbacks and retry logic
-
-#### Example Configuration:
-Here's a basic configuration to route requests to OpenAI, specifically using GPT-4o:
-
-```json
-{
-	"strategy": {
-		"mode": "single"
-	},
-	"targets": [
-		{
-			"virtual_key": "YOUR_OPENAI_VIRTUAL_KEY",
-			"override_params": {
-				"model": "gpt-4o"
-			}
-		}
-	]
+```py
+config = {
+    "cache": {
+        "mode": "semantic",  # or "simple" for exact matching
+    }
 }
 ```
 
-  Create your config on the [Configs page](https://app.portkey.ai/configs) in your Portkey dashboard.
+### 3. Production Reliability
+Portkey provides comprehensive reliability features:
+- **Automatic Retries**: Handle temporary failures gracefully
+- **Request Timeouts**: Prevent hanging operations
+- **Conditional Routing**: Route requests based on specific conditions
+- **Fallbacks**: Set up automatic provider failovers
+- **Load Balancing**: Distribute requests efficiently
 
-    <Note>
-    Configs can be updated anytime to adjust controls without affecting running applications.
-    </Note>
-  </Accordion>
+[Learn more about Reliability Features](https://portkey.ai/docs/product/ai-gateway/)
 
-  <Accordion title="Step 3: Implement Access Controls">
-    ### Step 3: Implement Access Controls
 
-    Create User-specific API keys that automatically:
-    - Track usage per user/team with the help of virtual keys
-    - Apply appropriate configs to route requests
-    - Collect relevant metadata to filter logs
-    - Enforce access permissions
 
-    Create API keys through:
-    - [Portkey App](https://app.portkey.ai/)
-    - [API Key Management API](/api-reference/admin-api/control-plane/api-keys/create-api-key)
+### 4. Metrics
 
-    Example using Python SDK:
-    ```python
-    from portkey_ai import Portkey
+Agent runs are complex. Portkey automatically logs **40+ comprehensive metrics** for your AI agents, including cost, tokens used, latency, etc. Whether you need a broad overview or granular insights into your agent runs, Portkey's customizable filters provide the metrics you need.
 
-    portkey = Portkey(api_key="YOUR_ADMIN_API_KEY")
 
-    api_key = portkey.api_keys.create(
-        name="engineering-team",
-        type="organisation",
-        workspace_id="YOUR_WORKSPACE_ID",
-        defaults={
-            "config_id": "your-config-id",
-            "metadata": {
-                "environment": "production",
-                "department": "engineering"
-            }
-        },
-        scopes=["logs.view", "configs.read"]
-    )
-    ```
+- Cost per agent interaction
+- Response times and latency
+- Token usage and efficiency
+- Success/failure rates
+- Cache hit rates
 
-    For detailed key management instructions, see our [API Keys documentation](/api-reference/admin-api/control-plane/api-keys/create-api-key).
-  </Accordion>
+<img src="https://github.com/siddharthsambharia-portkey/Portkey-Product-Images/blob/main/Portkey-Dashboard.png?raw=true" width="70%" alt="Portkey Dashboard" />
 
-  <Accordion title="Step 4: Deploy & Monitor">
-    ### Step 4: Deploy & Monitor
-    After distributing API keys to your team members, your enterprise-ready CrewAI setup is ready to go. Each team member can now use their designated API keys with appropriate access levels and budget controls.
+### 5. Detailed Logging
+Logs are essential for understanding agent behavior, diagnosing issues, and improving performance. They provide a detailed record of agent activities and tool use, which is crucial for debugging and optimizing processes.
 
-    Monitor usage in Portkey dashboard:
-    - Cost tracking by department
-    - Model usage patterns
-    - Request volumes
-    - Error rates
-  </Accordion>
 
-</AccordionGroup>
+Access a dedicated section to view records of agent executions, including parameters, outcomes, function calls, and errors. Filter logs based on multiple parameters such as trace ID, model, tokens used, and metadata.
 
-<Note>
-### Enterprise Features Now Available
-**Your CrewAI integration now has:**
-- Departmental budget controls
-- Model access governance
-- Usage tracking & attribution
-- Security guardrails
-- Reliability features
-</Note>
+<details>
+  <summary><b>Traces</b></summary>
+  <img src="https://raw.githubusercontent.com/siddharthsambharia-portkey/Portkey-Product-Images/main/Portkey-Traces.png" alt="Portkey Traces" width="70%" />
+</details>
 
-## Frequently Asked Questions
+<details>
+  <summary><b>Logs</b></summary>
+  <img src="https://raw.githubusercontent.com/siddharthsambharia-portkey/Portkey-Product-Images/main/Portkey-Logs.png" alt="Portkey Logs" width="70%" />
+</details>
 
-<AccordionGroup>
-  <Accordion title="How does Portkey enhance CrewAI?">
-    Portkey adds production-readiness to CrewAI through comprehensive observability (traces, logs, metrics), reliability features (fallbacks, retries, caching), and access to 200+ LLMs through a unified interface. This makes it easier to debug, optimize, and scale your agent applications.
-  </Accordion>
+### 6. Enterprise Security Features
+- Set budget limit and rate limts per Virtual Key (disposable API keys)
+- Implement role-based access control
+- Track system changes with audit logs
+- Configure data retention policies
 
-  <Accordion title="Can I use Portkey with existing CrewAI applications?">
-    Yes! Portkey integrates seamlessly with existing CrewAI applications. You just need to update your LLM configuration code with the Portkey-enabled version. The rest of your agent and crew code remains unchanged.
-  </Accordion>
 
-  <Accordion title="Does Portkey work with all CrewAI features?">
-    Portkey supports all CrewAI features, including agents, tools, human-in-the-loop workflows, and all task process types (sequential, hierarchical, etc.). It adds observability and reliability without limiting any of the framework's functionality.
-  </Accordion>
 
-  <Accordion title="Can I track usage across multiple agents in a crew?">
-    Yes, Portkey allows you to use a consistent `trace_id` across multiple agents in a crew to track the entire workflow. This is especially useful for complex crews where you want to understand the full execution path across multiple agents.
-  </Accordion>
-
-  <Accordion title="How do I filter logs and traces for specific crew runs?">
-    Portkey allows you to add custom metadata to your LLM configuration, which you can then use for filtering. Add fields like `crew_name`, `crew_type`, or `session_id` to easily find and analyze specific crew executions.
-  </Accordion>
-
-  <Accordion title="Can I use my own API keys with Portkey?">
-    Yes! Portkey uses your own API keys for the various LLM providers. It securely stores them as virtual keys, allowing you to easily manage and rotate keys without changing your code.
-  </Accordion>
-
-</AccordionGroup>
+For detailed information on creating and managing Configs, visit the [Portkey documentation](https://docs.portkey.ai/product/ai-gateway/configs).
 
 ## Resources
 
-<CardGroup cols="3">
-  <Card title="CrewAI Docs" icon="book" href="https://docs.crewai.com/">
-    <p>Official CrewAI documentation</p>
-  </Card>
-  <Card title="Book a Demo" icon="calendar" href="https://calendly.com/portkey-ai">
-    <p>Get personalized guidance on implementing this integration</p>
-  </Card>
-</CardGroup>
+- [📘 Portkey Documentation](https://docs.portkey.ai)
+- [📊 Portkey Dashboard](https://app.portkey.ai/?utm_source=crewai&utm_medium=crewai&utm_campaign=crewai)
+- [🐦 Twitter](https://twitter.com/portkeyai)
+- [💬 Discord Community](https://discord.gg/DD7vgKK299)

pyproject.toml

@@ -3,7 +3,7 @@ name = "crewai"
 version = "0.121.1"
 description = "Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks."
 readme = "README.md"
-requires-python = ">=3.10,<3.14"
+requires-python = ">=3.10,<3.13"
 authors = [
     { name = "Joao Moura", email = "joao@crewai.com" }
 ]
@@ -21,9 +21,6 @@ dependencies = [
     "opentelemetry-sdk>=1.30.0",
     "opentelemetry-exporter-otlp-proto-http>=1.30.0",
     # Data Handling
-    "chromadb>=0.5.23",
-    "tokenizers>=0.20.3",
-    "onnxruntime==1.22.0",
     "openpyxl>=3.1.5",
     "pyvis>=0.3.2",
     # Authentication and Security
@@ -49,9 +46,13 @@ Repository = "https://github.com/crewAIInc/crewAI"
 [project.optional-dependencies]
 tools = ["crewai-tools~=0.45.0"]
 embeddings = [
-    "tiktoken~=0.8.0"
+    "tiktoken~=0.7.0"
+]
+storage = [
+    "chromadb>=0.5.23"
 ]
 agentops = ["agentops>=0.3.0"]
+fastembed = ["fastembed>=0.4.1"]
 pdfplumber = [
     "pdfplumber>=0.11.4",
 ]
@@ -101,27 +102,6 @@ exclude = ["cli/templates"]
 [tool.bandit]
 exclude_dirs = ["src/crewai/cli/templates"]
 
-# PyTorch index configuration, since torch 2.5.0 is not compatible with python 3.13
-[[tool.uv.index]]
-name = "pytorch-nightly"
-url = "https://download.pytorch.org/whl/nightly/cpu"
-explicit = true
-
-[[tool.uv.index]]
-name = "pytorch"
-url = "https://download.pytorch.org/whl/cpu"
-explicit = true
-
-[tool.uv.sources]
-torch = [
-  { index = "pytorch-nightly", marker = "python_version >= '3.13'" },
-  { index = "pytorch", marker = "python_version < '3.13'" },
-]
-torchvision = [
-  { index = "pytorch-nightly", marker = "python_version >= '3.13'" },
-  { index = "pytorch", marker = "python_version < '3.13'" },
-]
-
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"

src/crewai/agent.py

@@ -200,7 +200,6 @@ class Agent(BaseAgent):
                         collection_name=self.role,
                         storage=self.knowledge_storage or None,
                     )
-                    self.knowledge.add_sources()
         except (TypeError, ValueError) as e:
             raise ValueError(f"Invalid Knowledge Configuration: {str(e)}")
 
@@ -244,28 +243,21 @@ class Agent(BaseAgent):
         """
         if self.reasoning:
             try:
-                from crewai.utilities.reasoning_handler import (
-                    AgentReasoning,
-                    AgentReasoningOutput,
-                )
-
+                from crewai.utilities.reasoning_handler import AgentReasoning, AgentReasoningOutput
+                
                 reasoning_handler = AgentReasoning(task=task, agent=self)
-                reasoning_output: AgentReasoningOutput = (
-                    reasoning_handler.handle_agent_reasoning()
-                )
-
+                reasoning_output: AgentReasoningOutput = reasoning_handler.handle_agent_reasoning()
+                
                 # Add the reasoning plan to the task description
                 task.description += f"\n\nReasoning Plan:\n{reasoning_output.plan.plan}"
             except Exception as e:
-                if hasattr(self, "_logger"):
-                    self._logger.log(
-                        "error", f"Error during reasoning process: {str(e)}"
-                    )
+                if hasattr(self, '_logger'):
+                    self._logger.log("error", f"Error during reasoning process: {str(e)}")
                 else:
                     print(f"Error during reasoning process: {str(e)}")
-
+            
         self._inject_date_to_task(task)
-
+            
         if self.tools_handler:
             self.tools_handler.last_used_tool = {}  # type: ignore # Incompatible types in assignment (expression has type "dict[Never, Never]", variable has type "ToolCalling")
 
@@ -630,33 +622,22 @@ class Agent(BaseAgent):
         """Inject the current date into the task description if inject_date is enabled."""
         if self.inject_date:
             from datetime import datetime
-
             try:
-                valid_format_codes = [
-                    "%Y",
-                    "%m",
-                    "%d",
-                    "%H",
-                    "%M",
-                    "%S",
-                    "%B",
-                    "%b",
-                    "%A",
-                    "%a",
-                ]
+                valid_format_codes = ['%Y', '%m', '%d', '%H', '%M', '%S', '%B', '%b', '%A', '%a']
                 is_valid = any(code in self.date_format for code in valid_format_codes)
-
+                
                 if not is_valid:
                     raise ValueError(f"Invalid date format: {self.date_format}")
-
+                
                 current_date: str = datetime.now().strftime(self.date_format)
                 task.description += f"\n\nCurrent Date: {current_date}"
             except Exception as e:
-                if hasattr(self, "_logger"):
+                if hasattr(self, '_logger'):
                     self._logger.log("warning", f"Failed to inject date: {str(e)}")
                 else:
                     print(f"Warning: Failed to inject date: {str(e)}")
 
+
     def _validate_docker_installation(self) -> None:
         """Check if Docker is installed and running."""
         if not shutil.which("docker"):

src/crewai/cli/plus_api.py

@@ -1,5 +1,5 @@
 from os import getenv
-from typing import List, Optional
+from typing import Optional
 from urllib.parse import urljoin
 
 import requests
@@ -48,7 +48,6 @@ class PlusAPI:
         version: str,
         description: Optional[str],
         encoded_file: str,
-        available_exports: Optional[List[str]] = None,
     ):
         params = {
             "handle": handle,
@@ -56,7 +55,6 @@ class PlusAPI:
             "version": version,
             "file": encoded_file,
             "description": description,
-            "available_exports": available_exports,
         }
         return self._make_request("POST", f"{self.TOOLS_RESOURCE}", json=params)
 

src/crewai/cli/templates/crew/README.md

@@ -4,7 +4,7 @@ Welcome to the {{crew_name}} Crew project, powered by [crewAI](https://crewai.co
 
 ## Installation
 
-Ensure you have Python >=3.10 <3.14 installed on your system. This project uses [UV](https://docs.astral.sh/uv/) for dependency management and package handling, offering a seamless setup and execution experience.
+Ensure you have Python >=3.10 <3.13 installed on your system. This project uses [UV](https://docs.astral.sh/uv/) for dependency management and package handling, offering a seamless setup and execution experience.
 
 First, if you haven't already, install uv:
 

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

@@ -3,7 +3,7 @@ name = "{{folder_name}}"
 version = "0.1.0"
 description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
-requires-python = ">=3.10,<3.14"
+requires-python = ">=3.10,<3.13"
 dependencies = [
     "crewai[tools]>=0.121.1,<1.0.0"
 ]

src/crewai/cli/templates/flow/README.md

@@ -4,7 +4,7 @@ Welcome to the {{crew_name}} Crew project, powered by [crewAI](https://crewai.co
 
 ## Installation
 
-Ensure you have Python >=3.10 <3.14 installed on your system. This project uses [UV](https://docs.astral.sh/uv/) for dependency management and package handling, offering a seamless setup and execution experience.
+Ensure you have Python >=3.10 <3.13 installed on your system. This project uses [UV](https://docs.astral.sh/uv/) for dependency management and package handling, offering a seamless setup and execution experience.
 
 First, if you haven't already, install uv:
 

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

@@ -3,7 +3,7 @@ name = "{{folder_name}}"
 version = "0.1.0"
 description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
-requires-python = ">=3.10,<3.14"
+requires-python = ">=3.10,<3.13"
 dependencies = [
     "crewai[tools]>=0.121.1,<1.0.0",
 ]

src/crewai/cli/templates/tool/README.md

@@ -5,7 +5,7 @@ custom tools to power up your crews.
 
 ## Installing
 
-Ensure you have Python >=3.10 <3.14 installed on your system. This project
+Ensure you have Python >=3.10 <3.13 installed on your system. This project
 uses [UV](https://docs.astral.sh/uv/) for dependency management and package
 handling, offering a seamless setup and execution experience.
 

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

@@ -3,7 +3,7 @@ name = "{{folder_name}}"
 version = "0.1.0"
 description = "Power up your crews with {{folder_name}}"
 readme = "README.md"
-requires-python = ">=3.10,<3.14"
+requires-python = ">=3.10,<3.13"
 dependencies = [
     "crewai[tools]>=0.121.1"
 ]

src/crewai/cli/templates/tool/src/{{folder_name}}/__init__.py

@@ -1,3 +0,0 @@
-from .tool import {{class_name}}
-
-__all__ = ["{{class_name}}"]

src/crewai/cli/tools/main.py

@@ -3,7 +3,6 @@ import os
 import subprocess
 import tempfile
 from pathlib import Path
-from typing import Any
 
 import click
 from rich.console import Console
@@ -12,7 +11,6 @@ from crewai.cli import git
 from crewai.cli.command import BaseCommand, PlusAPIMixin
 from crewai.cli.config import Settings
 from crewai.cli.utils import (
-    extract_available_exports,
     get_project_description,
     get_project_name,
     get_project_version,
@@ -84,14 +82,6 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
         project_description = get_project_description(require=False)
         encoded_tarball = None
 
-        console.print("[bold blue]Discovering tools from your project...[/bold blue]")
-        available_exports = extract_available_exports()
-
-        if available_exports:
-            console.print(
-                f"[green]Found these tools to publish: {', '.join([e['name'] for e in available_exports])}[/green]"
-            )
-
         with tempfile.TemporaryDirectory() as temp_build_dir:
             subprocess.run(
                 ["uv", "build", "--sdist", "--out-dir", temp_build_dir],
@@ -115,14 +105,12 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
 
             encoded_tarball = base64.b64encode(tarball_contents).decode("utf-8")
 
-        console.print("[bold blue]Publishing tool to repository...[/bold blue]")
         publish_response = self.plus_api_client.publish_tool(
             handle=project_name,
             is_public=is_public,
             version=project_version,
             description=project_description,
             encoded_file=f"data:application/x-gzip;base64,{encoded_tarball}",
-            available_exports=available_exports,
         )
 
         self._validate_response(publish_response)
@@ -179,8 +167,7 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
             "Successfully authenticated to the tool repository.", style="bold green"
         )
 
-    def _add_package(self, tool_details: dict[str, Any]):
-        is_from_pypi = tool_details.get("source", None) == "pypi"
+    def _add_package(self, tool_details):
         tool_handle = tool_details["handle"]
         repository_handle = tool_details["repository"]["handle"]
         repository_url = tool_details["repository"]["url"]
@@ -189,13 +176,10 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
         add_package_command = [
             "uv",
             "add",
+            "--index",
+            index,
+            tool_handle,
         ]
-
-        if is_from_pypi:
-            add_package_command.append(tool_handle)
-        else:
-            add_package_command.extend(["--index", index, tool_handle])
-
         add_package_result = subprocess.run(
             add_package_command,
             capture_output=False,

src/crewai/cli/utils.py

@@ -1,10 +1,8 @@
-import importlib.util
 import os
 import shutil
 import sys
 from functools import reduce
-from inspect import getmro, isclass, isfunction, ismethod
-from pathlib import Path
+from inspect import isfunction, ismethod
 from typing import Any, Dict, List, get_type_hints
 
 import click
@@ -341,112 +339,3 @@ def fetch_crews(module_attr) -> list[Crew]:
             if crew_instance := get_crew_instance(attr):
                 crew_instances.append(crew_instance)
     return crew_instances
-
-
-def is_valid_tool(obj):
-    from crewai.tools.base_tool import Tool
-
-    if isclass(obj):
-        try:
-            return any(base.__name__ == "BaseTool" for base in getmro(obj))
-        except (TypeError, AttributeError):
-            return False
-
-    return isinstance(obj, Tool)
-
-
-def extract_available_exports(dir_path: str = "src"):
-    """
-    Extract available tool classes from the project's __init__.py files.
-    Only includes classes that inherit from BaseTool or functions decorated with @tool.
-
-    Returns:
-        list: A list of valid tool class names or ["BaseTool"] if none found
-    """
-    try:
-        init_files = Path(dir_path).glob("**/__init__.py")
-        available_exports = []
-
-        for init_file in init_files:
-            tools = _load_tools_from_init(init_file)
-            available_exports.extend(tools)
-
-        if not available_exports:
-            _print_no_tools_warning()
-            raise SystemExit(1)
-
-        return available_exports
-
-    except Exception as e:
-        console.print(f"[red]Error: Could not extract tool classes: {str(e)}[/red]")
-        console.print(
-            "Please ensure your project contains valid tools (classes inheriting from BaseTool or functions with @tool decorator)."
-        )
-        raise SystemExit(1)
-
-
-def _load_tools_from_init(init_file: Path) -> list[dict[str, Any]]:
-    """
-    Load and validate tools from a given __init__.py file.
-    """
-    spec = importlib.util.spec_from_file_location("temp_module", init_file)
-
-    if not spec or not spec.loader:
-        return []
-
-    module = importlib.util.module_from_spec(spec)
-    sys.modules["temp_module"] = module
-
-    try:
-        spec.loader.exec_module(module)
-
-        if not hasattr(module, "__all__"):
-            console.print(
-                f"[bold yellow]Warning: No __all__ defined in {init_file}[/bold yellow]"
-            )
-            raise SystemExit(1)
-
-        return [
-            {
-                "name": name,
-            }
-            for name in module.__all__
-            if hasattr(module, name) and is_valid_tool(getattr(module, name))
-        ]
-
-    except Exception as e:
-        console.print(f"[red]Warning: Could not load {init_file}: {str(e)}[/red]")
-        raise SystemExit(1)
-
-    finally:
-        sys.modules.pop("temp_module", None)
-
-
-def _print_no_tools_warning():
-    """
-    Display warning and usage instructions if no tools were found.
-    """
-    console.print(
-        "\n[bold yellow]Warning: No valid tools were exposed in your __init__.py file![/bold yellow]"
-    )
-    console.print(
-        "Your __init__.py file must contain all classes that inherit from [bold]BaseTool[/bold] "
-        "or functions decorated with [bold]@tool[/bold]."
-    )
-    console.print(
-        "\nExample:\n[dim]# In your __init__.py file[/dim]\n"
-        "[green]__all__ = ['YourTool', 'your_tool_function'][/green]\n\n"
-        "[dim]# In your tool.py file[/dim]\n"
-        "[green]from crewai.tools import BaseTool, tool\n\n"
-        "# Tool class example\n"
-        "class YourTool(BaseTool):\n"
-        '    name = "your_tool"\n'
-        '    description = "Your tool description"\n'
-        "    # ... rest of implementation\n\n"
-        "# Decorated function example\n"
-        "@tool\n"
-        "def your_tool_function(text: str) -> str:\n"
-        '    """Your tool description"""\n'
-        "    # ... implementation\n"
-        "    return result\n"
-    )

src/crewai/knowledge/embedder/fastembed.py

@@ -0,0 +1,93 @@
+from pathlib import Path
+from typing import List, Optional, Union
+
+import numpy as np
+
+from .base_embedder import BaseEmbedder
+
+try:
+    from fastembed_gpu import TextEmbedding  # type: ignore
+
+    FASTEMBED_AVAILABLE = True
+except ImportError:
+    try:
+        from fastembed import TextEmbedding
+
+        FASTEMBED_AVAILABLE = True
+    except ImportError:
+        FASTEMBED_AVAILABLE = False
+
+
+class FastEmbed(BaseEmbedder):
+    """
+    A wrapper class for text embedding models using FastEmbed
+    """
+
+    def __init__(
+        self,
+        model_name: str = "BAAI/bge-small-en-v1.5",
+        cache_dir: Optional[Union[str, Path]] = None,
+    ):
+        """
+        Initialize the embedding model
+
+        Args:
+            model_name: Name of the model to use
+            cache_dir: Directory to cache the model
+            gpu: Whether to use GPU acceleration
+        """
+        if not FASTEMBED_AVAILABLE:
+            raise ImportError(
+                "FastEmbed is not installed. Please install it with: "
+                "uv pip install fastembed or uv pip install fastembed-gpu for GPU support"
+            )
+
+        self.model = TextEmbedding(
+            model_name=model_name,
+            cache_dir=str(cache_dir) if cache_dir else None,
+        )
+
+    def embed_chunks(self, chunks: List[str]) -> List[np.ndarray]:
+        """
+        Generate embeddings for a list of text chunks
+
+        Args:
+            chunks: List of text chunks to embed
+
+        Returns:
+            List of embeddings
+        """
+        embeddings = list(self.model.embed(chunks))
+        return embeddings
+
+    def embed_texts(self, texts: List[str]) -> List[np.ndarray]:
+        """
+        Generate embeddings for a list of texts
+
+        Args:
+            texts: List of texts to embed
+
+        Returns:
+            List of embeddings
+        """
+        embeddings = list(self.model.embed(texts))
+        return embeddings
+
+    def embed_text(self, text: str) -> np.ndarray:
+        """
+        Generate embedding for a single text
+
+        Args:
+            text: Text to embed
+
+        Returns:
+            Embedding array
+        """
+        return self.embed_texts([text])[0]
+
+    @property
+    def dimension(self) -> int:
+        """Get the dimension of the embeddings"""
+        # Generate a test embedding to get dimensions
+        test_embed = self.embed_text("test")
+        return len(test_embed)

src/crewai/knowledge/storage/knowledge_storage.py

@@ -6,16 +6,25 @@ import os
 import shutil
 from typing import Any, Dict, List, Optional, Union
 
-import chromadb
-import chromadb.errors
-from chromadb.api import ClientAPI
-from chromadb.api.types import OneOrMany
-from chromadb.config import Settings
+try:
+    import chromadb
+    import chromadb.errors
+    from chromadb.api import ClientAPI
+    from chromadb.api.types import OneOrMany
+    from chromadb.config import Settings
+    HAS_CHROMADB = True
+except ImportError:
+    chromadb = None  # type: ignore
+    ClientAPI = Any  # type: ignore
+    OneOrMany = Any  # type: ignore
+    Settings = Any  # type: ignore
+    HAS_CHROMADB = False
 
 from crewai.knowledge.storage.base_knowledge_storage import BaseKnowledgeStorage
 from crewai.utilities import EmbeddingConfigurator
 from crewai.utilities.chromadb import sanitize_collection_name
 from crewai.utilities.constants import KNOWLEDGE_DIRECTORY
+from crewai.utilities.errors import ChromaDBRequiredError
 from crewai.utilities.logger import Logger
 from crewai.utilities.paths import db_storage_path
 
@@ -43,7 +52,7 @@ class KnowledgeStorage(BaseKnowledgeStorage):
     search efficiency.
     """
 
-    collection: Optional[chromadb.Collection] = None
+    collection: Optional[Any] = None  # type: ignore
     collection_name: Optional[str] = "knowledge"
     app: Optional[ClientAPI] = None
 
@@ -62,6 +71,9 @@ class KnowledgeStorage(BaseKnowledgeStorage):
         filter: Optional[dict] = None,
         score_threshold: float = 0.35,
     ) -> List[Dict[str, Any]]:
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("knowledge storage")
+            
         with suppress_logging():
             if self.collection:
                 fetched = self.collection.query(
@@ -84,48 +96,63 @@ class KnowledgeStorage(BaseKnowledgeStorage):
                 raise Exception("Collection not initialized")
 
     def initialize_knowledge_storage(self):
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("knowledge storage")
+            
         base_path = os.path.join(db_storage_path(), "knowledge")
-        chroma_client = chromadb.PersistentClient(
-            path=base_path,
-            settings=Settings(allow_reset=True),
-        )
-
-        self.app = chroma_client
-
         try:
-            collection_name = (
-                f"knowledge_{self.collection_name}"
-                if self.collection_name
-                else "knowledge"
-            )
-            if self.app:
-                self.collection = self.app.get_or_create_collection(
-                    name=sanitize_collection_name(collection_name),
-                    embedding_function=self.embedder,
-                )
-            else:
-                raise Exception("Vector Database Client not initialized")
-        except Exception:
-            raise Exception("Failed to create or get collection")
-
-    def reset(self):
-        base_path = os.path.join(db_storage_path(), KNOWLEDGE_DIRECTORY)
-        if not self.app:
-            self.app = chromadb.PersistentClient(
+            chroma_client = chromadb.PersistentClient(
                 path=base_path,
                 settings=Settings(allow_reset=True),
             )
 
-        self.app.reset()
-        shutil.rmtree(base_path)
-        self.app = None
-        self.collection = None
+            self.app = chroma_client
+
+            try:
+                collection_name = (
+                    f"knowledge_{self.collection_name}"
+                    if self.collection_name
+                    else "knowledge"
+                )
+                if self.app:
+                    self.collection = self.app.get_or_create_collection(
+                        name=sanitize_collection_name(collection_name),
+                        embedding_function=self.embedder,
+                    )
+                else:
+                    raise Exception("Vector Database Client not initialized")
+            except Exception:
+                raise Exception("Failed to create or get collection")
+        except ImportError:
+            raise ChromaDBRequiredError("knowledge storage")
+
+    def reset(self):
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("knowledge storage")
+            
+        base_path = os.path.join(db_storage_path(), KNOWLEDGE_DIRECTORY)
+        try:
+            if not self.app:
+                self.app = chromadb.PersistentClient(
+                    path=base_path,
+                    settings=Settings(allow_reset=True),
+                )
+
+            self.app.reset()
+            shutil.rmtree(base_path)
+            self.app = None
+            self.collection = None
+        except ImportError:
+            raise ChromaDBRequiredError("knowledge storage")
 
     def save(
         self,
         documents: List[str],
         metadata: Optional[Union[Dict[str, Any], List[Dict[str, Any]]]] = None,
     ):
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("knowledge storage")
+            
         if not self.collection:
             raise Exception("Collection not initialized")
 
@@ -156,7 +183,7 @@ class KnowledgeStorage(BaseKnowledgeStorage):
                 filtered_ids.append(doc_id)
 
             # If we have no metadata at all, set it to None
-            final_metadata: Optional[OneOrMany[chromadb.Metadata]] = (
+            final_metadata: Optional[OneOrMany[Any]] = (
                 None if all(m is None for m in filtered_metadata) else filtered_metadata
             )
 
@@ -165,29 +192,38 @@ class KnowledgeStorage(BaseKnowledgeStorage):
                 metadatas=final_metadata,
                 ids=filtered_ids,
             )
-        except chromadb.errors.InvalidDimensionException as e:
-            Logger(verbose=True).log(
-                "error",
-                "Embedding dimension mismatch. This usually happens when mixing different embedding models. Try resetting the collection using `crewai reset-memories -a`",
-                "red",
-            )
-            raise ValueError(
-                "Embedding dimension mismatch. Make sure you're using the same embedding model "
-                "across all operations with this collection."
-                "Try resetting the collection using `crewai reset-memories -a`"
-            ) from e
+        except ImportError:
+            raise ChromaDBRequiredError("knowledge storage")
         except Exception as e:
-            Logger(verbose=True).log("error", f"Failed to upsert documents: {e}", "red")
-            raise
+            if HAS_CHROMADB and isinstance(e, chromadb.errors.InvalidDimensionException):
+                Logger(verbose=True).log(
+                    "error",
+                    "Embedding dimension mismatch. This usually happens when mixing different embedding models. Try resetting the collection using `crewai reset-memories -a`",
+                    "red",
+                )
+                raise ValueError(
+                    "Embedding dimension mismatch. Make sure you're using the same embedding model "
+                    "across all operations with this collection."
+                    "Try resetting the collection using `crewai reset-memories -a`"
+                ) from e
+            else:
+                Logger(verbose=True).log("error", f"Failed to upsert documents: {e}", "red")
+                raise
 
     def _create_default_embedding_function(self):
-        from chromadb.utils.embedding_functions.openai_embedding_function import (
-            OpenAIEmbeddingFunction,
-        )
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("knowledge storage")
+            
+        try:
+            from chromadb.utils.embedding_functions.openai_embedding_function import (
+                OpenAIEmbeddingFunction,
+            )
 
-        return OpenAIEmbeddingFunction(
-            api_key=os.getenv("OPENAI_API_KEY"), model_name="text-embedding-3-small"
-        )
+            return OpenAIEmbeddingFunction(
+                api_key=os.getenv("OPENAI_API_KEY"), model_name="text-embedding-3-small"
+            )
+        except ImportError:
+            raise ChromaDBRequiredError("knowledge storage")
 
     def _set_embedder_config(self, embedder: Optional[Dict[str, Any]] = None) -> None:
         """Set the embedding configuration for the knowledge storage.

src/crewai/memory/storage/rag_storage.py

@@ -6,11 +6,17 @@ import shutil
 import uuid
 from typing import Any, Dict, List, Optional
 
-from chromadb.api import ClientAPI
+try:
+    from chromadb.api import ClientAPI
+    HAS_CHROMADB = True
+except ImportError:
+    ClientAPI = Any  # type: ignore
+    HAS_CHROMADB = False
 
 from crewai.memory.storage.base_rag_storage import BaseRAGStorage
 from crewai.utilities import EmbeddingConfigurator
 from crewai.utilities.constants import MAX_FILE_NAME_LENGTH
+from crewai.utilities.errors import ChromaDBRequiredError
 from crewai.utilities.paths import db_storage_path
 
 
@@ -60,26 +66,32 @@ class RAGStorage(BaseRAGStorage):
         self.embedder_config = configurator.configure_embedder(self.embedder_config)
 
     def _initialize_app(self):
-        import chromadb
-        from chromadb.config import Settings
-
-        self._set_embedder_config()
-        chroma_client = chromadb.PersistentClient(
-            path=self.path if self.path else self.storage_file_name,
-            settings=Settings(allow_reset=self.allow_reset),
-        )
-
-        self.app = chroma_client
-
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("memory storage")
+            
         try:
-            self.collection = self.app.get_collection(
-                name=self.type, embedding_function=self.embedder_config
-            )
-        except Exception:
-            self.collection = self.app.create_collection(
-                name=self.type, embedding_function=self.embedder_config
+            import chromadb
+            from chromadb.config import Settings
+
+            self._set_embedder_config()
+            chroma_client = chromadb.PersistentClient(
+                path=self.path if self.path else self.storage_file_name,
+                settings=Settings(allow_reset=self.allow_reset),
             )
 
+            self.app = chroma_client
+
+            try:
+                self.collection = self.app.get_collection(
+                    name=self.type, embedding_function=self.embedder_config
+                )
+            except Exception:
+                self.collection = self.app.create_collection(
+                    name=self.type, embedding_function=self.embedder_config
+                )
+        except ImportError:
+            raise ChromaDBRequiredError("memory storage")
+
     def _sanitize_role(self, role: str) -> str:
         """
         Sanitizes agent roles to ensure valid directory names.
@@ -165,10 +177,16 @@ class RAGStorage(BaseRAGStorage):
                 )
 
     def _create_default_embedding_function(self):
-        from chromadb.utils.embedding_functions.openai_embedding_function import (
-            OpenAIEmbeddingFunction,
-        )
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("memory storage")
+            
+        try:
+            from chromadb.utils.embedding_functions.openai_embedding_function import (
+                OpenAIEmbeddingFunction,
+            )
 
-        return OpenAIEmbeddingFunction(
-            api_key=os.getenv("OPENAI_API_KEY"), model_name="text-embedding-3-small"
-        )
+            return OpenAIEmbeddingFunction(
+                api_key=os.getenv("OPENAI_API_KEY"), model_name="text-embedding-3-small"
+            )
+        except ImportError:
+            raise ChromaDBRequiredError("memory storage")

src/crewai/tools/__init__.py

@@ -1,7 +1 @@
-from .base_tool import BaseTool, tool, EnvVar
-
-__all__ = [
-    "BaseTool",
-    "tool",
-    "EnvVar",
-]
+from .base_tool import BaseTool, tool

src/crewai/tools/base_tool.py

@@ -1,7 +1,7 @@
 import asyncio
 from abc import ABC, abstractmethod
 from inspect import signature
-from typing import Any, Callable, Type, get_args, get_origin, Optional, List
+from typing import Any, Callable, Type, get_args, get_origin
 
 from pydantic import (
     BaseModel,
@@ -14,11 +14,6 @@ from pydantic import BaseModel as PydanticBaseModel
 
 from crewai.tools.structured_tool import CrewStructuredTool
 
-class EnvVar(BaseModel):
-    name: str
-    description: str
-    required: bool = True
-    default: Optional[str] = None
 
 class BaseTool(BaseModel, ABC):
     class _ArgsSchemaPlaceholder(PydanticBaseModel):
@@ -30,8 +25,6 @@ class BaseTool(BaseModel, ABC):
     """The unique name of the tool that clearly communicates its purpose."""
     description: str
     """Used to tell the model how/when/why to use the tool."""
-    env_vars: List[EnvVar] = []
-    """List of environment variables used by the tool."""
     args_schema: Type[PydanticBaseModel] = Field(
         default_factory=_ArgsSchemaPlaceholder, validate_default=True
     )

src/crewai/utilities/agent_utils.py

@@ -464,7 +464,7 @@ def load_agent_from_repository(from_repository: str) -> Dict[str, Any]:
                 attributes[key] = []
                 for tool in value:
                     try:
-                        module = importlib.import_module(tool["module"])
+                        module = importlib.import_module("crewai_tools")
                         tool_class = getattr(module, tool["name"])
                         attributes[key].append(tool_class())
                     except Exception as e:

src/crewai/utilities/embedding_configurator.py

@@ -1,8 +1,29 @@
 import os
-from typing import Any, Dict, Optional, cast
+from typing import Any, Dict, Optional, cast, Protocol, Sequence, TYPE_CHECKING, TypeVar, List, Union
 
-from chromadb import Documents, EmbeddingFunction, Embeddings
-from chromadb.api.types import validate_embedding_function
+from crewai.utilities.errors import ChromaDBRequiredError
+
+if TYPE_CHECKING:
+    from numpy import ndarray
+    from numpy import dtype, floating, signedinteger, unsignedinteger
+
+try:
+    from chromadb import Documents, EmbeddingFunction, Embeddings
+    from chromadb.api.types import validate_embedding_function
+    HAS_CHROMADB = True
+except ImportError:
+    HAS_CHROMADB = False
+    
+    Documents = List[str]  # type: ignore
+    Embeddings = List[List[float]]  # type: ignore
+    
+    class EmbeddingFunction(Protocol):  # type: ignore
+        """Protocol for embedding functions when ChromaDB is not available."""
+        def __call__(self, input: List[str]) -> List[List[float]]: ...
+    
+    def validate_embedding_function(func: Any) -> None:  # type: ignore
+        """Stub for validate_embedding_function when ChromaDB is not available."""
+        pass
 
 
 class EmbeddingConfigurator:
@@ -26,6 +47,9 @@ class EmbeddingConfigurator:
         embedder_config: Optional[Dict[str, Any]] = None,
     ) -> EmbeddingFunction:
         """Configures and returns an embedding function based on the provided config."""
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("embedding functionality")
+            
         if embedder_config is None:
             return self._create_default_embedding_function()
 
@@ -47,129 +71,189 @@ class EmbeddingConfigurator:
 
     @staticmethod
     def _create_default_embedding_function():
-        from chromadb.utils.embedding_functions.openai_embedding_function import (
-            OpenAIEmbeddingFunction,
-        )
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("embedding functionality")
+            
+        try:
+            from chromadb.utils.embedding_functions.openai_embedding_function import (
+                OpenAIEmbeddingFunction,
+            )
 
-        return OpenAIEmbeddingFunction(
-            api_key=os.getenv("OPENAI_API_KEY"), model_name="text-embedding-3-small"
-        )
+            return OpenAIEmbeddingFunction(
+                api_key=os.getenv("OPENAI_API_KEY"), model_name="text-embedding-3-small"
+            )
+        except ImportError:
+            raise ChromaDBRequiredError("embedding functionality")
 
     @staticmethod
     def _configure_openai(config, model_name):
-        from chromadb.utils.embedding_functions.openai_embedding_function import (
-            OpenAIEmbeddingFunction,
-        )
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("embedding functionality")
+            
+        try:
+            from chromadb.utils.embedding_functions.openai_embedding_function import (
+                OpenAIEmbeddingFunction,
+            )
 
-        return OpenAIEmbeddingFunction(
-            api_key=config.get("api_key") or os.getenv("OPENAI_API_KEY"),
-            model_name=model_name,
-            api_base=config.get("api_base", None),
-            api_type=config.get("api_type", None),
-            api_version=config.get("api_version", None),
-            default_headers=config.get("default_headers", None),
-            dimensions=config.get("dimensions", None),
-            deployment_id=config.get("deployment_id", None),
-            organization_id=config.get("organization_id", None),
-        )
+            return OpenAIEmbeddingFunction(
+                api_key=config.get("api_key") or os.getenv("OPENAI_API_KEY"),
+                model_name=model_name,
+                api_base=config.get("api_base", None),
+                api_type=config.get("api_type", None),
+                api_version=config.get("api_version", None),
+                default_headers=config.get("default_headers", None),
+                dimensions=config.get("dimensions", None),
+                deployment_id=config.get("deployment_id", None),
+                organization_id=config.get("organization_id", None),
+            )
+        except ImportError:
+            raise ChromaDBRequiredError("embedding functionality")
 
     @staticmethod
     def _configure_azure(config, model_name):
-        from chromadb.utils.embedding_functions.openai_embedding_function import (
-            OpenAIEmbeddingFunction,
-        )
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("embedding functionality")
+            
+        try:
+            from chromadb.utils.embedding_functions.openai_embedding_function import (
+                OpenAIEmbeddingFunction,
+            )
 
-        return OpenAIEmbeddingFunction(
-            api_key=config.get("api_key"),
-            api_base=config.get("api_base"),
-            api_type=config.get("api_type", "azure"),
-            api_version=config.get("api_version"),
-            model_name=model_name,
-            default_headers=config.get("default_headers"),
-            dimensions=config.get("dimensions"),
-            deployment_id=config.get("deployment_id"),
-            organization_id=config.get("organization_id"),
-        )
+            return OpenAIEmbeddingFunction(
+                api_key=config.get("api_key"),
+                api_base=config.get("api_base"),
+                api_type=config.get("api_type", "azure"),
+                api_version=config.get("api_version"),
+                model_name=model_name,
+                default_headers=config.get("default_headers"),
+                dimensions=config.get("dimensions"),
+                deployment_id=config.get("deployment_id"),
+                organization_id=config.get("organization_id"),
+            )
+        except ImportError:
+            raise ChromaDBRequiredError("embedding functionality")
 
     @staticmethod
     def _configure_ollama(config, model_name):
-        from chromadb.utils.embedding_functions.ollama_embedding_function import (
-            OllamaEmbeddingFunction,
-        )
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("embedding functionality")
+            
+        try:
+            from chromadb.utils.embedding_functions.ollama_embedding_function import (
+                OllamaEmbeddingFunction,
+            )
 
-        return OllamaEmbeddingFunction(
-            url=config.get("url", "http://localhost:11434/api/embeddings"),
-            model_name=model_name,
-        )
+            return OllamaEmbeddingFunction(
+                url=config.get("url", "http://localhost:11434/api/embeddings"),
+                model_name=model_name,
+            )
+        except ImportError:
+            raise ChromaDBRequiredError("embedding functionality")
 
     @staticmethod
     def _configure_vertexai(config, model_name):
-        from chromadb.utils.embedding_functions.google_embedding_function import (
-            GoogleVertexEmbeddingFunction,
-        )
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("embedding functionality")
+            
+        try:
+            from chromadb.utils.embedding_functions.google_embedding_function import (
+                GoogleVertexEmbeddingFunction,
+            )
 
-        return GoogleVertexEmbeddingFunction(
-            model_name=model_name,
-            api_key=config.get("api_key"),
-            project_id=config.get("project_id"),
-            region=config.get("region"),
-        )
+            return GoogleVertexEmbeddingFunction(
+                model_name=model_name,
+                api_key=config.get("api_key"),
+                project_id=config.get("project_id"),
+                region=config.get("region"),
+            )
+        except ImportError:
+            raise ChromaDBRequiredError("embedding functionality")
 
     @staticmethod
     def _configure_google(config, model_name):
-        from chromadb.utils.embedding_functions.google_embedding_function import (
-            GoogleGenerativeAiEmbeddingFunction,
-        )
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("embedding functionality")
+            
+        try:
+            from chromadb.utils.embedding_functions.google_embedding_function import (
+                GoogleGenerativeAiEmbeddingFunction,
+            )
 
-        return GoogleGenerativeAiEmbeddingFunction(
-            model_name=model_name,
-            api_key=config.get("api_key"),
-            task_type=config.get("task_type"),
-        )
+            return GoogleGenerativeAiEmbeddingFunction(
+                model_name=model_name,
+                api_key=config.get("api_key"),
+                task_type=config.get("task_type"),
+            )
+        except ImportError:
+            raise ChromaDBRequiredError("embedding functionality")
 
     @staticmethod
     def _configure_cohere(config, model_name):
-        from chromadb.utils.embedding_functions.cohere_embedding_function import (
-            CohereEmbeddingFunction,
-        )
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("embedding functionality")
+            
+        try:
+            from chromadb.utils.embedding_functions.cohere_embedding_function import (
+                CohereEmbeddingFunction,
+            )
 
-        return CohereEmbeddingFunction(
-            model_name=model_name,
-            api_key=config.get("api_key"),
-        )
+            return CohereEmbeddingFunction(
+                model_name=model_name,
+                api_key=config.get("api_key"),
+            )
+        except ImportError:
+            raise ChromaDBRequiredError("embedding functionality")
 
     @staticmethod
     def _configure_voyageai(config, model_name):
-        from chromadb.utils.embedding_functions.voyageai_embedding_function import (
-            VoyageAIEmbeddingFunction,
-        )
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("embedding functionality")
+            
+        try:
+            from chromadb.utils.embedding_functions.voyageai_embedding_function import (
+                VoyageAIEmbeddingFunction,
+            )
 
-        return VoyageAIEmbeddingFunction(
-            model_name=model_name,
-            api_key=config.get("api_key"),
-        )
+            return VoyageAIEmbeddingFunction(
+                model_name=model_name,
+                api_key=config.get("api_key"),
+            )
+        except ImportError:
+            raise ChromaDBRequiredError("embedding functionality")
 
     @staticmethod
     def _configure_bedrock(config, model_name):
-        from chromadb.utils.embedding_functions.amazon_bedrock_embedding_function import (
-            AmazonBedrockEmbeddingFunction,
-        )
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("embedding functionality")
+            
+        try:
+            from chromadb.utils.embedding_functions.amazon_bedrock_embedding_function import (
+                AmazonBedrockEmbeddingFunction,
+            )
 
-        # Allow custom model_name override with backwards compatibility
-        kwargs = {"session": config.get("session")}
-        if model_name is not None:
-            kwargs["model_name"] = model_name
-        return AmazonBedrockEmbeddingFunction(**kwargs)
+            # Allow custom model_name override with backwards compatibility
+            kwargs = {"session": config.get("session")}
+            if model_name is not None:
+                kwargs["model_name"] = model_name
+            return AmazonBedrockEmbeddingFunction(**kwargs)
+        except ImportError:
+            raise ChromaDBRequiredError("embedding functionality")
 
     @staticmethod
     def _configure_huggingface(config, model_name):
-        from chromadb.utils.embedding_functions.huggingface_embedding_function import (
-            HuggingFaceEmbeddingServer,
-        )
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("embedding functionality")
+            
+        try:
+            from chromadb.utils.embedding_functions.huggingface_embedding_function import (
+                HuggingFaceEmbeddingServer,
+            )
 
-        return HuggingFaceEmbeddingServer(
-            url=config.get("api_url"),
-        )
+            return HuggingFaceEmbeddingServer(
+                url=config.get("api_url"),
+            )
+        except ImportError:
+            raise ChromaDBRequiredError("embedding functionality")
 
     @staticmethod
     def _configure_watson(config, model_name):
@@ -182,7 +266,7 @@ class EmbeddingConfigurator:
                 "IBM Watson dependencies are not installed. Please install them to use Watson embedding."
             ) from e
 
-        class WatsonEmbeddingFunction(EmbeddingFunction):
+        class WatsonEmbeddingFunction:
             def __call__(self, input: Documents) -> Embeddings:
                 if isinstance(input, str):
                     input = [input]
@@ -212,6 +296,9 @@ class EmbeddingConfigurator:
 
     @staticmethod
     def _configure_custom(config):
+        if not HAS_CHROMADB:
+            raise ChromaDBRequiredError("embedding functionality")
+            
         custom_embedder = config.get("embedder")
         if isinstance(custom_embedder, EmbeddingFunction):
             try:

src/crewai/utilities/errors/__init__.py

@@ -0,0 +1,62 @@
+"""Custom error classes for CrewAI."""
+
+from typing import Optional
+
+
+class ChromaDBRequiredError(ImportError):
+    """Error raised when ChromaDB is required but not installed."""
+    
+    def __init__(self, feature: str):
+        """Initialize the error with a specific feature name.
+        
+        Args:
+            feature: The name of the feature that requires ChromaDB.
+        """
+        message = (
+            f"ChromaDB is required for {feature} features. "
+            "Please install it with 'pip install crewai[storage]'"
+        )
+        super().__init__(message)
+
+
+class DatabaseOperationError(Exception):
+    """Base exception class for database operation errors."""
+
+    def __init__(self, message: str, original_error: Optional[Exception] = None):
+        """Initialize the database operation error.
+
+        Args:
+            message: The error message to display
+            original_error: The original exception that caused this error, if any
+        """
+        super().__init__(message)
+        self.original_error = original_error
+
+
+class DatabaseError:
+    """Standardized error message templates for database operations."""
+
+    INIT_ERROR: str = "Database initialization error: {}"
+    SAVE_ERROR: str = "Error saving task outputs: {}"
+    UPDATE_ERROR: str = "Error updating task outputs: {}"
+    LOAD_ERROR: str = "Error loading task outputs: {}"
+    DELETE_ERROR: str = "Error deleting task outputs: {}"
+
+    @classmethod
+    def format_error(cls, template: str, error: Exception) -> str:
+        """Format an error message with the given template and error.
+
+        Args:
+            template: The error message template to use
+            error: The exception to format into the template
+
+        Returns:
+            The formatted error message
+        """
+        return template.format(str(error))
+
+
+class AgentRepositoryError(Exception):
+    """Exception raised when an agent repository is not found."""
+
+    ...

tests/agent_test.py

@@ -309,9 +309,7 @@ def test_cache_hitting():
     def handle_tool_end(source, event):
         received_events.append(event)
 
-    with (
-        patch.object(CacheHandler, "read") as read,
-    ):
+    with (patch.object(CacheHandler, "read") as read,):
         read.return_value = "0"
         task = Task(
             description="What is 2 times 6? Ignore correctness and just return the result of the multiplication tool, you must use the tool.",
@@ -1630,13 +1628,13 @@ def test_agent_execute_task_with_ollama():
 
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_agent_with_knowledge_sources():
+    # Create a knowledge source with some content
     content = "Brandon's favorite color is red and he likes Mexican food."
     string_source = StringKnowledgeSource(content=content)
     with patch("crewai.knowledge") as MockKnowledge:
         mock_knowledge_instance = MockKnowledge.return_value
         mock_knowledge_instance.sources = [string_source]
         mock_knowledge_instance.search.return_value = [{"content": content}]
-        MockKnowledge.add_sources.return_value = [string_source]
 
         agent = Agent(
             role="Information Agent",
@@ -1646,6 +1644,7 @@ def test_agent_with_knowledge_sources():
             knowledge_sources=[string_source],
         )
 
+        # Create a task that requires the agent to use the knowledge
         task = Task(
             description="What is Brandon's favorite color?",
             expected_output="Brandon's favorite color.",
@@ -1653,11 +1652,10 @@ def test_agent_with_knowledge_sources():
         )
 
         crew = Crew(agents=[agent], tasks=[task])
-        with patch.object(Knowledge, "add_sources") as mock_add_sources:
-            result = crew.kickoff()
-            assert mock_add_sources.called, "add_sources() should have been called"
-            mock_add_sources.assert_called_once()
-            assert "red" in result.raw.lower()
+        result = crew.kickoff()
+
+        # Assert that the agent provides the correct information
+        assert "red" in result.raw.lower()
 
 
 @pytest.mark.vcr(filter_headers=["authorization"])
@@ -2038,7 +2036,7 @@ def mock_get_auth_token():
 
 @patch("crewai.cli.plus_api.PlusAPI.get_agent")
 def test_agent_from_repository(mock_get_agent, mock_get_auth_token):
-    from crewai_tools import SerperDevTool, XMLSearchTool
+    from crewai_tools import SerperDevTool
 
     mock_get_response = MagicMock()
     mock_get_response.status_code = 200
@@ -2046,10 +2044,7 @@ def test_agent_from_repository(mock_get_agent, mock_get_auth_token):
         "role": "test role",
         "goal": "test goal",
         "backstory": "test backstory",
-        "tools": [
-            {"module": "crewai_tools", "name": "SerperDevTool"},
-            {"module": "crewai_tools", "name": "XMLSearchTool"},
-        ],
+        "tools": [{"name": "SerperDevTool"}],
     }
     mock_get_agent.return_value = mock_get_response
     agent = Agent(from_repository="test_agent")
@@ -2057,9 +2052,8 @@ def test_agent_from_repository(mock_get_agent, mock_get_auth_token):
     assert agent.role == "test role"
     assert agent.goal == "test goal"
     assert agent.backstory == "test backstory"
-    assert len(agent.tools) == 2
+    assert len(agent.tools) == 1
     assert isinstance(agent.tools[0], SerperDevTool)
-    assert isinstance(agent.tools[1], XMLSearchTool)
 
 
 @patch("crewai.cli.plus_api.PlusAPI.get_agent")
@@ -2072,7 +2066,7 @@ def test_agent_from_repository_override_attributes(mock_get_agent, mock_get_auth
         "role": "test role",
         "goal": "test goal",
         "backstory": "test backstory",
-        "tools": [{"name": "SerperDevTool", "module": "crewai_tools"}],
+        "tools": [{"name": "SerperDevTool"}],
     }
     mock_get_agent.return_value = mock_get_response
     agent = Agent(from_repository="test_agent", role="Custom Role")
@@ -2092,7 +2086,7 @@ def test_agent_from_repository_with_invalid_tools(mock_get_agent, mock_get_auth_
         "role": "test role",
         "goal": "test goal",
         "backstory": "test backstory",
-        "tools": [{"name": "DoesNotExist", "module": "crewai_tools",}],
+        "tools": [{"name": "DoesNotExist"}],
     }
     mock_get_agent.return_value = mock_get_response
     with pytest.raises(

tests/cli/deploy/test_deploy_main.py

@@ -231,7 +231,7 @@ class TestDeployCommand(unittest.TestCase):
         [project]
         name = "test_project"
         version = "0.1.0"
-        requires-python = ">=3.10,<3.14"
+        requires-python = ">=3.10,<3.13"
         dependencies = ["crewai"]
         """,
     )
@@ -250,7 +250,7 @@ class TestDeployCommand(unittest.TestCase):
     [project]
     name = "test_project"
     version = "0.1.0"
-    requires-python = ">=3.10,<3.14"
+    requires-python = ">=3.10,<3.13"
     dependencies = ["crewai"]
     """,
     )

tests/cli/test_plus_api.py

@@ -61,7 +61,6 @@ class TestPlusAPI(unittest.TestCase):
             "version": version,
             "file": encoded_file,
             "description": description,
-            "available_exports": None,
         }
         mock_make_request.assert_called_once_with(
             "POST", "/crewai_plus/api/v1/tools", json=params
@@ -88,7 +87,6 @@ class TestPlusAPI(unittest.TestCase):
             "version": version,
             "file": encoded_file,
             "description": description,
-            "available_exports": None,
         }
         mock_make_request.assert_called_once_with(
             "POST", "/crewai_plus/api/v1/tools", json=params

tests/cli/test_utils.py

@@ -1,7 +1,6 @@
 import os
 import shutil
 import tempfile
-from pathlib import Path
 
 import pytest
 
@@ -101,163 +100,3 @@ def test_tree_copy_to_existing_directory(temp_tree):
         assert os.path.isfile(os.path.join(dest_dir, "file1.txt"))
     finally:
         shutil.rmtree(dest_dir)
-
-
-@pytest.fixture
-def temp_project_dir():
-    """Create a temporary directory for testing tool extraction."""
-    with tempfile.TemporaryDirectory() as temp_dir:
-        yield Path(temp_dir)
-
-
-def create_init_file(directory, content):
-    return create_file(directory / "__init__.py", content)
-
-
-def test_extract_available_exports_empty_project(temp_project_dir, capsys):
-    with pytest.raises(SystemExit):
-        utils.extract_available_exports(dir_path=temp_project_dir)
-    captured = capsys.readouterr()
-
-    assert "No valid tools were exposed in your __init__.py file" in captured.out
-
-
-def test_extract_available_exports_no_init_file(temp_project_dir, capsys):
-    (temp_project_dir / "some_file.py").write_text("print('hello')")
-    with pytest.raises(SystemExit):
-        utils.extract_available_exports(dir_path=temp_project_dir)
-    captured = capsys.readouterr()
-
-    assert "No valid tools were exposed in your __init__.py file" in captured.out
-
-
-def test_extract_available_exports_empty_init_file(temp_project_dir, capsys):
-    create_init_file(temp_project_dir, "")
-    with pytest.raises(SystemExit):
-        utils.extract_available_exports(dir_path=temp_project_dir)
-    captured = capsys.readouterr()
-
-    assert "Warning: No __all__ defined in" in captured.out
-
-
-def test_extract_available_exports_no_all_variable(temp_project_dir, capsys):
-    create_init_file(
-        temp_project_dir,
-        "from crewai.tools import BaseTool\n\nclass MyTool(BaseTool):\n    pass",
-    )
-    with pytest.raises(SystemExit):
-        utils.extract_available_exports(dir_path=temp_project_dir)
-    captured = capsys.readouterr()
-
-    assert "Warning: No __all__ defined in" in captured.out
-
-
-def test_extract_available_exports_valid_base_tool_class(temp_project_dir):
-    create_init_file(
-        temp_project_dir,
-        """from crewai.tools import BaseTool
-
-class MyTool(BaseTool):
-    name: str = "my_tool"
-    description: str = "A test tool"
-
-__all__ = ['MyTool']
-""",
-    )
-    tools = utils.extract_available_exports(dir_path=temp_project_dir)
-    assert [{"name": "MyTool"}] == tools
-
-
-def test_extract_available_exports_valid_tool_decorator(temp_project_dir):
-    create_init_file(
-        temp_project_dir,
-        """from crewai.tools import tool
-
-@tool
-def my_tool_function(text: str) -> str:
-    \"\"\"A test tool function\"\"\"
-    return text
-
-__all__ = ['my_tool_function']
-""",
-    )
-    tools = utils.extract_available_exports(dir_path=temp_project_dir)
-    assert [{"name": "my_tool_function"}] == tools
-
-
-def test_extract_available_exports_multiple_valid_tools(temp_project_dir):
-    create_init_file(
-        temp_project_dir,
-        """from crewai.tools import BaseTool, tool
-
-class MyTool(BaseTool):
-    name: str = "my_tool"
-    description: str = "A test tool"
-
-@tool
-def my_tool_function(text: str) -> str:
-    \"\"\"A test tool function\"\"\"
-    return text
-
-__all__ = ['MyTool', 'my_tool_function']
-""",
-    )
-    tools = utils.extract_available_exports(dir_path=temp_project_dir)
-    assert [{"name": "MyTool"}, {"name": "my_tool_function"}] == tools
-
-
-def test_extract_available_exports_with_invalid_tool_decorator(temp_project_dir):
-    create_init_file(
-        temp_project_dir,
-        """from crewai.tools import BaseTool
-
-class MyTool(BaseTool):
-    name: str = "my_tool"
-    description: str = "A test tool"
-
-def not_a_tool():
-    pass
-
-__all__ = ['MyTool', 'not_a_tool']
-""",
-    )
-    tools = utils.extract_available_exports(dir_path=temp_project_dir)
-    assert [{"name": "MyTool"}] == tools
-
-
-def test_extract_available_exports_import_error(temp_project_dir, capsys):
-    create_init_file(
-        temp_project_dir,
-        """from nonexistent_module import something
-
-class MyTool(BaseTool):
-    pass
-
-__all__ = ['MyTool']
-""",
-    )
-    with pytest.raises(SystemExit):
-        utils.extract_available_exports(dir_path=temp_project_dir)
-    captured = capsys.readouterr()
-
-    assert "nonexistent_module" in captured.out
-
-
-def test_extract_available_exports_syntax_error(temp_project_dir, capsys):
-    create_init_file(
-        temp_project_dir,
-        """from crewai.tools import BaseTool
-
-class MyTool(BaseTool):
-    # Missing closing parenthesis
-    def __init__(self, name:
-        pass
-
-__all__ = ['MyTool']
-""",
-    )
-    with pytest.raises(SystemExit):
-        utils.extract_available_exports(dir_path=temp_project_dir)
-    captured = capsys.readouterr()
-
-    assert "was never closed" in captured.out

tests/cli/tools/test_main.py

@@ -85,36 +85,6 @@ def test_install_success(mock_get, mock_subprocess_run, capsys, tool_command):
         env=unittest.mock.ANY,
     )
 
-@patch("crewai.cli.tools.main.subprocess.run")
-@patch("crewai.cli.plus_api.PlusAPI.get_tool")
-def test_install_success_from_pypi(mock_get, mock_subprocess_run, capsys, tool_command):
-    mock_get_response = MagicMock()
-    mock_get_response.status_code = 200
-    mock_get_response.json.return_value = {
-        "handle": "sample-tool",
-        "repository": {"handle": "sample-repo", "url": "https://example.com/repo"},
-        "source": "pypi",
-    }
-    mock_get.return_value = mock_get_response
-    mock_subprocess_run.return_value = MagicMock(stderr=None)
-
-    tool_command.install("sample-tool")
-    output = capsys.readouterr().out
-    assert "Successfully installed sample-tool" in output
-
-    mock_get.assert_has_calls([mock.call("sample-tool"), mock.call().json()])
-    mock_subprocess_run.assert_any_call(
-        [
-            "uv",
-            "add",
-            "sample-tool",
-        ],
-        capture_output=False,
-        text=True,
-        check=True,
-        env=unittest.mock.ANY,
-    )
-
 
 @patch("crewai.cli.plus_api.PlusAPI.get_tool")
 def test_install_tool_not_found(mock_get, capsys, tool_command):
@@ -165,9 +135,7 @@ def test_publish_when_not_in_sync(mock_is_synced, capsys, tool_command):
 )
 @patch("crewai.cli.plus_api.PlusAPI.publish_tool")
 @patch("crewai.cli.tools.main.git.Repository.is_synced", return_value=False)
-@patch("crewai.cli.tools.main.extract_available_exports", return_value=[{"name": "SampleTool"}])
 def test_publish_when_not_in_sync_and_force(
-    mock_available_exports,
     mock_is_synced,
     mock_publish,
     mock_open,
@@ -200,7 +168,6 @@ def test_publish_when_not_in_sync_and_force(
         version="1.0.0",
         description="A sample tool",
         encoded_file=unittest.mock.ANY,
-        available_exports=[{"name": "SampleTool"}],
     )
 
 
@@ -216,9 +183,7 @@ def test_publish_when_not_in_sync_and_force(
 )
 @patch("crewai.cli.plus_api.PlusAPI.publish_tool")
 @patch("crewai.cli.tools.main.git.Repository.is_synced", return_value=True)
-@patch("crewai.cli.tools.main.extract_available_exports", return_value=[{"name": "SampleTool"}])
 def test_publish_success(
-    mock_available_exports,
     mock_is_synced,
     mock_publish,
     mock_open,
@@ -251,7 +216,6 @@ def test_publish_success(
         version="1.0.0",
         description="A sample tool",
         encoded_file=unittest.mock.ANY,
-        available_exports=[{"name": "SampleTool"}],
     )
 
 
@@ -266,9 +230,7 @@ def test_publish_success(
     read_data=b"sample tarball content",
 )
 @patch("crewai.cli.plus_api.PlusAPI.publish_tool")
-@patch("crewai.cli.tools.main.extract_available_exports", return_value=[{"name": "SampleTool"}])
 def test_publish_failure(
-    mock_available_exports,
     mock_publish,
     mock_open,
     mock_listdir,
@@ -304,9 +266,7 @@ def test_publish_failure(
     read_data=b"sample tarball content",
 )
 @patch("crewai.cli.plus_api.PlusAPI.publish_tool")
-@patch("crewai.cli.tools.main.extract_available_exports", return_value=[{"name": "SampleTool"}])
 def test_publish_api_error(
-    mock_available_exports,
     mock_publish,
     mock_open,
     mock_listdir,

tests/crew_test.py

@@ -2384,6 +2384,16 @@ def test_multiple_conditional_tasks(researcher, writer):
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_using_contextual_memory():
     from unittest.mock import patch
+    
+    # Check if ChromaDB is available
+    try:
+        import chromadb  # noqa: F401
+        HAS_CHROMADB = True
+    except ImportError:
+        HAS_CHROMADB = False
+        
+    if not HAS_CHROMADB:
+        pytest.skip("ChromaDB is required for this test")
 
     math_researcher = Agent(
         role="Researcher",
@@ -2412,6 +2422,16 @@ def test_using_contextual_memory():
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_using_contextual_memory_with_long_term_memory():
     from unittest.mock import patch
+    
+    # Check if ChromaDB is available
+    try:
+        import chromadb  # noqa: F401
+        HAS_CHROMADB = True
+    except ImportError:
+        HAS_CHROMADB = False
+        
+    if not HAS_CHROMADB:
+        pytest.skip("ChromaDB is required for this test")
 
     math_researcher = Agent(
         role="Researcher",
@@ -2441,6 +2461,16 @@ def test_using_contextual_memory_with_long_term_memory():
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_warning_long_term_memory_without_entity_memory():
     from unittest.mock import patch
+    
+    # Check if ChromaDB is available
+    try:
+        import chromadb  # noqa: F401
+        HAS_CHROMADB = True
+    except ImportError:
+        HAS_CHROMADB = False
+        
+    if not HAS_CHROMADB:
+        pytest.skip("ChromaDB is required for this test")
 
     math_researcher = Agent(
         role="Researcher",
@@ -2478,6 +2508,16 @@ def test_warning_long_term_memory_without_entity_memory():
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_long_term_memory_with_memory_flag():
     from unittest.mock import patch
+    
+    # Check if ChromaDB is available
+    try:
+        import chromadb  # noqa: F401
+        HAS_CHROMADB = True
+    except ImportError:
+        HAS_CHROMADB = False
+        
+    if not HAS_CHROMADB:
+        pytest.skip("ChromaDB is required for this test")
 
     math_researcher = Agent(
         role="Researcher",
@@ -2513,6 +2553,16 @@ def test_long_term_memory_with_memory_flag():
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_using_contextual_memory_with_short_term_memory():
     from unittest.mock import patch
+    
+    # Check if ChromaDB is available
+    try:
+        import chromadb  # noqa: F401
+        HAS_CHROMADB = True
+    except ImportError:
+        HAS_CHROMADB = False
+        
+    if not HAS_CHROMADB:
+        pytest.skip("ChromaDB is required for this test")
 
     math_researcher = Agent(
         role="Researcher",
@@ -2542,6 +2592,16 @@ def test_using_contextual_memory_with_short_term_memory():
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_disabled_memory_using_contextual_memory():
     from unittest.mock import patch
+    
+    # Check if ChromaDB is available
+    try:
+        import chromadb  # noqa: F401
+        HAS_CHROMADB = True
+    except ImportError:
+        HAS_CHROMADB = False
+        
+    if not HAS_CHROMADB:
+        pytest.skip("ChromaDB is required for this test")
 
     math_researcher = Agent(
         role="Researcher",

tests/memory/external_memory_test.py

@@ -169,6 +169,15 @@ def test_crew_external_memory_reset(mem_type, crew_with_external_memory):
 def test_crew_external_memory_save_with_memory_flag(
     mem_method, crew_with_external_memory
 ):
+    try:
+        import chromadb  # noqa: F401
+        HAS_CHROMADB = True
+    except ImportError:
+        HAS_CHROMADB = False
+        
+    if not HAS_CHROMADB:
+        pytest.skip("ChromaDB is required for this test")
+        
     with patch(
         f"crewai.memory.external.external_memory.ExternalMemory.{mem_method}"
     ) as mock_method:
@@ -181,6 +190,15 @@ def test_crew_external_memory_save_with_memory_flag(
 def test_crew_external_memory_save_using_crew_without_memory_flag(
     mem_method, crew_with_external_memory_without_memory_flag
 ):
+    try:
+        import chromadb  # noqa: F401
+        HAS_CHROMADB = True
+    except ImportError:
+        HAS_CHROMADB = False
+        
+    if not HAS_CHROMADB:
+        pytest.skip("ChromaDB is required for this test")
+        
     with patch(
         f"crewai.memory.external.external_memory.ExternalMemory.{mem_method}"
     ) as mock_method:

tests/memory/long_term_memory_test.py

@@ -7,10 +7,28 @@ from crewai.memory.long_term.long_term_memory_item import LongTermMemoryItem
 @pytest.fixture
 def long_term_memory():
     """Fixture to create a LongTermMemory instance"""
+    try:
+        import chromadb  # noqa: F401
+        HAS_CHROMADB = True
+    except ImportError:
+        HAS_CHROMADB = False
+        
+    if not HAS_CHROMADB:
+        pytest.skip("ChromaDB is required for this test")
+        
     return LongTermMemory()
 
 
 def test_save_and_search(long_term_memory):
+    try:
+        import chromadb  # noqa: F401
+        HAS_CHROMADB = True
+    except ImportError:
+        HAS_CHROMADB = False
+        
+    if not HAS_CHROMADB:
+        pytest.skip("ChromaDB is required for this test")
+        
     memory = LongTermMemoryItem(
         agent="test_agent",
         task="test_task",

tests/memory/short_term_memory_test.py

@@ -12,6 +12,15 @@ from crewai.task import Task
 @pytest.fixture
 def short_term_memory():
     """Fixture to create a ShortTermMemory instance"""
+    try:
+        import chromadb  # noqa: F401
+        HAS_CHROMADB = True
+    except ImportError:
+        HAS_CHROMADB = False
+        
+    if not HAS_CHROMADB:
+        pytest.skip("ChromaDB is required for this test")
+        
     agent = Agent(
         role="Researcher",
         goal="Search relevant data and provide results",
@@ -29,6 +38,15 @@ def short_term_memory():
 
 
 def test_save_and_search(short_term_memory):
+    try:
+        import chromadb  # noqa: F401
+        HAS_CHROMADB = True
+    except ImportError:
+        HAS_CHROMADB = False
+        
+    if not HAS_CHROMADB:
+        pytest.skip("ChromaDB is required for this test")
+        
     memory = ShortTermMemoryItem(
         data="""test value test value test value test value test value test value
         test value test value test value test value test value test value

tests/test_optional_dependencies.py

@@ -0,0 +1,80 @@
+import pytest
+import importlib
+import sys
+from unittest.mock import patch
+
+from crewai.utilities.errors import ChromaDBRequiredError
+
+
+def test_import_without_chromadb():
+    """Test that crewai can be imported without chromadb."""
+    with patch.dict(sys.modules, {"chromadb": None, "chromadb.errors": None, "chromadb.api": None, "chromadb.config": None}):
+        modules_to_reload = [
+            "crewai.memory.storage.rag_storage",
+            "crewai.knowledge.storage.knowledge_storage", 
+            "crewai.utilities.embedding_configurator"
+        ]
+        for module in modules_to_reload:
+            if module in sys.modules:
+                importlib.reload(sys.modules[module])
+            
+        from crewai import Agent, Task, Crew, Process
+        
+        agent = Agent(role="Test Agent", goal="Test Goal", backstory="Test Backstory")
+        task = Task(description="Test Task", agent=agent)
+        _ = Crew(agents=[agent], tasks=[task], process=Process.sequential)
+
+
+def test_memory_storage_without_chromadb():
+    """Test that memory storage raises appropriate error when chromadb is not available."""
+    with patch.dict(sys.modules, {"chromadb": None, "chromadb.errors": None, "chromadb.api": None, "chromadb.config": None}):
+        if "crewai.memory.storage.rag_storage" in sys.modules:
+            importlib.reload(sys.modules["crewai.memory.storage.rag_storage"])
+            
+        from crewai.memory.storage.rag_storage import RAGStorage, HAS_CHROMADB
+        
+        assert not HAS_CHROMADB
+        
+        with pytest.raises(ChromaDBRequiredError) as excinfo:
+            storage = RAGStorage("memory", allow_reset=True, crew=None)
+            
+        assert "ChromaDB is required for memory storage" in str(excinfo.value)
+
+
+def test_knowledge_storage_without_chromadb():
+    """Test that knowledge storage raises appropriate error when chromadb is not available."""
+    with patch.dict(sys.modules, {"chromadb": None, "chromadb.errors": None, "chromadb.api": None, "chromadb.config": None}):
+        modules_to_reload = [
+            "crewai.knowledge.storage.knowledge_storage",
+            "crewai.utilities.embedding_configurator"
+        ]
+        for module in modules_to_reload:
+            if module in sys.modules:
+                importlib.reload(sys.modules[module])
+            
+        from crewai.knowledge.storage.knowledge_storage import KnowledgeStorage, HAS_CHROMADB
+        
+        assert not HAS_CHROMADB
+        
+        with pytest.raises(ChromaDBRequiredError) as excinfo:
+            storage = KnowledgeStorage()
+            storage.initialize_knowledge_storage()
+            
+        assert "ChromaDB is required for knowledge storage" in str(excinfo.value)
+
+
+def test_embedding_configurator_without_chromadb():
+    """Test that embedding configurator raises appropriate error when chromadb is not available."""
+    with patch.dict(sys.modules, {"chromadb": None, "chromadb.errors": None, "chromadb.api": None, "chromadb.config": None}):
+        if "crewai.utilities.embedding_configurator" in sys.modules:
+            importlib.reload(sys.modules["crewai.utilities.embedding_configurator"])
+            
+        from crewai.utilities.embedding_configurator import EmbeddingConfigurator, HAS_CHROMADB
+        
+        assert not HAS_CHROMADB
+        
+        with pytest.raises(ChromaDBRequiredError) as excinfo:
+            configurator = EmbeddingConfigurator()
+            configurator.configure_embedder()
+            
+        assert "ChromaDB is required for embedding functionality" in str(excinfo.value)