fix: cast dict values to str in _format_prompt

- Add str() casts for type safety
- These values are always strings when called from invoke

docs/docs.json

@@ -32,6 +32,11 @@
               "href": "https://chatgpt.com/g/g-qqTuUWsBY-crewai-assistant",
               "icon": "robot"
             },
+            {
+              "anchor": "Get Help",
+              "href": "mailto:support@crewai.com",
+              "icon": "headset"
+            },
             {
               "anchor": "Releases",
               "href": "https://github.com/crewAIInc/crewAI/releases",
@@ -367,6 +372,11 @@
               "href": "https://chatgpt.com/g/g-qqTuUWsBY-crewai-assistant",
               "icon": "robot"
             },
+            {
+              "anchor": "Obter Ajuda",
+              "href": "mailto:support@crewai.com",
+              "icon": "headset"
+            },
             {
               "anchor": "Lançamentos",
               "href": "https://github.com/crewAIInc/crewAI/releases",

docs/en/concepts/llms.mdx

@@ -270,7 +270,7 @@ In this section, you'll find detailed examples that help you select, configure,
     from crewai import LLM
 
     llm = LLM(
-        model="gemini-1.5-pro-latest", # or vertex_ai/gemini-1.5-pro-latest
+        model="gemini/gemini-1.5-pro-latest",
         temperature=0.7,
         vertex_credentials=vertex_credentials_json
     )

docs/en/concepts/memory.mdx

@@ -623,7 +623,7 @@ for provider in providers_to_test:
 **Model not found errors:**
 ```python
 # Verify model availability
-from crewai.rag.embeddings.configurator import EmbeddingConfigurator
+from crewai.utilities.embedding_configurator import EmbeddingConfigurator
 
 configurator = EmbeddingConfigurator()
 try:
@@ -720,16 +720,7 @@ crew = Crew(
 ```
 
 ### Advanced Mem0 Configuration
-When using Mem0 Client, you can customize the memory configuration further, by using parameters like 'includes', 'excludes', 'custom_categories', 'infer' and 'run_id' (this is only for short-term memory).
-You can find more details in the [Mem0 documentation](https://docs.mem0.ai/).
 ```python
-
-new_categories = [
-    {"lifestyle_management_concerns": "Tracks daily routines, habits, hobbies and interests including cooking, time management and work-life balance"},
-    {"seeking_structure": "Documents goals around creating routines, schedules, and organized systems in various life areas"},
-    {"personal_information": "Basic information about the user including name, preferences, and personality traits"}
-]
-
 crew = Crew(
     agents=[...],
     tasks=[...],
@@ -741,11 +732,6 @@ crew = Crew(
             "org_id": "my_org_id",        # Optional
             "project_id": "my_project_id", # Optional
             "api_key": "custom-api-key"    # Optional - overrides env var
-            "run_id": "my_run_id",        # Optional - for short-term memory
-            "includes": "include1",       # Optional 
-            "excludes": "exclude1",       # Optional
-            "infer": True                 # Optional defaults to True
-            "custom_categories": new_categories  # Optional - custom categories for user memory
         },
         "user_memory": {}
     }
@@ -775,8 +761,7 @@ crew = Crew(
                     "provider": "openai",
                     "config": {"api_key": "your-api-key", "model": "text-embedding-3-small"}
                 }
-            },
-            "infer": True                   # Optional defaults to True
+            }
         },
         "user_memory": {}
     }

docs/en/concepts/tasks.mdx

@@ -54,11 +54,10 @@ crew = Crew(
 | **Markdown** _(optional)_        | `markdown`        | `Optional[bool]`              | Whether the task should instruct the agent to return the final answer formatted in Markdown. Defaults to False.      |
 | **Config** _(optional)_          | `config`          | `Optional[Dict[str, Any]]`    | Task-specific configuration parameters.                                                                              |
 | **Output File** _(optional)_     | `output_file`     | `Optional[str]`               | File path for storing the task output.                                                                               |
-| **Create Directory** _(optional)_ | `create_directory` | `Optional[bool]`             | Whether to create the directory for output_file if it doesn't exist. Defaults to True.                               |
 | **Output JSON** _(optional)_     | `output_json`     | `Optional[Type[BaseModel]]`   | A Pydantic model to structure the JSON output.                                                                       |
 | **Output Pydantic** _(optional)_ | `output_pydantic` | `Optional[Type[BaseModel]]`   | A Pydantic model for task output.                                                                                    |
 | **Callback** _(optional)_        | `callback`        | `Optional[Any]`               | Function/object to be executed after task completion.                                                                |
-| **Guardrail** _(optional)_       | `guardrail`       | `Optional[Callable]`             | Function to validate task output before proceeding to next task.                                                  |
+| **Guardrail** _(optional)_       | `guardrail`       | `Optional[Union[Callable, str]]` | Function or string description to validate task output before proceeding to next task.                            |
 
 ## Creating Tasks
 
@@ -88,6 +87,7 @@ research_task:
   expected_output: >
     A list with 10 bullet points of the most relevant information about {topic}
   agent: researcher
+  guardrail: ensure each bullet contains a minimum of 100 words
 
 reporting_task:
   description: >
@@ -334,7 +334,9 @@ Task guardrails provide a way to validate and transform task outputs before they
 are passed to the next task. This feature helps ensure data quality and provides
 feedback to agents when their output doesn't meet specific criteria.
 
-Guardrails are implemented as Python functions that contain custom validation logic, giving you complete control over the validation process and ensuring reliable, deterministic results.
+**Guardrails can be defined in two ways:**
+1. **Function-based guardrails**: Python functions that implement custom validation logic
+2. **String-based guardrails**: Natural language descriptions that are automatically converted to LLM-powered validation
 
 ### Function-Based Guardrails
 
@@ -376,7 +378,82 @@ blog_task = Task(
    - On success: it returns a tuple of `(bool, Any)`. For example: `(True, validated_result)`
    - On Failure: it returns a tuple of `(bool, str)`. For example: `(False, "Error message explain the failure")`
 
+### String-Based Guardrails
 
+String-based guardrails allow you to describe validation criteria in natural language. When you provide a string instead of a function, CrewAI automatically converts it to an `LLMGuardrail` that uses an AI agent to validate the task output.
+
+#### Using String Guardrails in Python
+
+```python Code
+from crewai import Task
+
+# Simple string-based guardrail
+blog_task = Task(
+    description="Write a blog post about AI",
+    expected_output="A blog post under 200 words",
+    agent=blog_agent,
+    guardrail="Ensure the blog post is under 200 words and includes practical examples"
+)
+
+# More complex validation criteria
+research_task = Task(
+    description="Research AI trends for 2025",
+    expected_output="A comprehensive research report",
+    agent=research_agent,
+    guardrail="Ensure each finding includes a credible source and is backed by recent data from 2024-2025"
+)
+```
+
+#### Using String Guardrails in YAML
+
+```yaml
+research_task:
+  description: Research the latest AI developments
+  expected_output: A list of 10 bullet points about AI
+  agent: researcher
+  guardrail: ensure each bullet contains a minimum of 100 words
+
+validation_task:
+  description: Validate the research findings
+  expected_output: A validation report
+  agent: validator
+  guardrail: confirm all sources are from reputable publications and published within the last 2 years
+```
+
+#### How String Guardrails Work
+
+When you provide a string guardrail, CrewAI automatically:
+1. Creates an `LLMGuardrail` instance using the string as validation criteria
+2. Uses the task's agent LLM to power the validation
+3. Creates a temporary validation agent that checks the output against your criteria
+4. Returns detailed feedback if validation fails
+
+This approach is ideal when you want to use natural language to describe validation rules without writing custom validation functions.
+
+### LLMGuardrail Class
+
+The `LLMGuardrail` class is the underlying mechanism that powers string-based guardrails. You can also use it directly for more advanced control:
+
+```python Code
+from crewai import Task
+from crewai.tasks.llm_guardrail import LLMGuardrail
+from crewai.llm import LLM
+
+# Create a custom LLMGuardrail with specific LLM
+custom_guardrail = LLMGuardrail(
+    description="Ensure the response contains exactly 5 bullet points with proper citations",
+    llm=LLM(model="gpt-4o-mini")
+)
+
+task = Task(
+    description="Research AI safety measures",
+    expected_output="A detailed analysis with bullet points",
+    agent=research_agent,
+    guardrail=custom_guardrail
+)
+```
+
+**Note**: When you use a string guardrail, CrewAI automatically creates an `LLMGuardrail` instance using your task's agent LLM. Using `LLMGuardrail` directly gives you more control over the validation process and LLM selection.
 
 ### Error Handling Best Practices
 
@@ -804,87 +881,21 @@ These validations help in maintaining the consistency and reliability of task ex
 
 ## Creating Directories when Saving Files
 
-The `create_directory` parameter controls whether CrewAI should automatically create directories when saving task outputs to files. This feature is particularly useful for organizing outputs and ensuring that file paths are correctly structured, especially when working with complex project hierarchies.
-
-### Default Behavior
-
-By default, `create_directory=True`, which means CrewAI will automatically create any missing directories in the output file path:
+You can now specify if a task should create directories when saving its output to a file. This is particularly useful for organizing outputs and ensuring that file paths are correctly structured.
 
 ```python Code
-# Default behavior - directories are created automatically
-report_task = Task(
-    description='Generate a comprehensive market analysis report',
-    expected_output='A detailed market analysis with charts and insights',
-    agent=analyst_agent,
-    output_file='reports/2025/market_analysis.md',  # Creates 'reports/2025/' if it doesn't exist
-    markdown=True
+# ...
+
+save_output_task = Task(
+    description='Save the summarized AI news to a file',
+    expected_output='File saved successfully',
+    agent=research_agent,
+    tools=[file_save_tool],
+    output_file='outputs/ai_news_summary.txt',
+    create_directory=True
 )
-```
 
-### Disabling Directory Creation
-
-If you want to prevent automatic directory creation and ensure that the directory already exists, set `create_directory=False`:
-
-```python Code
-# Strict mode - directory must already exist
-strict_output_task = Task(
-    description='Save critical data that requires existing infrastructure',
-    expected_output='Data saved to pre-configured location',
-    agent=data_agent,
-    output_file='secure/vault/critical_data.json',
-    create_directory=False  # Will raise RuntimeError if 'secure/vault/' doesn't exist
-)
-```
-
-### YAML Configuration
-
-You can also configure this behavior in your YAML task definitions:
-
-```yaml tasks.yaml
-analysis_task:
-  description: >
-    Generate quarterly financial analysis
-  expected_output: >
-    A comprehensive financial report with quarterly insights
-  agent: financial_analyst
-  output_file: reports/quarterly/q4_2024_analysis.pdf
-  create_directory: true  # Automatically create 'reports/quarterly/' directory
-
-audit_task:
-  description: >
-    Perform compliance audit and save to existing audit directory
-  expected_output: >
-    A compliance audit report
-  agent: auditor
-  output_file: audit/compliance_report.md
-  create_directory: false  # Directory must already exist
-```
-
-### Use Cases
-
-**Automatic Directory Creation (`create_directory=True`):**
-- Development and prototyping environments
-- Dynamic report generation with date-based folders
-- Automated workflows where directory structure may vary
-- Multi-tenant applications with user-specific folders
-
-**Manual Directory Management (`create_directory=False`):**
-- Production environments with strict file system controls
-- Security-sensitive applications where directories must be pre-configured
-- Systems with specific permission requirements
-- Compliance environments where directory creation is audited
-
-### Error Handling
-
-When `create_directory=False` and the directory doesn't exist, CrewAI will raise a `RuntimeError`:
-
-```python Code
-try:
-    result = crew.kickoff()
-except RuntimeError as e:
-    # Handle missing directory error
-    print(f"Directory creation failed: {e}")
-    # Create directory manually or use fallback location
+#...
 ```
 
 Check out the video below to see how to use structured outputs in CrewAI:

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

@@ -6,6 +6,10 @@ icon: google
 
 # `SerperDevTool`
 
+<Note>
+    We are still working on improving tools, so there might be unexpected behavior or changes in the future.
+</Note>
+
 ## Description
 
 This tool is designed to perform a semantic search for a specified query from a text's content across the internet. It utilizes the [serper.dev](https://serper.dev) API 
@@ -13,12 +17,6 @@ to fetch and display the most relevant search results based on the query provide
 
 ## Installation
 
-To effectively use the `SerperDevTool`, follow these steps:
-
-1. **Package Installation**: Confirm that the `crewai[tools]` package is installed in your Python environment.
-2. **API Key Acquisition**: Acquire a `serper.dev` API key by registering for a free account at `serper.dev`.
-3. **Environment Configuration**: Store your obtained API key in an environment variable named `SERPER_API_KEY` to facilitate its use by the tool.
-
 To incorporate this tool into your project, follow the installation instructions below:
 
 ```shell
@@ -36,6 +34,14 @@ from crewai_tools import SerperDevTool
 tool = SerperDevTool()
 ```
 
+## Steps to Get Started
+
+To effectively use the `SerperDevTool`, follow these steps:
+
+1. **Package Installation**: Confirm that the `crewai[tools]` package is installed in your Python environment.
+2. **API Key Acquisition**: Acquire a `serper.dev` API key by registering for a free account at `serper.dev`.
+3. **Environment Configuration**: Store your obtained API key in an environment variable named `SERPER_API_KEY` to facilitate its use by the tool.
+
 ## Parameters
 
 The `SerperDevTool` comes with several parameters that will be passed to the API :

docs/en/tools/web-scraping/serperscrapewebsitetool.mdx

@@ -1,100 +0,0 @@
----
-title: Serper Scrape Website
-description: The `SerperScrapeWebsiteTool` is designed to scrape websites and extract clean, readable content using Serper's scraping API.
-icon: globe
----
-
-# `SerperScrapeWebsiteTool`
-
-## Description
-
-This tool is designed to scrape website content and extract clean, readable text from any website URL. It utilizes the [serper.dev](https://serper.dev) scraping API to fetch and process web pages, optionally including markdown formatting for better structure and readability.
-
-## Installation
-
-To effectively use the `SerperScrapeWebsiteTool`, follow these steps:
-
-1. **Package Installation**: Confirm that the `crewai[tools]` package is installed in your Python environment.
-2. **API Key Acquisition**: Acquire a `serper.dev` API key by registering for an account at `serper.dev`.
-3. **Environment Configuration**: Store your obtained API key in an environment variable named `SERPER_API_KEY` to facilitate its use by the tool.
-
-To incorporate this tool into your project, follow the installation instructions below:
-
-```shell
-pip install 'crewai[tools]'
-```
-
-## Example
-
-The following example demonstrates how to initialize the tool and scrape a website:
-
-```python Code
-from crewai_tools import SerperScrapeWebsiteTool
-
-# Initialize the tool for website scraping capabilities
-tool = SerperScrapeWebsiteTool()
-
-# Scrape a website with markdown formatting
-result = tool.run(url="https://example.com", include_markdown=True)
-```
-
-## Arguments
-
-The `SerperScrapeWebsiteTool` accepts the following arguments:
-
-- **url**: Required. The URL of the website to scrape.
-- **include_markdown**: Optional. Whether to include markdown formatting in the scraped content. Defaults to `True`.
-
-## Example with Parameters
-
-Here is an example demonstrating how to use the tool with different parameters:
-
-```python Code
-from crewai_tools import SerperScrapeWebsiteTool
-
-tool = SerperScrapeWebsiteTool()
-
-# Scrape with markdown formatting (default)
-markdown_result = tool.run(
-    url="https://docs.crewai.com",
-    include_markdown=True
-)
-
-# Scrape without markdown formatting for plain text
-plain_result = tool.run(
-    url="https://docs.crewai.com",
-    include_markdown=False
-)
-
-print("Markdown formatted content:")
-print(markdown_result)
-
-print("\nPlain text content:")
-print(plain_result)
-```
-
-## Use Cases
-
-The `SerperScrapeWebsiteTool` is particularly useful for:
-
-- **Content Analysis**: Extract and analyze website content for research purposes
-- **Data Collection**: Gather structured information from web pages
-- **Documentation Processing**: Convert web-based documentation into readable formats
-- **Competitive Analysis**: Scrape competitor websites for market research
-- **Content Migration**: Extract content from existing websites for migration purposes
-
-## Error Handling
-
-The tool includes comprehensive error handling for:
-
-- **Network Issues**: Handles connection timeouts and network errors gracefully
-- **API Errors**: Provides detailed error messages for API-related issues
-- **Invalid URLs**: Validates and reports issues with malformed URLs
-- **Authentication**: Clear error messages for missing or invalid API keys
-
-## Security Considerations
-
-- Always store your `SERPER_API_KEY` in environment variables, never hardcode it in your source code
-- Be mindful of rate limits imposed by the Serper API
-- Respect robots.txt and website terms of service when scraping content
-- Consider implementing delays between requests for large-scale scraping operations

docs/pt-BR/concepts/cli.mdx

@@ -84,8 +84,8 @@ filename = "seu_modelo.pkl"
 
 try:
     SuaCrew().crew().train(
-      n_iterations=n_iterations,
-      inputs=inputs,
+      n_iterations=n_iterations, 
+      inputs=inputs, 
       filename=filename
     )
 except Exception as e:
@@ -103,7 +103,7 @@ crewai replay [OPTIONS]
 - `-t, --task_id TEXT`: Reexecuta o crew a partir deste task ID, incluindo todas as tarefas subsequentes
 
 Exemplo:
-```shell Terminal
+```shell Terminal    
 crewai replay -t task_123456
 ```
 
@@ -149,7 +149,7 @@ crewai test [OPTIONS]
 - `-m, --model TEXT`: Modelo LLM para executar os testes no Crew (padrão: "gpt-4o-mini")
 
 Exemplo:
-```shell Terminal
+```shell Terminal    
 crewai test -n 5 -m gpt-3.5-turbo
 ```
 
@@ -203,7 +203,10 @@ def crew(self) -> Crew:
 Implemente o crew ou flow no [CrewAI Enterprise](https://app.crewai.com).
 
 - **Autenticação**: Você precisa estar autenticado para implementar no CrewAI Enterprise.
-    Você pode fazer login ou criar uma conta com:
+    ```shell Terminal
+    crewai signup
+    ```
+    Caso já tenha uma conta, você pode fazer login com:
     ```shell Terminal
     crewai login
     ```
@@ -250,7 +253,7 @@ Você deve estar autenticado no CrewAI Enterprise para usar estes comandos de ge
 - **Implantar o Crew**: Depois de autenticado, você pode implantar seu crew ou flow no CrewAI Enterprise.
     ```shell Terminal
     crewai deploy push
-    ```
+    ``` 
     - Inicia o processo de deployment na plataforma CrewAI Enterprise.
     - Após a iniciação bem-sucedida, será exibida a mensagem Deployment created successfully! juntamente com o Nome do Deployment e um Deployment ID (UUID) único.
 
@@ -323,4 +326,4 @@ Ao escolher um provedor, o CLI solicitará que você informe o nome da chave e a
 
 Veja o seguinte link para o nome de chave de cada provedor:
 
-* [LiteLLM Providers](https://docs.litellm.ai/docs/providers)
+* [LiteLLM Providers](https://docs.litellm.ai/docs/providers)

docs/pt-BR/concepts/llms.mdx

@@ -268,7 +268,7 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
     from crewai import LLM
 
     llm = LLM(
-        model="gemini-1.5-pro-latest", # or vertex_ai/gemini-1.5-pro-latest
+        model="gemini/gemini-1.5-pro-latest",
         temperature=0.7,
         vertex_credentials=vertex_credentials_json
     )

docs/pt-BR/concepts/memory.mdx

@@ -623,7 +623,7 @@ for provider in providers_to_test:
 **Erros de modelo não encontrado:**
 ```python
 # Verifique disponibilidade do modelo
-from crewai.rag.embeddings.configurator import EmbeddingConfigurator
+from crewai.utilities.embedding_configurator import EmbeddingConfigurator
 
 configurator = EmbeddingConfigurator()
 try:

docs/pt-BR/concepts/tasks.mdx

@@ -54,11 +54,10 @@ crew = Crew(
 | **Markdown** _(opcional)_        | `markdown`        | `Optional[bool]`             | Se a tarefa deve instruir o agente a retornar a resposta final formatada em Markdown. O padrão é False.            |
 | **Config** _(opcional)_          | `config`          | `Optional[Dict[str, Any]]`   | Parâmetros de configuração específicos da tarefa.                                                                  |
 | **Arquivo de Saída** _(opcional)_| `output_file`     | `Optional[str]`              | Caminho do arquivo para armazenar a saída da tarefa.                                                               |
-| **Criar Diretório** _(opcional)_ | `create_directory` | `Optional[bool]`            | Se deve criar o diretório para output_file caso não exista. O padrão é True.                                       |
 | **Saída JSON** _(opcional)_      | `output_json`     | `Optional[Type[BaseModel]]`  | Um modelo Pydantic para estruturar a saída em JSON.                                                                |
 | **Output Pydantic** _(opcional)_ | `output_pydantic` | `Optional[Type[BaseModel]]`  | Um modelo Pydantic para a saída da tarefa.                                                                         |
 | **Callback** _(opcional)_        | `callback`        | `Optional[Any]`              | Função/objeto a ser executado após a conclusão da tarefa.                                                          |
-| **Guardrail** _(opcional)_       | `guardrail`       | `Optional[Callable]`             | Função para validar a saída da tarefa antes de prosseguir para a próxima tarefa.                                |
+| **Guardrail** _(opcional)_       | `guardrail`       | `Optional[Union[Callable, str]]` | Função ou descrição em string para validar a saída da tarefa antes de prosseguir para a próxima tarefa.        |
 
 ## Criando Tarefas
 
@@ -88,6 +87,7 @@ research_task:
   expected_output: >
     Uma lista com 10 tópicos em bullet points das informações mais relevantes sobre {topic}
   agent: researcher
+  guardrail: garanta que cada bullet point contenha no mínimo 100 palavras
 
 reporting_task:
   description: >
@@ -332,7 +332,9 @@ analysis_task = Task(
 
 Guardrails (trilhas de proteção) de tarefas fornecem uma maneira de validar e transformar as saídas das tarefas antes que elas sejam passadas para a próxima tarefa. Esse recurso assegura a qualidade dos dados e oferece feedback aos agentes quando sua saída não atende a critérios específicos.
 
-Guardrails são implementados como funções Python que contêm lógica de validação customizada, proporcionando controle total sobre o processo de validação e garantindo resultados confiáveis e determinísticos.
+**Guardrails podem ser definidos de duas maneiras:**
+1. **Guardrails baseados em função**: Funções Python que implementam lógica de validação customizada
+2. **Guardrails baseados em string**: Descrições em linguagem natural que são automaticamente convertidas em validação baseada em LLM
 
 ### Guardrails Baseados em Função
 
@@ -374,7 +376,82 @@ blog_task = Task(
    - Em caso de sucesso: retorna uma tupla `(True, resultado_validado)`
    - Em caso de falha: retorna uma tupla `(False, "mensagem de erro explicando a falha")`
 
+### Guardrails Baseados em String
 
+Guardrails baseados em string permitem que você descreva critérios de validação em linguagem natural. Quando você fornece uma string em vez de uma função, o CrewAI automaticamente a converte em um `LLMGuardrail` que usa um agente de IA para validar a saída da tarefa.
+
+#### Usando Guardrails de String em Python
+
+```python Code
+from crewai import Task
+
+# Guardrail simples baseado em string
+blog_task = Task(
+    description="Escreva um post de blog sobre IA",
+    expected_output="Um post de blog com menos de 200 palavras",
+    agent=blog_agent,
+    guardrail="Garanta que o post do blog tenha menos de 200 palavras e inclua exemplos práticos"
+)
+
+# Critérios de validação mais complexos
+research_task = Task(
+    description="Pesquise tendências de IA para 2025",
+    expected_output="Um relatório abrangente de pesquisa",
+    agent=research_agent,
+    guardrail="Garanta que cada descoberta inclua uma fonte confiável e seja respaldada por dados recentes de 2024-2025"
+)
+```
+
+#### Usando Guardrails de String em YAML
+
+```yaml
+research_task:
+  description: Pesquise os últimos desenvolvimentos em IA
+  expected_output: Uma lista de 10 bullet points sobre IA
+  agent: researcher
+  guardrail: garanta que cada bullet point contenha no mínimo 100 palavras
+
+validation_task:
+  description: Valide os achados da pesquisa
+  expected_output: Um relatório de validação
+  agent: validator
+  guardrail: confirme que todas as fontes são de publicações respeitáveis e publicadas nos últimos 2 anos
+```
+
+#### Como Funcionam os Guardrails de String
+
+Quando você fornece um guardrail de string, o CrewAI automaticamente:
+1. Cria uma instância `LLMGuardrail` usando a string como critério de validação
+2. Usa o LLM do agente da tarefa para alimentar a validação
+3. Cria um agente temporário de validação que verifica a saída contra seus critérios
+4. Retorna feedback detalhado se a validação falhar
+
+Esta abordagem é ideal quando você quer usar linguagem natural para descrever regras de validação sem escrever funções de validação customizadas.
+
+### Classe LLMGuardrail
+
+A classe `LLMGuardrail` é o mecanismo subjacente que alimenta os guardrails baseados em string. Você também pode usá-la diretamente para maior controle avançado:
+
+```python Code
+from crewai import Task
+from crewai.tasks.llm_guardrail import LLMGuardrail
+from crewai.llm import LLM
+
+# Crie um LLMGuardrail customizado com LLM específico
+custom_guardrail = LLMGuardrail(
+    description="Garanta que a resposta contenha exatamente 5 bullet points com citações adequadas",
+    llm=LLM(model="gpt-4o-mini")
+)
+
+task = Task(
+    description="Pesquise medidas de segurança em IA",
+    expected_output="Uma análise detalhada com bullet points",
+    agent=research_agent,
+    guardrail=custom_guardrail
+)
+```
+
+**Nota**: Quando você usa um guardrail de string, o CrewAI automaticamente cria uma instância `LLMGuardrail` usando o LLM do agente da sua tarefa. Usar `LLMGuardrail` diretamente lhe dá mais controle sobre o processo de validação e seleção de LLM.
 
 ### Melhores Práticas de Tratamento de Erros
 
@@ -825,7 +902,26 @@ task = Task(
 )
 ```
 
+#### Use uma abordagem no-code para validação
 
+```python Code
+from crewai import Task
+
+task = Task(
+    description="Gerar dados em JSON",
+    expected_output="Objeto JSON válido",
+    guardrail="Garanta que a resposta é um objeto JSON válido"
+)
+```
+
+#### Usando YAML
+
+```yaml
+research_task:
+  ...
+  guardrail: garanta que cada bullet tenha no mínimo 100 palavras
+  ...
+```
 
 ```python Code
 @CrewBase
@@ -941,87 +1037,21 @@ task = Task(
 
 ## Criando Diretórios ao Salvar Arquivos
 
-O parâmetro `create_directory` controla se o CrewAI deve criar automaticamente diretórios ao salvar saídas de tarefas em arquivos. Este recurso é particularmente útil para organizar outputs e garantir que os caminhos de arquivos estejam estruturados corretamente, especialmente ao trabalhar com hierarquias de projetos complexas.
-
-### Comportamento Padrão
-
-Por padrão, `create_directory=True`, o que significa que o CrewAI criará automaticamente qualquer diretório ausente no caminho do arquivo de saída:
+Agora é possível especificar se uma tarefa deve criar diretórios ao salvar sua saída em arquivo. Isso é útil para organizar outputs e garantir que os caminhos estejam corretos.
 
 ```python Code
-# Comportamento padrão - diretórios são criados automaticamente
-report_task = Task(
-    description='Gerar um relatório abrangente de análise de mercado',
-    expected_output='Uma análise detalhada de mercado com gráficos e insights',
-    agent=analyst_agent,
-    output_file='reports/2025/market_analysis.md',  # Cria 'reports/2025/' se não existir
-    markdown=True
+# ...
+
+save_output_task = Task(
+    description='Salve o resumo das notícias de IA em um arquivo',
+    expected_output='Arquivo salvo com sucesso',
+    agent=research_agent,
+    tools=[file_save_tool],
+    output_file='outputs/ai_news_summary.txt',
+    create_directory=True
 )
-```
 
-### Desabilitando a Criação de Diretórios
-
-Se você quiser evitar a criação automática de diretórios e garantir que o diretório já exista, defina `create_directory=False`:
-
-```python Code
-# Modo estrito - o diretório já deve existir
-strict_output_task = Task(
-    description='Salvar dados críticos que requerem infraestrutura existente',
-    expected_output='Dados salvos em localização pré-configurada',
-    agent=data_agent,
-    output_file='secure/vault/critical_data.json',
-    create_directory=False  # Gerará RuntimeError se 'secure/vault/' não existir
-)
-```
-
-### Configuração YAML
-
-Você também pode configurar este comportamento em suas definições de tarefas YAML:
-
-```yaml tasks.yaml
-analysis_task:
-  description: >
-    Gerar análise financeira trimestral
-  expected_output: >
-    Um relatório financeiro abrangente com insights trimestrais
-  agent: financial_analyst
-  output_file: reports/quarterly/q4_2024_analysis.pdf
-  create_directory: true  # Criar automaticamente o diretório 'reports/quarterly/'
-
-audit_task:
-  description: >
-    Realizar auditoria de conformidade e salvar no diretório de auditoria existente
-  expected_output: >
-    Um relatório de auditoria de conformidade
-  agent: auditor
-  output_file: audit/compliance_report.md
-  create_directory: false  # O diretório já deve existir
-```
-
-### Casos de Uso
-
-**Criação Automática de Diretórios (`create_directory=True`):**
-- Ambientes de desenvolvimento e prototipagem
-- Geração dinâmica de relatórios com pastas baseadas em datas
-- Fluxos de trabalho automatizados onde a estrutura de diretórios pode variar
-- Aplicações multi-tenant com pastas específicas do usuário
-
-**Gerenciamento Manual de Diretórios (`create_directory=False`):**
-- Ambientes de produção com controles rígidos do sistema de arquivos
-- Aplicações sensíveis à segurança onde diretórios devem ser pré-configurados
-- Sistemas com requisitos específicos de permissão
-- Ambientes de conformidade onde a criação de diretórios é auditada
-
-### Tratamento de Erros
-
-Quando `create_directory=False` e o diretório não existe, o CrewAI gerará um `RuntimeError`:
-
-```python Code
-try:
-    result = crew.kickoff()
-except RuntimeError as e:
-    # Tratar erro de diretório ausente
-    print(f"Falha na criação do diretório: {e}")
-    # Criar diretório manualmente ou usar local alternativo
+#...
 ```
 
 Veja o vídeo abaixo para aprender como utilizar saídas estruturadas no CrewAI:

pyproject.toml

@@ -48,7 +48,7 @@ Documentation = "https://docs.crewai.com"
 Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
-tools = ["crewai-tools~=0.59.0"]
+tools = ["crewai-tools~=0.55.0"]
 embeddings = [
     "tiktoken~=0.8.0"
 ]

src/crewai/__init__.py

@@ -54,7 +54,7 @@ def _track_install_async():
 
 _track_install_async()
 
-__version__ = "0.152.0"
+__version__ = "0.148.0"
 __all__ = [
     "Agent",
     "Crew",

src/crewai/agent.py

@@ -1,7 +1,18 @@
 import shutil
 import subprocess
 import time
-from typing import Any, Callable, Dict, List, Literal, Optional, Sequence, Tuple, Type, Union
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+)
 
 from pydantic import Field, InstanceOf, PrivateAttr, model_validator
 
@@ -76,6 +87,12 @@ class Agent(BaseAgent):
     """
 
     _times_executed: int = PrivateAttr(default=0)
+    agent_executor: Optional[CrewAgentExecutor] = Field(
+        default=None,
+        init=False,  # Not included in __init__ as it's created dynamically in create_agent_executor()
+        exclude=True,  # Excluded from serialization to avoid circular references
+        description="The agent executor instance for running tasks. Created dynamically when needed.",
+    )
     max_execution_time: Optional[int] = Field(
         default=None,
         description="Maximum execution time for an agent to execute a task",
@@ -162,7 +179,7 @@ class Agent(BaseAgent):
     )
     guardrail: Optional[Union[Callable[[Any], Tuple[bool, Any]], str]] = Field(
         default=None,
-        description="Function or string description of a guardrail to validate agent output"
+        description="Function or string description of a guardrail to validate agent output",
     )
     guardrail_max_retries: int = Field(
         default=3, description="Maximum number of retries when guardrail fails"
@@ -340,7 +357,6 @@ class Agent(BaseAgent):
             self.knowledge_config.model_dump() if self.knowledge_config else {}
         )
 
-
         if self.knowledge or (self.crew and self.crew.knowledge):
             crewai_event_bus.emit(
                 self,
@@ -531,6 +547,11 @@ class Agent(BaseAgent):
         Returns:
             The output of the agent.
         """
+        if not self.agent_executor:
+            raise ValueError(
+                "Agent executor not initialized. Call create_agent_executor() first."
+            )
+
         return self.agent_executor.invoke(
             {
                 "input": task_prompt,

src/crewai/agents/crew_agent_executor.py

@@ -96,7 +96,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             )
         )
 
-    def invoke(self, inputs: Dict[str, str]) -> Dict[str, Any]:
+    def invoke(self, inputs: Dict[str, Union[str, bool, None]]) -> Dict[str, Any]:
         if "system" in self.prompt:
             system_prompt = self._format_prompt(self.prompt.get("system", ""), inputs)
             user_prompt = self._format_prompt(self.prompt.get("user", ""), inputs)
@@ -122,7 +122,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             handle_unknown_error(self._printer, e)
             raise
 
-
         if self.ask_for_human_input:
             formatted_answer = self._handle_human_feedback(formatted_answer)
 
@@ -156,7 +155,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                     messages=self.messages,
                     callbacks=self.callbacks,
                     printer=self._printer,
-                    from_task=self.task
+                    from_task=self.task,
                 )
                 formatted_answer = process_llm_response(answer, self.use_stop_words)
 
@@ -372,10 +371,13 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         training_data[agent_id] = agent_training_data
         training_handler.save(training_data)
 
-    def _format_prompt(self, prompt: str, inputs: Dict[str, str]) -> str:
-        prompt = prompt.replace("{input}", inputs["input"])
-        prompt = prompt.replace("{tool_names}", inputs["tool_names"])
-        prompt = prompt.replace("{tools}", inputs["tools"])
+    def _format_prompt(
+        self, prompt: str, inputs: Dict[str, Union[str, bool, None]]
+    ) -> str:
+        # Cast to str to satisfy type checker - these are always strings when called
+        prompt = prompt.replace("{input}", str(inputs["input"]))
+        prompt = prompt.replace("{tool_names}", str(inputs["tool_names"]))
+        prompt = prompt.replace("{tools}", str(inputs["tools"]))
         return prompt
 
     def _handle_human_feedback(self, formatted_answer: AgentFinish) -> AgentFinish:

src/crewai/cli/command.py

@@ -26,7 +26,7 @@ class PlusAPIMixin:
                 "Please sign up/login to CrewAI+ before using the CLI.",
                 style="bold red",
             )
-            console.print("Run 'crewai login' to sign up/login.", style="bold green")
+            console.print("Run 'crewai signup' to sign up/login.", style="bold green")
             raise SystemExit
 
     def _validate_response(self, response: requests.Response) -> None:

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

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

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

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

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

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

src/crewai/flow/flow.py

@@ -436,7 +436,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
     _routers: Set[str] = set()
     _router_paths: Dict[str, List[str]] = {}
     initial_state: Union[Type[T], T, None] = None
-    name: Optional[str] = None
 
     def __class_getitem__(cls: Type["Flow"], item: Type[T]) -> Type["Flow"]:
         class _FlowGeneric(cls):  # type: ignore
@@ -474,7 +473,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
             self,
             FlowCreatedEvent(
                 type="flow_created",
-                flow_name=self.name or self.__class__.__name__,
+                flow_name=self.__class__.__name__,
             ),
         )
 
@@ -770,7 +769,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
             self,
             FlowStartedEvent(
                 type="flow_started",
-                flow_name=self.name or self.__class__.__name__,
+                flow_name=self.__class__.__name__,
                 inputs=inputs,
             ),
         )
@@ -793,7 +792,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
             self,
             FlowFinishedEvent(
                 type="flow_finished",
-                flow_name=self.name or self.__class__.__name__,
+                flow_name=self.__class__.__name__,
                 result=final_output,
             ),
         )
@@ -835,7 +834,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
                 MethodExecutionStartedEvent(
                     type="method_execution_started",
                     method_name=method_name,
-                    flow_name=self.name or self.__class__.__name__,
+                    flow_name=self.__class__.__name__,
                     params=dumped_params,
                     state=self._copy_state(),
                 ),
@@ -857,7 +856,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
                 MethodExecutionFinishedEvent(
                     type="method_execution_finished",
                     method_name=method_name,
-                    flow_name=self.name or self.__class__.__name__,
+                    flow_name=self.__class__.__name__,
                     state=self._copy_state(),
                     result=result,
                 ),
@@ -870,7 +869,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
                 MethodExecutionFailedEvent(
                     type="method_execution_failed",
                     method_name=method_name,
-                    flow_name=self.name or self.__class__.__name__,
+                    flow_name=self.__class__.__name__,
                     error=e,
                 ),
             )
@@ -1077,7 +1076,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
             self,
             FlowPlotEvent(
                 type="flow_plot",
-                flow_name=self.name or self.__class__.__name__,
+                flow_name=self.__class__.__name__,
             ),
         )
         plot_flow(self, filename)

src/crewai/knowledge/embedder/base_embedder.py

@@ -0,0 +1,55 @@
+from abc import ABC, abstractmethod
+from typing import List
+
+import numpy as np
+
+
+class BaseEmbedder(ABC):
+    """
+    Abstract base class for text embedding models
+    """
+
+    @abstractmethod
+    def embed_chunks(self, chunks: List[str]) -> np.ndarray:
+        """
+        Generate embeddings for a list of text chunks
+
+        Args:
+            chunks: List of text chunks to embed
+
+        Returns:
+            Array of embeddings
+        """
+        pass
+
+    @abstractmethod
+    def embed_texts(self, texts: List[str]) -> np.ndarray:
+        """
+        Generate embeddings for a list of texts
+
+        Args:
+            texts: List of texts to embed
+
+        Returns:
+            Array of embeddings
+        """
+        pass
+
+    @abstractmethod
+    def embed_text(self, text: str) -> np.ndarray:
+        """
+        Generate embedding for a single text
+
+        Args:
+            text: Text to embed
+
+        Returns:
+            Embedding array
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def dimension(self) -> int:
+        """Get the dimension of the embeddings"""
+        pass

src/crewai/knowledge/storage/knowledge_storage.py

@@ -13,7 +13,7 @@ from chromadb.api.types import OneOrMany
 from chromadb.config import Settings
 
 from crewai.knowledge.storage.base_knowledge_storage import BaseKnowledgeStorage
-from crewai.rag.embeddings.configurator import EmbeddingConfigurator
+from crewai.utilities import EmbeddingConfigurator
 from crewai.utilities.chromadb import sanitize_collection_name
 from crewai.utilities.constants import KNOWLEDGE_DIRECTORY
 from crewai.utilities.logger import Logger

src/crewai/memory/storage/mem0_storage.py

@@ -1,10 +1,10 @@
 import os
 from typing import Any, Dict, List
-from collections import defaultdict
+
 from mem0 import Memory, MemoryClient
-from crewai.utilities.chromadb import sanitize_collection_name
 
 from crewai.memory.storage.interface import Storage
+from crewai.utilities.chromadb import sanitize_collection_name
 
 MAX_AGENT_ID_LENGTH_MEM0 = 255
 
@@ -13,162 +13,47 @@ class Mem0Storage(Storage):
     """
     Extends Storage to handle embedding and searching across entities using Mem0.
     """
+
     def __init__(self, type, crew=None, config=None):
         super().__init__()
-
-        self._validate_type(type)
-        self.memory_type = type
-        self.crew = crew
-
-        # TODO: Memory config will be removed in the future the config will be passed as a parameter
-        self.config = config or getattr(crew, "memory_config", {}).get("config", {}) or {}
-
-        self._validate_user_id()
-        self._extract_config_values()
-        self._initialize_memory()
-
-    def _validate_type(self, type):
-        supported_types = {"user", "short_term", "long_term", "entities", "external"}
+        supported_types = ["user", "short_term", "long_term", "entities", "external"]
         if type not in supported_types:
             raise ValueError(
-                f"Invalid type '{type}' for Mem0Storage. Must be one of: {', '.join(supported_types)}"
+                f"Invalid type '{type}' for Mem0Storage. Must be one of: "
+                + ", ".join(supported_types)
             )
 
-    def _validate_user_id(self):
-        if self.memory_type == "user" and not self.config.get("user_id", ""):
+        self.memory_type = type
+        self.crew = crew
+        self.config = config or {}
+        # TODO: Memory config will be removed in the future the config will be passed as a parameter
+        self.memory_config = self.config or getattr(crew, "memory_config", {}) or {}
+
+        # User ID is required for user memory type "user" since it's used as a unique identifier for the user.
+        user_id = self._get_user_id()
+        if type == "user" and not user_id:
             raise ValueError("User ID is required for user memory type")
 
-    def _extract_config_values(self):
-        cfg = self.config
-        self.mem0_run_id = cfg.get("run_id")
-        self.includes = cfg.get("includes")
-        self.excludes = cfg.get("excludes")
-        self.custom_categories = cfg.get("custom_categories")
-        self.infer = cfg.get("infer", True)
+        # API key in memory config overrides the environment variable
+        config = self._get_config()
+        mem0_api_key = config.get("api_key") or os.getenv("MEM0_API_KEY")
+        mem0_org_id = config.get("org_id")
+        mem0_project_id = config.get("project_id")
+        mem0_local_config = config.get("local_mem0_config")
 
-    def _initialize_memory(self):
-        api_key = self.config.get("api_key") or os.getenv("MEM0_API_KEY")
-        org_id = self.config.get("org_id")
-        project_id = self.config.get("project_id")
-        local_config = self.config.get("local_mem0_config")
-
-        if api_key:
-            self.memory = (
-                MemoryClient(api_key=api_key, org_id=org_id, project_id=project_id)
-                if org_id and project_id
-                else MemoryClient(api_key=api_key)
-            )
-            if self.custom_categories:
-                self.memory.update_project(custom_categories=self.custom_categories)
+        # Initialize MemoryClient or Memory based on the presence of the mem0_api_key
+        if mem0_api_key:
+            if mem0_org_id and mem0_project_id:
+                self.memory = MemoryClient(
+                    api_key=mem0_api_key, org_id=mem0_org_id, project_id=mem0_project_id
+                )
+            else:
+                self.memory = MemoryClient(api_key=mem0_api_key)
         else:
-            self.memory = (
-                Memory.from_config(local_config)
-                if local_config and len(local_config)
-                else Memory()
-            )
-
-    def _create_filter_for_search(self):
-        """
-        Returns:
-            dict: A filter dictionary containing AND conditions for querying data.
-                - Includes user_id and agent_id if both are present.
-                - Includes user_id if only user_id is present.
-                - Includes agent_id if only agent_id is present.
-                - Includes run_id if memory_type is 'short_term' and mem0_run_id is present.
-        """
-        filter = defaultdict(list)
-
-        if self.memory_type == "short_term" and self.mem0_run_id:
-            filter["AND"].append({"run_id": self.mem0_run_id})
-        else:
-            user_id = self.config.get("user_id", "")
-            agent_id = self.config.get("agent_id", "")
-
-            if user_id and agent_id:
-                filter["OR"].append({"user_id": user_id})
-                filter["OR"].append({"agent_id": agent_id})
-            elif user_id:
-                filter["AND"].append({"user_id": user_id})
-            elif agent_id:
-                filter["AND"].append({"agent_id": agent_id})
-
-        return filter
-
-    def save(self, value: Any, metadata: Dict[str, Any]) -> None:
-        user_id = self.config.get("user_id", "")
-        assistant_message = [{"role" : "assistant","content" : value}]
-
-        base_metadata = {
-            "short_term": "short_term",
-            "long_term": "long_term",
-            "entities": "entity",
-            "external": "external"
-        }
-
-        # Shared base params
-        params: dict[str, Any] = {
-            "metadata": {"type": base_metadata[self.memory_type], **metadata},
-            "infer": self.infer
-        }
-
-        # MemoryClient-specific overrides
-        if isinstance(self.memory, MemoryClient):
-            params["includes"] = self.includes
-            params["excludes"] = self.excludes
-            params["output_format"] = "v1.1"
-            params["version"] = "v2"
-
-        if self.memory_type == "short_term" and self.mem0_run_id:
-            params["run_id"] = self.mem0_run_id
-
-        if user_id:
-            params["user_id"] = user_id
-
-        if agent_id := self.config.get("agent_id", self._get_agent_name()):
-            params["agent_id"] = agent_id
-
-        self.memory.add(assistant_message, **params)
-
-    def search(self,query: str,limit: int = 3,score_threshold: float = 0.35) -> List[Any]:
-        params = {
-            "query": query,
-            "limit": limit,
-            "version": "v2",
-            "output_format": "v1.1"
-            }
-
-        if user_id := self.config.get("user_id", ""):
-            params["user_id"] = user_id
-
-        memory_type_map = {
-            "short_term": {"type": "short_term"},
-            "long_term": {"type": "long_term"},
-            "entities": {"type": "entity"},
-            "external": {"type": "external"},
-        }
-
-        if self.memory_type in memory_type_map:
-            params["metadata"] = memory_type_map[self.memory_type]
-            if self.memory_type == "short_term":
-                params["run_id"] = self.mem0_run_id
-
-        # Discard the filters for now since we create the filters
-        # automatically when the crew is created.
-
-        params["filters"] = self._create_filter_for_search()
-        params['threshold'] = score_threshold
-
-        if isinstance(self.memory, Memory):
-            del params["metadata"], params["version"], params['output_format']
-            if params.get("run_id"):
-                del params["run_id"]
-
-        results = self.memory.search(**params)
-        return [r for r in results["results"]]
-
-    def reset(self):
-        if self.memory:
-            self.memory.reset()
+            if mem0_local_config and len(mem0_local_config):
+                self.memory = Memory.from_config(mem0_local_config)
+            else:
+                self.memory = Memory()
 
     def _sanitize_role(self, role: str) -> str:
         """
@@ -176,6 +61,77 @@ class Mem0Storage(Storage):
         """
         return role.replace("\n", "").replace(" ", "_").replace("/", "_")
 
+    def save(self, value: Any, metadata: Dict[str, Any]) -> None:
+        user_id = self._get_user_id()
+        agent_name = self._get_agent_name()
+        assistant_message = [{"role" : "assistant","content" : value}] 
+        params = None
+        if self.memory_type == "short_term":
+            params = {
+                "agent_id": agent_name,
+                "infer": False,
+                "metadata": {"type": "short_term", **metadata},
+            }
+        elif self.memory_type == "long_term":
+            params = {
+                "agent_id": agent_name,
+                "infer": False,
+                "metadata": {"type": "long_term", **metadata},
+            }
+        elif self.memory_type == "entities":
+            params = {
+                "agent_id": agent_name,
+                "infer": False,
+                "metadata": {"type": "entity", **metadata},
+            }
+        elif self.memory_type == "external":
+            params = {
+                "user_id": user_id,
+                "agent_id": agent_name,
+                "metadata": {"type": "external", **metadata},
+            }
+
+        if params:
+            if isinstance(self.memory, MemoryClient):
+                params["output_format"] = "v1.1"
+            
+            self.memory.add(assistant_message, **params)
+
+    def search(
+        self,
+        query: str,
+        limit: int = 3,
+        score_threshold: float = 0.35,
+    ) -> List[Any]:
+        params = {"query": query, "limit": limit, "output_format": "v1.1"}
+        if user_id := self._get_user_id():
+            params["user_id"] = user_id
+
+        agent_name = self._get_agent_name()
+        if self.memory_type == "short_term":
+            params["agent_id"] = agent_name
+            params["metadata"] = {"type": "short_term"}
+        elif self.memory_type == "long_term":
+            params["agent_id"] = agent_name
+            params["metadata"] = {"type": "long_term"}
+        elif self.memory_type == "entities":
+            params["agent_id"] = agent_name
+            params["metadata"] = {"type": "entity"}
+        elif self.memory_type == "external":
+            params["agent_id"] = agent_name
+            params["metadata"] = {"type": "external"}
+
+        # Discard the filters for now since we create the filters
+        # automatically when the crew is created.
+        if isinstance(self.memory, Memory):
+            del params["metadata"], params["output_format"]
+            
+        results = self.memory.search(**params)
+        return [r for r in results["results"] if r["score"] >= score_threshold]
+
+    def _get_user_id(self) -> str:
+        return self._get_config().get("user_id", "")
+
     def _get_agent_name(self) -> str:
         if not self.crew:
             return ""
@@ -183,4 +139,11 @@ class Mem0Storage(Storage):
         agents = self.crew.agents
         agents = [self._sanitize_role(agent.role) for agent in agents]
         agents = "_".join(agents)
-        return sanitize_collection_name(name=agents, max_collection_length=MAX_AGENT_ID_LENGTH_MEM0)
+        return sanitize_collection_name(name=agents,max_collection_length=MAX_AGENT_ID_LENGTH_MEM0)
+
+    def _get_config(self) -> Dict[str, Any]:
+        return self.config or getattr(self, "memory_config", {}).get("config", {}) or {}
+
+    def reset(self):
+        if self.memory:
+            self.memory.reset()

src/crewai/memory/storage/rag_storage.py

@@ -7,8 +7,8 @@ import uuid
 
 from typing import Any, Dict, List, Optional
 from chromadb.api import ClientAPI
-from crewai.rag.storage.base_rag_storage import BaseRAGStorage
-from crewai.rag.embeddings.configurator import EmbeddingConfigurator
+from crewai.memory.storage.base_rag_storage import BaseRAGStorage
+from crewai.utilities import EmbeddingConfigurator
 from crewai.utilities.chromadb import create_persistent_client
 from crewai.utilities.constants import MAX_FILE_NAME_LENGTH
 from crewai.utilities.paths import db_storage_path

src/crewai/rag/__init__.py

@@ -1 +0,0 @@
-"""RAG (Retrieval-Augmented Generation) infrastructure for CrewAI."""

src/crewai/rag/embeddings/__init__.py

@@ -1 +0,0 @@
-"""Embedding components for RAG infrastructure."""

src/crewai/rag/storage/__init__.py

@@ -1 +0,0 @@
-"""Storage components for RAG infrastructure."""

src/crewai/utilities/__init__.py

@@ -10,6 +10,7 @@ from .rpm_controller import RPMController
 from .exceptions.context_window_exceeding_exception import (
     LLMContextLengthExceededException,
 )
+from .embedding_configurator import EmbeddingConfigurator
 
 __all__ = [
     "Converter",
@@ -23,4 +24,5 @@ __all__ = [
     "RPMController",
     "YamlParser",
     "LLMContextLengthExceededException",
+    "EmbeddingConfigurator",
 ]

src/crewai/utilities/embedding_configurator.py

@@ -38,14 +38,7 @@ class EmbeddingConfigurator:
                 f"Unsupported embedding provider: {provider}, supported providers: {list(self.embedding_functions.keys())}"
             )
 
-        try:
-            embedding_function = self.embedding_functions[provider]
-        except ImportError as e:
-            missing_package = str(e).split()[-1]
-            raise ImportError( 
-                f"{missing_package} is not installed. Please install it with: pip install {missing_package}"
-            )
-
+        embedding_function = self.embedding_functions[provider]
         return (
             embedding_function(config)
             if provider == "custom"

src/crewai/utilities/events/base_events.py

@@ -1,5 +1,6 @@
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import Any, Dict, Optional
+
 from pydantic import BaseModel, Field
 
 from crewai.utilities.serialization import to_serializable
@@ -8,7 +9,7 @@ from crewai.utilities.serialization import to_serializable
 class BaseEvent(BaseModel):
     """Base class for all events"""
 
-    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    timestamp: datetime = Field(default_factory=datetime.now)
     type: str
     source_fingerprint: Optional[str] = None  # UUID string of the source entity
     source_type: Optional[str] = None  # "agent", "task", "crew", "memory", "entity_memory", "short_term_memory", "long_term_memory", "external_memory"

tests/flow_test.py

@@ -755,15 +755,3 @@ def test_multiple_routers_from_same_trigger():
     assert execution_order.index("anemia_analysis") > execution_order.index(
         "anemia_router"
     )
-
-
-def test_flow_name():
-    class MyFlow(Flow):
-        name = "MyFlow"
-
-        @start()
-        def start(self):
-            return "Hello, world!"
-
-    flow = MyFlow()
-    assert flow.name == "MyFlow"

tests/storage/test_mem0_storage.py

@@ -55,11 +55,10 @@ def mem0_storage_with_mocked_config(mock_mem0_memory):
         }
 
         # Instantiate the class with memory_config
-        # Parameters like run_id, includes, and excludes doesn't matter in Memory OSS
         crew = MockCrew(
             memory_config={
                 "provider": "mem0",
-                "config": {"user_id": "test_user", "local_mem0_config": config, "run_id": "my_run_id", "includes": "include1","excludes": "exclude1", "infer" : True},
+                "config": {"user_id": "test_user", "local_mem0_config": config},
             }
         )
 
@@ -96,10 +95,6 @@ def mem0_storage_with_memory_client_using_config_from_crew(mock_mem0_memory_clie
                     "api_key": "ABCDEFGH",
                     "org_id": "my_org_id",
                     "project_id": "my_project_id",
-                    "run_id": "my_run_id",
-                    "includes": "include1",
-                    "excludes": "exclude1",
-                    "infer": True
                 },
             }
         )
@@ -155,75 +150,28 @@ def test_mem0_storage_with_explict_config(
     assert (
         mem0_storage_with_memory_client_using_explictly_config.config == expected_config
     )
-
-
-def test_mem0_storage_updates_project_with_custom_categories(mock_mem0_memory_client):
-    mock_mem0_memory_client.update_project = MagicMock()
-
-    new_categories = [
-    {"lifestyle_management_concerns": "Tracks daily routines, habits, hobbies and interests including cooking, time management and work-life balance"},
-    ]
-
-    crew = MockCrew(
-        memory_config={
-            "provider": "mem0",
-            "config": {
-                "user_id": "test_user",
-                "api_key": "ABCDEFGH",
-                "org_id": "my_org_id",
-                "project_id": "my_project_id",
-                "custom_categories": new_categories,
-            },
-        }
+    assert (
+        mem0_storage_with_memory_client_using_explictly_config.memory_config
+        == expected_config
     )
 
-    with patch.object(MemoryClient, "__new__", return_value=mock_mem0_memory_client):
-        _ = Mem0Storage(type="short_term", crew=crew)
-
-    mock_mem0_memory_client.update_project.assert_called_once_with(
-        custom_categories=new_categories
-    )
-
-
-
 
 def test_save_method_with_memory_oss(mem0_storage_with_mocked_config):
     """Test save method for different memory types"""
     mem0_storage, _, _ = mem0_storage_with_mocked_config
     mem0_storage.memory.add = MagicMock()
-
+    
     # Test short_term memory type (already set in fixture)
     test_value = "This is a test memory"
     test_metadata = {"key": "value"}
-
+    
     mem0_storage.save(test_value, test_metadata)
-
+    
     mem0_storage.memory.add.assert_called_once_with(
-        [{"role": "assistant" , "content": test_value}],
-        infer=True,
+        [{'role': 'assistant' , 'content': test_value}],
+        agent_id="Test_Agent",
+        infer=False,
         metadata={"type": "short_term", "key": "value"},
-        run_id="my_run_id",
-        user_id="test_user",
-        agent_id='Test_Agent'
-    )
-
-def test_save_method_with_multiple_agents(mem0_storage_with_mocked_config):
-    mem0_storage, _, _ = mem0_storage_with_mocked_config
-    mem0_storage.crew.agents = [MagicMock(role="Test Agent"), MagicMock(role="Test Agent 2"), MagicMock(role="Test Agent 3")]
-    mem0_storage.memory.add = MagicMock()
-
-    test_value = "This is a test memory"
-    test_metadata = {"key": "value"}
-
-    mem0_storage.save(test_value, test_metadata)
-
-    mem0_storage.memory.add.assert_called_once_with(
-        [{"role": "assistant" , "content": test_value}],
-        infer=True,
-        metadata={"type": "short_term", "key": "value"},
-        run_id="my_run_id",
-        user_id="test_user",
-        agent_id='Test_Agent_Test_Agent_2_Test_Agent_3'
     )
 
 
@@ -231,24 +179,19 @@ def test_save_method_with_memory_client(mem0_storage_with_memory_client_using_co
     """Test save method for different memory types"""
     mem0_storage = mem0_storage_with_memory_client_using_config_from_crew
     mem0_storage.memory.add = MagicMock()
-
+    
     # Test short_term memory type (already set in fixture)
     test_value = "This is a test memory"
     test_metadata = {"key": "value"}
-
+    
     mem0_storage.save(test_value, test_metadata)
-
+    
     mem0_storage.memory.add.assert_called_once_with(
         [{'role': 'assistant' , 'content': test_value}],
-        infer=True,
+        agent_id="Test_Agent",
+        infer=False,
         metadata={"type": "short_term", "key": "value"},
-        version="v2",
-        run_id="my_run_id",
-        includes="include1",
-        excludes="exclude1",
-        output_format='v1.1',
-        user_id='test_user',
-         agent_id='Test_Agent'
+        output_format="v1.1"
     )
 
 
@@ -261,14 +204,13 @@ def test_search_method_with_memory_oss(mem0_storage_with_mocked_config):
     results = mem0_storage.search("test query", limit=5, score_threshold=0.5)
 
     mem0_storage.memory.search.assert_called_once_with(
-        query="test query",
-        limit=5,
-        user_id="test_user",
-        filters={'AND': [{'run_id': 'my_run_id'}]},
-        threshold=0.5
+        query="test query", 
+        limit=5, 
+        agent_id="Test_Agent",
+        user_id="test_user"
     )
 
-    assert len(results) == 2
+    assert len(results) == 1
     assert results[0]["content"] == "Result 1"
 
 
@@ -281,85 +223,13 @@ def test_search_method_with_memory_client(mem0_storage_with_memory_client_using_
     results = mem0_storage.search("test query", limit=5, score_threshold=0.5)
 
     mem0_storage.memory.search.assert_called_once_with(
-        query="test query",
-        limit=5,
+        query="test query", 
+        limit=5, 
+        agent_id="Test_Agent", 
         metadata={"type": "short_term"},
         user_id="test_user",
-        version='v2',
-        run_id="my_run_id",
-        output_format='v1.1',
-        filters={'AND': [{'run_id': 'my_run_id'}]},
-        threshold=0.5
+        output_format='v1.1'
     )
 
-    assert len(results) == 2
-    assert results[0]["content"] == "Result 1"
-
-
-def test_mem0_storage_default_infer_value(mock_mem0_memory_client):
-    """Test that Mem0Storage sets infer=True by default for short_term memory."""
-    with patch.object(MemoryClient, "__new__", return_value=mock_mem0_memory_client):
-        crew = MockCrew(
-            memory_config={
-                "provider": "mem0",
-                "config": {
-                    "user_id": "test_user",
-                    "api_key": "ABCDEFGH"
-                },
-            }
-        )
-
-        mem0_storage = Mem0Storage(type="short_term", crew=crew)
-        assert mem0_storage.infer is True
-
-def test_save_memory_using_agent_entity(mock_mem0_memory_client):
-    config = {
-        "agent_id": "agent-123",
-    }
-
-    mock_memory = MagicMock(spec=Memory)
-    with patch.object(Memory, "__new__", return_value=mock_memory):
-        mem0_storage = Mem0Storage(type="external", config=config)
-        mem0_storage.save("test memory", {"key": "value"})
-        mem0_storage.memory.add.assert_called_once_with(
-            [{'role': 'assistant' , 'content': 'test memory'}],
-            infer=True,
-            metadata={"type": "external", "key": "value"},
-            agent_id="agent-123",
-        )
-
-def test_search_method_with_agent_entity():
-    mem0_storage = Mem0Storage(type="external", config={"agent_id": "agent-123"})
-    mock_results = {"results": [{"score": 0.9, "content": "Result 1"}, {"score": 0.4, "content": "Result 2"}]}
-    mem0_storage.memory.search = MagicMock(return_value=mock_results)
-
-    results = mem0_storage.search("test query", limit=5, score_threshold=0.5)
-
-    mem0_storage.memory.search.assert_called_once_with(
-        query="test query",
-        limit=5,
-        filters={"AND": [{"agent_id": "agent-123"}]},
-        threshold=0.5,
-    )
-
-    assert len(results) == 2
-    assert results[0]["content"] == "Result 1"
-
-
-def test_search_method_with_agent_id_and_user_id():
-    mem0_storage = Mem0Storage(type="external", config={"agent_id": "agent-123", "user_id": "user-123"})
-    mock_results = {"results": [{"score": 0.9, "content": "Result 1"}, {"score": 0.4, "content": "Result 2"}]}
-    mem0_storage.memory.search = MagicMock(return_value=mock_results)
-
-    results = mem0_storage.search("test query", limit=5, score_threshold=0.5)
-
-    mem0_storage.memory.search.assert_called_once_with(
-        query="test query",
-        limit=5,
-        user_id='user-123',
-        filters={"OR": [{"user_id": "user-123"}, {"agent_id": "agent-123"}]},
-        threshold=0.5,
-    )
-
-    assert len(results) == 2
+    assert len(results) == 1
     assert results[0]["content"] == "Result 1"

tests/utilities/test_embedding_configuration.py

@@ -1,25 +0,0 @@
-from unittest.mock import patch
-
-import pytest
-
-from crewai.rag.embeddings.configurator import EmbeddingConfigurator
-
-
-def test_configure_embedder_importerror():
-    configurator = EmbeddingConfigurator()
-    
-    embedder_config = {
-        'provider': 'openai',
-        'config': {
-            'model': 'text-embedding-ada-002',
-        }
-    }
-    
-    with patch('chromadb.utils.embedding_functions.openai_embedding_function.OpenAIEmbeddingFunction') as mock_openai:
-        mock_openai.side_effect = ImportError("Module not found.")
-        
-        with pytest.raises(ImportError) as exc_info:
-            configurator.configure_embedder(embedder_config)
-
-        assert str(exc_info.value) == "Module not found."
-        mock_openai.assert_called_once()

tests/utilities/test_events.py

@@ -64,8 +64,7 @@ def base_agent():
         llm="gpt-4o-mini",
         goal="Just say hi",
         backstory="You are a helpful assistant that just says hi",
-    )
-
+)
 
 @pytest.fixture(scope="module")
 def base_task(base_agent):
@@ -75,7 +74,6 @@ def base_task(base_agent):
         agent=base_agent,
     )
 
-
 event_listener = EventListener()
 
 
@@ -450,27 +448,6 @@ def test_flow_emits_start_event():
     assert received_events[0].type == "flow_started"
 
 
-def test_flow_name_emitted_to_event_bus():
-    received_events = []
-
-    class MyFlowClass(Flow):
-        name = "PRODUCTION_FLOW"
-
-        @start()
-        def start(self):
-            return "Hello, world!"
-
-    @crewai_event_bus.on(FlowStartedEvent)
-    def handle_flow_start(source, event):
-        received_events.append(event)
-
-    flow = MyFlowClass()
-    flow.kickoff()
-
-    assert len(received_events) == 1
-    assert received_events[0].flow_name == "PRODUCTION_FLOW"
-
-
 def test_flow_emits_finish_event():
     received_events = []
 
@@ -779,7 +756,6 @@ def test_streaming_empty_response_handling():
     received_chunks = []
 
     with crewai_event_bus.scoped_handlers():
-
         @crewai_event_bus.on(LLMStreamChunkEvent)
         def handle_stream_chunk(source, event):
             received_chunks.append(event.chunk)
@@ -817,7 +793,6 @@ def test_streaming_empty_response_handling():
             # Restore the original method
             llm.call = original_call
 
-
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_stream_llm_emits_event_with_task_and_agent_info():
     completed_event = []
@@ -826,7 +801,6 @@ def test_stream_llm_emits_event_with_task_and_agent_info():
     stream_event = []
 
     with crewai_event_bus.scoped_handlers():
-
         @crewai_event_bus.on(LLMCallFailedEvent)
         def handle_llm_failed(source, event):
             failed_event.append(event)
@@ -853,7 +827,7 @@ def test_stream_llm_emits_event_with_task_and_agent_info():
             description="Just say hi",
             expected_output="hi",
             llm=LLM(model="gpt-4o-mini", stream=True),
-            agent=agent,
+            agent=agent
         )
 
         crew = Crew(agents=[agent], tasks=[task])
@@ -881,7 +855,6 @@ def test_stream_llm_emits_event_with_task_and_agent_info():
     assert set(all_task_id) == {task.id}
     assert set(all_task_name) == {task.name}
 
-
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_llm_emits_event_with_task_and_agent_info(base_agent, base_task):
     completed_event = []
@@ -890,7 +863,6 @@ def test_llm_emits_event_with_task_and_agent_info(base_agent, base_task):
     stream_event = []
 
     with crewai_event_bus.scoped_handlers():
-
         @crewai_event_bus.on(LLMCallFailedEvent)
         def handle_llm_failed(source, event):
             failed_event.append(event)
@@ -932,7 +904,6 @@ def test_llm_emits_event_with_task_and_agent_info(base_agent, base_task):
     assert set(all_task_id) == {base_task.id}
     assert set(all_task_name) == {base_task.name}
 
-
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_llm_emits_event_with_lite_agent():
     completed_event = []
@@ -941,7 +912,6 @@ def test_llm_emits_event_with_lite_agent():
     stream_event = []
 
     with crewai_event_bus.scoped_handlers():
-
         @crewai_event_bus.on(LLMCallFailedEvent)
         def handle_llm_failed(source, event):
             failed_event.append(event)
@@ -966,6 +936,7 @@ def test_llm_emits_event_with_lite_agent():
         )
         agent.kickoff(messages=[{"role": "user", "content": "say hi!"}])
 
+
     assert len(completed_event) == 2
     assert len(failed_event) == 0
     assert len(started_event) == 2

uv.lock

@@ -193,24 +193,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
 ]
 
-[[package]]
-name = "anthropic"
-version = "0.59.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "distro" },
-    { name = "httpx" },
-    { name = "jiter" },
-    { name = "pydantic" },
-    { name = "sniffio" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/52daff015f5a1f24eec891b3041f5f816712fea8b5113dc76638bcbc23d8/anthropic-0.59.0.tar.gz", hash = "sha256:d710d1ef0547ebbb64b03f219e44ba078e83fc83752b96a9b22e9726b523fd8f", size = 425679, upload-time = "2025-07-23T16:23:16.901Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3c/b1/03f680393eac04afd8f2be44ee0e39e033c40faf43dbc1c11764b07a2687/anthropic-0.59.0-py3-none-any.whl", hash = "sha256:cbc8b3dccef66ad6435c4fa1d317e5ebb092399a4b88b33a09dc4bf3944c3183", size = 293057, upload-time = "2025-07-23T16:23:14.934Z" },
-]
-
 [[package]]
 name = "anyio"
 version = "4.9.0"
@@ -385,23 +367,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/10/cb/f2ad4230dc2eb1a74edf38f1a38b9b52277f75bef262d8908e60d957e13c/blinker-1.9.0-py3-none-any.whl", hash = "sha256:ba0efaa9080b619ff2f3459d1d500c57bddea4a6b424b60a91141db6fd2f08bc", size = 8458, upload-time = "2024-11-08T17:25:46.184Z" },
 ]
 
-[[package]]
-name = "browserbase"
-version = "1.4.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anyio" },
-    { name = "distro" },
-    { name = "httpx" },
-    { name = "pydantic" },
-    { name = "sniffio" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/71/df/17ac5e1116ab8f1264c6a9718f935358d20bdcd8ae0e3d1f18fd580cd871/browserbase-1.4.0.tar.gz", hash = "sha256:e2ed36f513c8630b94b826042c4bb9f497c333f3bd28e5b76cb708c65b4318a0", size = 122103, upload-time = "2025-05-16T20:50:40.802Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/58/13/4191423982a2ec69dc8c10a1c4b94a50a0861f49be81ffc19621b75841bc/browserbase-1.4.0-py3-none-any.whl", hash = "sha256:ea9f1fb4a88921975b8b9606835c441a59d8ce82ce00313a6d48bbe8e30f79fb", size = 98044, upload-time = "2025-05-16T20:50:39.331Z" },
-]
-
 [[package]]
 name = "build"
 version = "1.2.2.post1"
@@ -798,7 +763,7 @@ requires-dist = [
     { name = "blinker", specifier = ">=1.9.0" },
     { name = "chromadb", specifier = ">=0.5.23" },
     { name = "click", specifier = ">=8.1.7" },
-    { name = "crewai-tools", marker = "extra == 'tools'", specifier = "~=0.59.0" },
+    { name = "crewai-tools", marker = "extra == 'tools'", specifier = "~=0.55.0" },
     { name = "docling", marker = "extra == 'docling'", specifier = ">=2.12.0" },
     { name = "instructor", specifier = ">=1.3.3" },
     { name = "json-repair", specifier = "==0.25.2" },
@@ -850,7 +815,7 @@ dev = [
 
 [[package]]
 name = "crewai-tools"
-version = "0.59.0"
+version = "0.55.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "chromadb" },
@@ -860,17 +825,15 @@ dependencies = [
     { name = "embedchain" },
     { name = "lancedb" },
     { name = "openai" },
-    { name = "portalocker" },
     { name = "pydantic" },
     { name = "pyright" },
     { name = "pytube" },
     { name = "requests" },
-    { name = "stagehand" },
     { name = "tiktoken" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/10/cd/af005e7dca5a35ed6000db2d1594acad890997b92172d8af2c1d9a83784e/crewai_tools-0.59.0.tar.gz", hash = "sha256:030e4b65446f4c6eccdcba5380bbdc90896de74589cb1bdb3cabc2c22c83f326", size = 1032093, upload-time = "2025-07-30T21:15:54.182Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/75/d8cae7f84e78a93210f91a4580aec8eb72dc1f33368655a8ad4e381d575b/crewai_tools-0.55.0.tar.gz", hash = "sha256:0961821128b07148197b89b1827b6c0a548424fa8a01674991528a56fd03fe81", size = 1015820, upload-time = "2025-07-16T19:16:36.648Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/b2/6b11d770fda6df99ddc49bdb26d3cb0b5efd026ff395a72ca5eeb704c335/crewai_tools-0.59.0-py3-none-any.whl", hash = "sha256:816297934eb352368ff0869a0eb11dd9febb4c40b6d0eda8e6eba8f3e426f446", size = 657025, upload-time = "2025-07-30T21:15:52.531Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/98/da76dff3b814f5a6c9cbce7dacc09462669174083fd872b21c9373cdd412/crewai_tools-0.55.0-py3-none-any.whl", hash = "sha256:f69967394a9b5c85cab8722dfbae320e0a80d6124a3f36063c5864fe3516ee06", size = 634456, upload-time = "2025-07-16T19:16:35.259Z" },
 ]
 
 [[package]]
@@ -3825,25 +3788,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/fe/39/979e8e21520d4e47a0bbe349e2713c0aac6f3d853d0e5b34d76206c439aa/platformdirs-4.3.8-py3-none-any.whl", hash = "sha256:ff7059bb7eb1179e2685604f4aaf157cfd9535242bd23742eadc3c13542139b4", size = 18567, upload-time = "2025-05-07T22:47:40.376Z" },
 ]
 
-[[package]]
-name = "playwright"
-version = "1.54.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "greenlet" },
-    { name = "pyee" },
-]
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f3/09/33d5bfe393a582d8dac72165a9e88b274143c9df411b65ece1cc13f42988/playwright-1.54.0-py3-none-macosx_10_13_x86_64.whl", hash = "sha256:bf3b845af744370f1bd2286c2a9536f474cc8a88dc995b72ea9a5be714c9a77d", size = 40439034, upload-time = "2025-07-22T13:58:04.816Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/7b/51882dc584f7aa59f446f2bb34e33c0e5f015de4e31949e5b7c2c10e54f0/playwright-1.54.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:780928b3ca2077aea90414b37e54edd0c4bbb57d1aafc42f7aa0b3fd2c2fac02", size = 38702308, upload-time = "2025-07-22T13:58:08.211Z" },
-    { url = "https://files.pythonhosted.org/packages/73/a1/7aa8ae175b240c0ec8849fcf000e078f3c693f9aa2ffd992da6550ea0dff/playwright-1.54.0-py3-none-macosx_11_0_universal2.whl", hash = "sha256:81d0b6f28843b27f288cfe438af0a12a4851de57998009a519ea84cee6fbbfb9", size = 40439037, upload-time = "2025-07-22T13:58:11.37Z" },
-    { url = "https://files.pythonhosted.org/packages/34/a9/45084fd23b6206f954198296ce39b0acf50debfdf3ec83a593e4d73c9c8a/playwright-1.54.0-py3-none-manylinux1_x86_64.whl", hash = "sha256:09919f45cc74c64afb5432646d7fef0d19fff50990c862cb8d9b0577093f40cc", size = 45920135, upload-time = "2025-07-22T13:58:14.494Z" },
-    { url = "https://files.pythonhosted.org/packages/02/d4/6a692f4c6db223adc50a6e53af405b45308db39270957a6afebddaa80ea2/playwright-1.54.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:13ae206c55737e8e3eae51fb385d61c0312eeef31535643bb6232741b41b6fdc", size = 45302695, upload-time = "2025-07-22T13:58:18.901Z" },
-    { url = "https://files.pythonhosted.org/packages/72/7a/4ee60a1c3714321db187bebbc40d52cea5b41a856925156325058b5fca5a/playwright-1.54.0-py3-none-win32.whl", hash = "sha256:0b108622ffb6906e28566f3f31721cd57dda637d7e41c430287804ac01911f56", size = 35469309, upload-time = "2025-07-22T13:58:21.917Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/77/8f8fae05a242ef639de963d7ae70a69d0da61d6d72f1207b8bbf74ffd3e7/playwright-1.54.0-py3-none-win_amd64.whl", hash = "sha256:9e5aee9ae5ab1fdd44cd64153313a2045b136fcbcfb2541cc0a3d909132671a2", size = 35469311, upload-time = "2025-07-22T13:58:24.707Z" },
-    { url = "https://files.pythonhosted.org/packages/33/ff/99a6f4292a90504f2927d34032a4baf6adb498dc3f7cf0f3e0e22899e310/playwright-1.54.0-py3-none-win_arm64.whl", hash = "sha256:a975815971f7b8dca505c441a4c56de1aeb56a211290f8cc214eeef5524e8d75", size = 31239119, upload-time = "2025-07-22T13:58:27.56Z" },
-]
-
 [[package]]
 name = "pluggy"
 version = "1.6.0"
@@ -4276,18 +4220,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/58/f0/427018098906416f580e3cf1366d3b1abfb408a0652e9f31600c24a1903c/pydantic_settings-2.10.1-py3-none-any.whl", hash = "sha256:a60952460b99cf661dc25c29c0ef171721f98bfcb52ef8d9ea4c943d7c8cc796", size = 45235, upload-time = "2025-06-24T13:26:45.485Z" },
 ]
 
-[[package]]
-name = "pyee"
-version = "13.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/95/03/1fd98d5841cd7964a27d729ccf2199602fe05eb7a405c1462eb7277945ed/pyee-13.0.0.tar.gz", hash = "sha256:b391e3c5a434d1f5118a25615001dbc8f669cf410ab67d04c4d4e07c55481c37", size = 31250, upload-time = "2025-03-17T18:53:15.955Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9b/4d/b9add7c84060d4c1906abe9a7e5359f2a60f7a9a4f67268b2766673427d8/pyee-13.0.0-py3-none-any.whl", hash = "sha256:48195a3cddb3b1515ce0695ed76036b5ccc2ef3a9f963ff9f77aec0139845498", size = 15730, upload-time = "2025-03-17T18:53:14.532Z" },
-]
-
 [[package]]
 name = "pygments"
 version = "2.19.2"
@@ -5439,27 +5371,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" },
 ]
 
-[[package]]
-name = "stagehand"
-version = "0.4.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "anthropic" },
-    { name = "browserbase" },
-    { name = "httpx" },
-    { name = "litellm" },
-    { name = "openai" },
-    { name = "playwright" },
-    { name = "pydantic" },
-    { name = "python-dotenv" },
-    { name = "requests" },
-    { name = "rich" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/e8/82/24f6ade40784ad51b6e2687ff2e077d02210bb0db35fdb3302d7425c9dc5/stagehand-0.4.1.tar.gz", hash = "sha256:721934b47b0756519ce9920d50879b58a3e919f44fa11ac1b1957490f3903124", size = 89751, upload-time = "2025-07-18T19:51:05.216Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/84/db/594daf76d214ceed02733f1225ea2e66ab7c84e454cbf5da67b3f5e8447b/stagehand-0.4.1-py3-none-any.whl", hash = "sha256:a212f5d018e0e44991c28f27a9140fa841aca0365c72b0d97dd137faa8f1c226", size = 100874, upload-time = "2025-07-18T19:51:03.903Z" },
-]
-
 [[package]]
 name = "starlette"
 version = "0.46.2"