try again

* improve tool text descriptoin and args

* fix lint

* Drop print

* add back in docstring

README.md

@@ -351,7 +351,7 @@ pre-commit install
 ### Running Tests
 
 ```bash
-uvx pytest
+uv run pytest .
 ```
 
 ### Running static type checks

docs/concepts/agents.mdx

@@ -31,16 +31,17 @@ Think of an agent as a member of a team, with specific skills and a particular j
 | **Max RPM** *(optional)*   | `max_rpm`  | Max RPM is the maximum number of requests per minute the agent can perform to avoid rate limits. It's optional and can be left unspecified, with a default value of `None`.                                                                               |
 | **Max Execution Time** *(optional)*   | `max_execution_time`  | Max Execution Time is the maximum execution time for an agent to execute a task. It's optional and can be left unspecified, with a default value of `None`, meaning no max execution time.                                                                     |
 | **Verbose** *(optional)*   | `verbose`  | Setting this to `True` configures the internal logger to provide detailed execution logs, aiding in debugging and monitoring. Default is `False`.                                                                                              |
-| **Allow Delegation** *(optional)* | `allow_delegation`  | Agents can delegate tasks or questions to one another, ensuring that each task is handled by the most suitable agent. Default is `False`.
+| **Allow Delegation** *(optional)* | `allow_delegation`  | Agents can delegate tasks or questions to one another, ensuring that each task is handled by the most suitable agent. Default is `False`.                                                                                                      |
 | **Step Callback** *(optional)* | `step_callback`  | A function that is called after each step of the agent. This can be used to log the agent's actions or to perform other operations. It will overwrite the crew `step_callback`.                                                               |
 | **Cache** *(optional)*     | `cache`  | Indicates if the agent should use a cache for tool usage. Default is `True`.                                                                                                                                                                  |
 | **System Template** *(optional)*     | `system_template`  | Specifies the system format for the agent. Default is `None`.                                                                                                                                                                  |
 | **Prompt Template** *(optional)*     | `prompt_template`  | Specifies the prompt format for the agent. Default is `None`.                                                                                                                                                                  |
 | **Response Template** *(optional)*     | `response_template`  | Specifies the response format for the agent. Default is `None`.                                                                                                                                                                  |
 | **Allow Code Execution** *(optional)*     | `allow_code_execution`  | Enable code execution for the agent. Default is `False`.                                                                                                                                                                  |
-| **Max Retry Limit** *(optional)*     | `max_retry_limit`  | Maximum number of retries for an agent to execute a task when an error occurs. Default is `2`.
+| **Max Retry Limit** *(optional)*     | `max_retry_limit`  | Maximum number of retries for an agent to execute a task when an error occurs. Default is `2`.                                                                                                                                                                  |
 | **Use System Prompt** *(optional)*     | `use_system_prompt`  | Adds the ability to not use system prompt (to support o1 models). Default is `True`.                                                                                                                                                                  |
 | **Respect Context Window** *(optional)*     | `respect_context_window`  | Summary strategy to avoid overflowing the context window. Default is `True`.                                                                                                                                                                  |
+| **Code Execution Mode** *(optional)* | `code_execution_mode` | Determines the mode for code execution: 'safe' (using Docker) or 'unsafe' (direct execution on the host machine). Default is `safe`.                                                                                                          |
 
 ## Creating an agent
 
@@ -83,6 +84,7 @@ agent = Agent(
   max_retry_limit=2,  # Optional
   use_system_prompt=True,  # Optional
   respect_context_window=True,  # Optional
+  code_execution_mode='safe',  # Optional, defaults to 'safe'
 )
 ```
 
@@ -156,4 +158,4 @@ crew = my_crew.kickoff(inputs={"input": "Mark Twain"})
 ## Conclusion
 
 Agents are the building blocks of the CrewAI framework. By understanding how to define and interact with agents, 
-you can create sophisticated AI systems that leverage the power of collaborative intelligence.
+you can create sophisticated AI systems that leverage the power of collaborative intelligence. The `code_execution_mode` attribute provides flexibility in how agents execute code, allowing for both secure and direct execution options.

docs/concepts/cli.mdx

@@ -6,7 +6,7 @@ icon: terminal
 
 # CrewAI CLI Documentation
 
-The CrewAI CLI provides a set of commands to interact with CrewAI, allowing you to create, train, run, and manage crews and pipelines.
+The CrewAI CLI provides a set of commands to interact with CrewAI, allowing you to create, train, run, and manage crews & flows.
 
 ## Installation
 
@@ -146,3 +146,34 @@ crewai run
 Make sure to run these commands from the directory where your CrewAI project is set up. 
 Some commands may require additional configuration or setup within your project structure.
 </Note>
+
+
+### 9. API Keys
+
+When running ```crewai create crew``` command, the CLI will first show you the top 5 most common LLM providers and ask you to select one.
+
+Once you've selected an LLM provider, you will be prompted for API keys.
+
+#### Initial API key providers
+
+The CLI will initially prompt for API keys for the following services:
+
+* OpenAI
+* Groq
+* Anthropic
+* Google Gemini
+
+When you select a provider, the CLI will prompt you to enter your API key.
+
+#### Other Options
+
+If you select option 6, you will be able to select from a list of LiteLLM supported providers.
+
+When you select a provider, the CLI will prompt you to enter the Key name and the API key.
+
+See the following link for each provider's key name:
+
+* [LiteLLM Providers](https://docs.litellm.ai/docs/providers)
+
+
+

docs/concepts/flows.mdx

@@ -560,6 +560,40 @@ uv run kickoff
 
 The flow will execute, and you should see the output in the console.
 
+
+### Adding Additional Crews Using the CLI
+
+Once you have created your initial flow, you can easily add additional crews to your project using the CLI. This allows you to expand your flow's capabilities by integrating new crews without starting from scratch.
+
+To add a new crew to your existing flow, use the following command:
+
+```bash
+crewai flow add-crew <crew_name>
+```
+
+This command will create a new directory for your crew within the `crews` folder of your flow project. It will include the necessary configuration files and a crew definition file, similar to the initial setup.
+
+#### Folder Structure
+
+After adding a new crew, your folder structure will look like this:
+
+name_of_flow/
+├── crews/
+│   ├── poem_crew/
+│   │   ├── config/
+│   │   │   ├── agents.yaml
+│   │   │   └── tasks.yaml
+│   │   └── poem_crew.py
+│   └── name_of_crew/
+│       ├── config/
+│       │   ├── agents.yaml
+│       │   └── tasks.yaml
+│       └── name_of_crew.py
+
+You can then customize the `agents.yaml` and `tasks.yaml` files to define the agents and tasks for your new crew. The `name_of_crew.py` file will contain the crew's logic, which you can modify to suit your needs.
+
+By using the CLI to add additional crews, you can efficiently build complex AI workflows that leverage multiple crews working together.
+
 ## Plot Flows
 
 Visualizing your AI workflows can provide valuable insights into the structure and execution paths of your flows. CrewAI offers a powerful visualization tool that allows you to generate interactive plots of your flows, making it easier to understand and optimize your AI workflows.

docs/concepts/memory.mdx

@@ -105,9 +105,48 @@ my_crew = Crew(
     process=Process.sequential,
     memory=True,
     verbose=True,
-    embedder=embedding_functions.OpenAIEmbeddingFunction(
-            api_key=os.getenv("OPENAI_API_KEY"), model_name="text-embedding-3-small"
-        )
+    embedder={
+        "provider": "openai",
+        "config": {
+            "model": 'text-embedding-3-small'
+        }
+    }
+)
+```
+Alternatively, you can directly pass the OpenAIEmbeddingFunction to the embedder parameter.
+
+Example:
+```python Code
+from crewai import Crew, Agent, Task, Process
+from chromadb.utils.embedding_functions import OpenAIEmbeddingFunction
+
+my_crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process=Process.sequential,
+    memory=True,
+    verbose=True,
+    embedder=OpenAIEmbeddingFunction(api_key=os.getenv("OPENAI_API_KEY"), model_name="text-embedding-3-small"),
+)
+```
+
+### Using Ollama embeddings
+
+```python Code
+from crewai import Crew, Agent, Task, Process
+
+my_crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process=Process.sequential,
+    memory=True,
+    verbose=True,
+    embedder={
+        "provider": "ollama",
+        "config": {
+            "model": "mxbai-embed-large"
+        }
+    }
 )
 ```
 
@@ -122,16 +161,20 @@ my_crew = Crew(
     process=Process.sequential,
     memory=True,
     verbose=True,
-    embedder=embedding_functions.OpenAIEmbeddingFunction(
-            api_key=os.getenv("OPENAI_API_KEY"),
-            model_name="text-embedding-ada-002"
-    )
+    embedder={
+        "provider": "google",
+        "config": {
+            "api_key": "<YOUR_API_KEY>",
+            "model_name": "<model_name>"
+        }
+    }
 )
 ```
 
 ### Using Azure OpenAI embeddings
 
 ```python Code
+from chromadb.utils.embedding_functions import OpenAIEmbeddingFunction
 from crewai import Crew, Agent, Task, Process
 
 my_crew = Crew(
@@ -140,7 +183,7 @@ my_crew = Crew(
     process=Process.sequential,
     memory=True,
     verbose=True,
-    embedder=embedding_functions.OpenAIEmbeddingFunction(
+    embedder=OpenAIEmbeddingFunction(
         api_key="YOUR_API_KEY",
         api_base="YOUR_API_BASE_PATH",
         api_type="azure",
@@ -153,6 +196,7 @@ my_crew = Crew(
 ### Using Vertex AI embeddings
 
 ```python Code
+from chromadb.utils.embedding_functions import GoogleVertexEmbeddingFunction
 from crewai import Crew, Agent, Task, Process
 
 my_crew = Crew(
@@ -161,7 +205,7 @@ my_crew = Crew(
     process=Process.sequential,
     memory=True,
     verbose=True,
-    embedder=embedding_functions.GoogleVertexEmbeddingFunction(
+    embedder=GoogleVertexEmbeddingFunction(
         project_id="YOUR_PROJECT_ID",
         region="YOUR_REGION",
         api_key="YOUR_API_KEY",
@@ -181,10 +225,32 @@ my_crew = Crew(
     process=Process.sequential,
     memory=True,
     verbose=True,
-    embedder=embedding_functions.CohereEmbeddingFunction(
-        api_key=YOUR_API_KEY,
-        model_name="<model_name>"
-    )
+    embedder={
+        "provider": "cohere",
+        "config": {
+            "api_key": "YOUR_API_KEY",
+            "model_name": "<model_name>"
+        }
+    }
+)
+```
+### Using HuggingFace embeddings
+
+```python Code
+from crewai import Crew, Agent, Task, Process
+
+my_crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process=Process.sequential,
+    memory=True,
+    verbose=True,
+    embedder={
+        "provider": "huggingface",
+        "config": {
+            "api_url": "<api_url>",
+        }
+    }
 )
 ```
 

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "crewai"
-version = "0.74.2"
+version = "0.76.2"
 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.13"
@@ -28,6 +28,7 @@ dependencies = [
     "uv>=0.4.25",
     "tomli-w>=1.1.0",
     "chromadb>=0.4.24",
+    "tomli>=2.0.2",
 ]
 
 [project.urls]

src/crewai/__init__.py

@@ -14,5 +14,5 @@ warnings.filterwarnings(
     category=UserWarning,
     module="pydantic.main",
 )
-__version__ = "0.74.2"
+__version__ = "0.76.2"
 __all__ = ["Agent", "Crew", "Process", "Task", "Pipeline", "Router", "LLM", "Flow"]

src/crewai/agent.py

@@ -1,6 +1,7 @@
 import os
-from inspect import signature
-from typing import Any, List, Optional, Union
+import shutil
+import subprocess
+from typing import Any, List, Literal, Optional, Union
 
 from pydantic import Field, InstanceOf, PrivateAttr, model_validator
 
@@ -112,6 +113,10 @@ class Agent(BaseAgent):
         default=2,
         description="Maximum number of retries for an agent to execute a task when an error occurs.",
     )
+    code_execution_mode: Literal["safe", "unsafe"] = Field(
+        default="safe",
+        description="Mode for code execution: 'safe' (using Docker) or 'unsafe' (direct execution).",
+    )
 
     @model_validator(mode="after")
     def post_init_setup(self):
@@ -173,6 +178,9 @@ class Agent(BaseAgent):
         if not self.agent_executor:
             self._setup_agent_executor()
 
+        if self.allow_code_execution:
+            self._validate_docker_installation()
+
         return self
 
     def _setup_agent_executor(self):
@@ -308,7 +316,9 @@ class Agent(BaseAgent):
         try:
             from crewai_tools import CodeInterpreterTool
 
-            return [CodeInterpreterTool()]
+            # Set the unsafe_mode based on the code_execution_mode attribute
+            unsafe_mode = self.code_execution_mode == "unsafe"
+            return [CodeInterpreterTool(unsafe_mode=unsafe_mode)]
         except ModuleNotFoundError:
             self._logger.log(
                 "info", "Coding tools not available. Install crewai_tools. "
@@ -384,30 +394,49 @@ class Agent(BaseAgent):
     def _render_text_description_and_args(self, tools: List[Any]) -> str:
         """Render the tool name, description, and args in plain text.
 
-        Output will be in the format of:
+            Output will be in the format of:
 
-        .. code-block:: markdown
+            .. code-block:: markdown
 
             search: This tool is used for search, args: {"query": {"type": "string"}}
             calculator: This tool is used for math, \
-    args: {"expression": {"type": "string"}}
+            args: {"expression": {"type": "string"}}
         """
         tool_strings = []
         for tool in tools:
-            args_schema = str(tool.model_fields)
-            if hasattr(tool, "func") and tool.func:
-                sig = signature(tool.func)
-                description = (
-                    f"Tool Name: {tool.name}{sig}\nTool Description: {tool.description}"
-                )
-            else:
-                description = (
-                    f"Tool Name: {tool.name}\nTool Description: {tool.description}"
-                )
+            args_schema = {
+                name: {
+                    "description": field.description,
+                    "type": field.annotation.__name__,
+                }
+                for name, field in tool.args_schema.model_fields.items()
+            }
+            description = (
+                f"Tool Name: {tool.name}\nTool Description: {tool.description}"
+            )
             tool_strings.append(f"{description}\nTool Arguments: {args_schema}")
 
         return "\n".join(tool_strings)
 
+    def _validate_docker_installation(self) -> None:
+        """Check if Docker is installed and running."""
+        if not shutil.which("docker"):
+            raise RuntimeError(
+                f"Docker is not installed. Please install Docker to use code execution with agent: {self.role}"
+            )
+
+        try:
+            subprocess.run(
+                ["docker", "info"],
+                check=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+        except subprocess.CalledProcessError:
+            raise RuntimeError(
+                f"Docker is not running. Please start Docker to use code execution with agent: {self.role}"
+            )
+
     @staticmethod
     def __tools_names(tools) -> str:
         return ", ".join([t.name for t in tools])

src/crewai/cli/add_crew_to_flow.py

@@ -0,0 +1,70 @@
+from pathlib import Path
+
+import click
+
+from crewai.cli.utils import copy_template
+
+
+def add_crew_to_flow(crew_name: str) -> None:
+    """Add a new crew to the current flow."""
+    # Check if pyproject.toml exists in the current directory
+    if not Path("pyproject.toml").exists():
+        print("This command must be run from the root of a flow project.")
+        raise click.ClickException(
+            "This command must be run from the root of a flow project."
+        )
+
+    # Determine the flow folder based on the current directory
+    flow_folder = Path.cwd()
+    crews_folder = flow_folder / "src" / flow_folder.name / "crews"
+
+    if not crews_folder.exists():
+        print("Crews folder does not exist in the current flow.")
+        raise click.ClickException("Crews folder does not exist in the current flow.")
+
+    # Create the crew within the flow's crews directory
+    create_embedded_crew(crew_name, parent_folder=crews_folder)
+
+    click.echo(
+        f"Crew {crew_name} added to the current flow successfully!",
+    )
+
+
+def create_embedded_crew(crew_name: str, parent_folder: Path) -> None:
+    """Create a new crew within an existing flow project."""
+    folder_name = crew_name.replace(" ", "_").replace("-", "_").lower()
+    class_name = crew_name.replace("_", " ").replace("-", " ").title().replace(" ", "")
+
+    crew_folder = parent_folder / folder_name
+
+    if crew_folder.exists():
+        if not click.confirm(
+            f"Crew {folder_name} already exists. Do you want to override it?"
+        ):
+            click.secho("Operation cancelled.", fg="yellow")
+            return
+        click.secho(f"Overriding crew {folder_name}...", fg="green", bold=True)
+    else:
+        click.secho(f"Creating crew {folder_name}...", fg="green", bold=True)
+        crew_folder.mkdir(parents=True)
+
+    # Create config and crew.py files
+    config_folder = crew_folder / "config"
+    config_folder.mkdir(exist_ok=True)
+
+    templates_dir = Path(__file__).parent / "templates" / "crew"
+    config_template_files = ["agents.yaml", "tasks.yaml"]
+    crew_template_file = f"{folder_name}_crew.py"  # Updated file name
+
+    for file_name in config_template_files:
+        src_file = templates_dir / "config" / file_name
+        dst_file = config_folder / file_name
+        copy_template(src_file, dst_file, crew_name, class_name, folder_name)
+
+    src_file = templates_dir / "crew.py"
+    dst_file = crew_folder / crew_template_file
+    copy_template(src_file, dst_file, crew_name, class_name, folder_name)
+
+    click.secho(
+        f"Crew {crew_name} added to the flow successfully!", fg="green", bold=True
+    )

src/crewai/cli/cli.py

@@ -3,6 +3,7 @@ from typing import Optional
 import click
 import pkg_resources
 
+from crewai.cli.add_crew_to_flow import add_crew_to_flow
 from crewai.cli.create_crew import create_crew
 from crewai.cli.create_flow import create_flow
 from crewai.cli.create_pipeline import create_pipeline
@@ -32,10 +33,12 @@ def crewai():
 @crewai.command()
 @click.argument("type", type=click.Choice(["crew", "pipeline", "flow"]))
 @click.argument("name")
-def create(type, name):
+@click.option("--provider", type=str, help="The provider to use for the crew")
+@click.option("--skip_provider", is_flag=True, help="Skip provider validation")
+def create(type, name, provider, skip_provider=False):
     """Create a new crew, pipeline, or flow."""
     if type == "crew":
-        create_crew(name)
+        create_crew(name, provider, skip_provider)
     elif type == "pipeline":
         create_pipeline(name)
     elif type == "flow":
@@ -176,10 +179,16 @@ def test(n_iterations: int, model: str):
     evaluate_crew(n_iterations, model)
 
 
-@crewai.command()
-def install():
+@crewai.command(
+    context_settings=dict(
+        ignore_unknown_options=True,
+        allow_extra_args=True,
+    )
+)
+@click.pass_context
+def install(context):
     """Install the Crew."""
-    install_crew()
+    install_crew(context.args)
 
 
 @crewai.command()
@@ -318,5 +327,13 @@ def flow_plot():
     plot_flow()
 
 
+@flow.command(name="add-crew")
+@click.argument("crew_name")
+def flow_add_crew(crew_name):
+    """Add a crew to an existing flow."""
+    click.echo(f"Adding crew {crew_name} to the flow")
+    add_crew_to_flow(crew_name)
+
+
 if __name__ == "__main__":
     crewai()

src/crewai/cli/create_crew.py

@@ -1,8 +1,16 @@
+import sys
 from pathlib import Path
+
 import click
-from crewai.cli.utils import copy_template, load_env_vars, write_env_file
-from crewai.cli.provider import get_provider_data, select_provider, PROVIDERS
+
 from crewai.cli.constants import ENV_VARS
+from crewai.cli.provider import (
+    PROVIDERS,
+    get_provider_data,
+    select_model,
+    select_provider,
+)
+from crewai.cli.utils import copy_template, load_env_vars, write_env_file
 
 
 def create_folder_structure(name, parent_folder=None):
@@ -14,11 +22,19 @@ def create_folder_structure(name, parent_folder=None):
     else:
         folder_path = Path(folder_name)
 
-    click.secho(
-        f"Creating {'crew' if parent_folder else 'folder'} {folder_name}...",
-        fg="green",
-        bold=True,
-    )
+    if folder_path.exists():
+        if not click.confirm(
+            f"Folder {folder_name} already exists. Do you want to override it?"
+        ):
+            click.secho("Operation cancelled.", fg="yellow")
+            sys.exit(0)
+        click.secho(f"Overriding folder {folder_name}...", fg="green", bold=True)
+    else:
+        click.secho(
+            f"Creating {'crew' if parent_folder else 'folder'} {folder_name}...",
+            fg="green",
+            bold=True,
+        )
 
     if not folder_path.exists():
         folder_path.mkdir(parents=True)
@@ -27,11 +43,6 @@ def create_folder_structure(name, parent_folder=None):
             (folder_path / "src" / folder_name).mkdir(parents=True)
             (folder_path / "src" / folder_name / "tools").mkdir(parents=True)
             (folder_path / "src" / folder_name / "config").mkdir(parents=True)
-    else:
-        click.secho(
-            f"\tFolder {folder_name} already exists.",
-            fg="yellow",
-        )
 
     return folder_path, folder_name, class_name
 
@@ -70,37 +81,84 @@ def copy_template_files(folder_path, name, class_name, parent_folder):
             copy_template(src_file, dst_file, name, class_name, folder_path.name)
 
 
-def create_crew(name, parent_folder=None):
+def create_crew(name, provider=None, skip_provider=False, parent_folder=None):
     folder_path, folder_name, class_name = create_folder_structure(name, parent_folder)
     env_vars = load_env_vars(folder_path)
+    if not skip_provider:
+        if not provider:
+            provider_models = get_provider_data()
+            if not provider_models:
+                return
 
-    provider_models = get_provider_data()
-    if not provider_models:
-        return
+        existing_provider = None
+        for provider, env_keys in ENV_VARS.items():
+            if any(key in env_vars for key in env_keys):
+                existing_provider = provider
+                break
 
-    selected_provider = select_provider(provider_models)
-    if not selected_provider:
-        return
-    provider = selected_provider
+        if existing_provider:
+            if not click.confirm(
+                f"Found existing environment variable configuration for {existing_provider.capitalize()}. Do you want to override it?"
+            ):
+                click.secho("Keeping existing provider configuration.", fg="yellow")
+                return
 
-    # selected_model = select_model(provider, provider_models)
-    # if not selected_model:
-    #     return
-    # model = selected_model
+        provider_models = get_provider_data()
+        if not provider_models:
+            return
 
-    if provider in PROVIDERS:
-        api_key_var = ENV_VARS[provider][0]
-    else:
-        api_key_var = click.prompt(
-            f"Enter the environment variable name for your {provider.capitalize()} API key",
-            type=str,
+        while True:
+            selected_provider = select_provider(provider_models)
+            if selected_provider is None:  # User typed 'q'
+                click.secho("Exiting...", fg="yellow")
+                sys.exit(0)
+            if selected_provider:  # Valid selection
+                break
+            click.secho(
+                "No provider selected. Please try again or press 'q' to exit.", fg="red"
+            )
+
+        while True:
+            selected_model = select_model(selected_provider, provider_models)
+            if selected_model is None:  # User typed 'q'
+                click.secho("Exiting...", fg="yellow")
+                sys.exit(0)
+            if selected_model:  # Valid selection
+                break
+            click.secho(
+                "No model selected. Please try again or press 'q' to exit.", fg="red"
+            )
+
+        if selected_provider in PROVIDERS:
+            api_key_var = ENV_VARS[selected_provider][0]
+        else:
+            api_key_var = click.prompt(
+                f"Enter the environment variable name for your {selected_provider.capitalize()} API key",
+                type=str,
+                default="",
+            )
+
+        api_key_value = ""
+        click.echo(
+            f"Enter your {selected_provider.capitalize()} API key (press Enter to skip): ",
+            nl=False,
         )
+        try:
+            api_key_value = input()
+        except (KeyboardInterrupt, EOFError):
+            api_key_value = ""
 
-    env_vars = {api_key_var: "YOUR_API_KEY_HERE"}
-    write_env_file(folder_path, env_vars)
+        if api_key_value.strip():
+            env_vars = {api_key_var: api_key_value}
+            write_env_file(folder_path, env_vars)
+            click.secho("API key saved to .env file", fg="green")
+        else:
+            click.secho(
+                "No API key provided. Skipping .env file creation.", fg="yellow"
+            )
 
-    # env_vars['MODEL'] = model
-    # click.secho(f"Selected model: {model}", fg="green")
+        env_vars["MODEL"] = selected_model
+        click.secho(f"Selected model: {selected_model}", fg="green")
 
     package_dir = Path(__file__).parent
     templates_dir = package_dir / "templates" / "crew"

src/crewai/cli/install_crew.py

@@ -3,12 +3,13 @@ import subprocess
 import click
 
 
-def install_crew() -> None:
+def install_crew(proxy_options: list[str]) -> None:
     """
     Install the crew by running the UV command to lock and install.
     """
     try:
-        subprocess.run(["uv", "sync"], check=True, capture_output=False, text=True)
+        command = ["uv", "sync"] + proxy_options
+        subprocess.run(command, check=True, capture_output=False, text=True)
 
     except subprocess.CalledProcessError as e:
         click.echo(f"An error occurred while running the crew: {e}", err=True)

src/crewai/cli/plot_flow.py

@@ -7,7 +7,7 @@ def plot_flow() -> None:
     """
     Plot the flow by running a command in the UV environment.
     """
-    command = ["uv", "run", "plot_flow"]
+    command = ["uv", "run", "plot"]
 
     try:
         result = subprocess.run(command, capture_output=False, text=True, check=True)

src/crewai/cli/provider.py

@@ -1,67 +1,91 @@
 import json
 import time
-import requests
 from collections import defaultdict
+from pathlib import Path
+
 import click
-from pathlib import Path 
-from crewai.cli.constants import PROVIDERS, MODELS, JSON_URL
+import requests
+
+from crewai.cli.constants import JSON_URL, MODELS, PROVIDERS
+
 
 def select_choice(prompt_message, choices):
     """
     Presents a list of choices to the user and prompts them to select one.
-    
+
     Args:
     - prompt_message (str): The message to display to the user before presenting the choices.
     - choices (list): A list of options to present to the user.
-    
+
     Returns:
-    - str: The selected choice from the list, or None if the operation is aborted or an invalid selection is made.
+    - str: The selected choice from the list, or None if the user chooses to quit.
     """
+
+    provider_models = get_provider_data()
+    if not provider_models:
+        return
     click.secho(prompt_message, fg="cyan")
     for idx, choice in enumerate(choices, start=1):
         click.secho(f"{idx}. {choice}", fg="cyan")
-    try:
-        selected_index = click.prompt("Enter the number of your choice", type=int) - 1
-    except click.exceptions.Abort:
-        click.secho("Operation aborted by the user.", fg="red")
-        return None
-    if not (0 <= selected_index < len(choices)):
-        click.secho("Invalid selection.", fg="red")
-        return None
-    return choices[selected_index]
+    click.secho("q. Quit", fg="cyan")
+
+    while True:
+        choice = click.prompt(
+            "Enter the number of your choice or 'q' to quit", type=str
+        )
+
+        if choice.lower() == "q":
+            return None
+
+        try:
+            selected_index = int(choice) - 1
+            if 0 <= selected_index < len(choices):
+                return choices[selected_index]
+        except ValueError:
+            pass
+
+        click.secho(
+            "Invalid selection. Please select a number between 1 and 6 or 'q' to quit.",
+            fg="red",
+        )
+
 
 def select_provider(provider_models):
     """
     Presents a list of providers to the user and prompts them to select one.
-    
+
     Args:
     - provider_models (dict): A dictionary of provider models.
-    
+
     Returns:
-    - str: The selected provider, or None if the operation is aborted or an invalid selection is made.
+    - str: The selected provider
+    - None: If user explicitly quits
     """
     predefined_providers = [p.lower() for p in PROVIDERS]
     all_providers = sorted(set(predefined_providers + list(provider_models.keys())))
 
-    provider = select_choice("Select a provider to set up:", predefined_providers + ['other'])
-    if not provider:
+    provider = select_choice(
+        "Select a provider to set up:", predefined_providers + ["other"]
+    )
+    if provider is None:  # User typed 'q'
         return None
-    provider = provider.lower()
 
-    if provider == 'other':
+    if provider == "other":
         provider = select_choice("Select a provider from the full list:", all_providers)
-        if not provider:
+        if provider is None:  # User typed 'q'
             return None
-    return provider
+
+    return provider.lower() if provider else False
+
 
 def select_model(provider, provider_models):
     """
     Presents a list of models for a given provider to the user and prompts them to select one.
-    
+
     Args:
     - provider (str): The provider for which to select a model.
     - provider_models (dict): A dictionary of provider models.
-    
+
     Returns:
     - str: The selected model, or None if the operation is aborted or an invalid selection is made.
     """
@@ -76,37 +100,49 @@ def select_model(provider, provider_models):
         click.secho(f"No models available for provider '{provider}'.", fg="red")
         return None
 
-    selected_model = select_choice(f"Select a model to use for {provider.capitalize()}:", available_models)
+    selected_model = select_choice(
+        f"Select a model to use for {provider.capitalize()}:", available_models
+    )
     return selected_model
 
+
 def load_provider_data(cache_file, cache_expiry):
     """
     Loads provider data from a cache file if it exists and is not expired. If the cache is expired or corrupted, it fetches the data from the web.
-    
+
     Args:
     - cache_file (Path): The path to the cache file.
     - cache_expiry (int): The cache expiry time in seconds.
-    
+
     Returns:
     - dict or None: The loaded provider data or None if the operation fails.
     """
     current_time = time.time()
-    if cache_file.exists() and (current_time - cache_file.stat().st_mtime) < cache_expiry:
+    if (
+        cache_file.exists()
+        and (current_time - cache_file.stat().st_mtime) < cache_expiry
+    ):
         data = read_cache_file(cache_file)
         if data:
             return data
-        click.secho("Cache is corrupted. Fetching provider data from the web...", fg="yellow")
+        click.secho(
+            "Cache is corrupted. Fetching provider data from the web...", fg="yellow"
+        )
     else:
-        click.secho("Cache expired or not found. Fetching provider data from the web...", fg="cyan")
+        click.secho(
+            "Cache expired or not found. Fetching provider data from the web...",
+            fg="cyan",
+        )
     return fetch_provider_data(cache_file)
 
+
 def read_cache_file(cache_file):
     """
     Reads and returns the JSON content from a cache file. Returns None if the file contains invalid JSON.
-    
+
     Args:
     - cache_file (Path): The path to the cache file.
-    
+
     Returns:
     - dict or None: The JSON content of the cache file or None if the JSON is invalid.
     """
@@ -116,13 +152,14 @@ def read_cache_file(cache_file):
     except json.JSONDecodeError:
         return None
 
+
 def fetch_provider_data(cache_file):
     """
     Fetches provider data from a specified URL and caches it to a file.
-    
+
     Args:
     - cache_file (Path): The path to the cache file.
-    
+
     Returns:
     - dict or None: The fetched provider data or None if the operation fails.
     """
@@ -139,38 +176,42 @@ def fetch_provider_data(cache_file):
         click.secho("Error parsing provider data. Invalid JSON format.", fg="red")
     return None
 
+
 def download_data(response):
     """
     Downloads data from a given HTTP response and returns the JSON content.
-    
+
     Args:
     - response (requests.Response): The HTTP response object.
-    
+
     Returns:
     - dict: The JSON content of the response.
     """
-    total_size = int(response.headers.get('content-length', 0))
+    total_size = int(response.headers.get("content-length", 0))
     block_size = 8192
     data_chunks = []
-    with click.progressbar(length=total_size, label='Downloading', show_pos=True) as progress_bar:
+    with click.progressbar(
+        length=total_size, label="Downloading", show_pos=True
+    ) as progress_bar:
         for chunk in response.iter_content(block_size):
             if chunk:
                 data_chunks.append(chunk)
                 progress_bar.update(len(chunk))
-    data_content = b''.join(data_chunks)
-    return json.loads(data_content.decode('utf-8'))
+    data_content = b"".join(data_chunks)
+    return json.loads(data_content.decode("utf-8"))
+
 
 def get_provider_data():
     """
     Retrieves provider data from a cache file, filters out models based on provider criteria, and returns a dictionary of providers mapped to their models.
-    
+
     Returns:
     - dict or None: A dictionary of providers mapped to their models or None if the operation fails.
     """
-    cache_dir = Path.home() / '.crewai'
+    cache_dir = Path.home() / ".crewai"
     cache_dir.mkdir(exist_ok=True)
-    cache_file = cache_dir / 'provider_cache.json'
-    cache_expiry = 24 * 3600 
+    cache_file = cache_dir / "provider_cache.json"
+    cache_expiry = 24 * 3600
 
     data = load_provider_data(cache_file, cache_expiry)
     if not data:
@@ -179,8 +220,8 @@ def get_provider_data():
     provider_models = defaultdict(list)
     for model_name, properties in data.items():
         provider = properties.get("litellm_provider", "").strip().lower()
-        if 'http' in provider or provider == 'other':
+        if "http" in provider or provider == "other":
             continue
         if provider:
             provider_models[provider].append(model_name)
-    return provider_models
+    return provider_models

src/crewai/cli/run_crew.py

@@ -1,10 +1,9 @@
 import subprocess
 
 import click
-import tomllib
 from packaging import version
 
-from crewai.cli.utils import get_crewai_version
+from crewai.cli.utils import get_crewai_version, read_toml
 
 
 def run_crew() -> None:
@@ -15,10 +14,9 @@ def run_crew() -> None:
     crewai_version = get_crewai_version()
     min_required_version = "0.71.0"
 
-    with open("pyproject.toml", "rb") as f:
-        data = tomllib.load(f)
+    pyproject_data = read_toml()
 
-    if data.get("tool", {}).get("poetry") and (
+    if pyproject_data.get("tool", {}).get("poetry") and (
         version.parse(crewai_version) < version.parse(min_required_version)
     ):
         click.secho(
@@ -35,10 +33,7 @@ def run_crew() -> None:
         click.echo(f"An error occurred while running the crew: {e}", err=True)
         click.echo(e.output, err=True, nl=True)
 
-        with open("pyproject.toml", "rb") as f:
-            data = tomllib.load(f)
-
-        if data.get("tool", {}).get("poetry"):
+        if pyproject_data.get("tool", {}).get("poetry"):
             click.secho(
                 "It's possible that you are using an old version of crewAI that uses poetry, please run `crewai update` to update your pyproject.toml to use uv.",
                 fg="yellow",

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.13"
 dependencies = [
-    "crewai[tools]>=0.74.2,<1.0.0"
+    "crewai[tools]>=0.76.2,<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.13"
 dependencies = [
-    "crewai[tools]>=0.74.2,<1.0.0",
+    "crewai[tools]>=0.76.2,<1.0.0",
 ]
 
 [project.scripts]

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

@@ -6,7 +6,7 @@ authors = ["Your Name <you@example.com>"]
 
 [tool.poetry.dependencies]
 python = ">=3.10,<=3.13"
-crewai = { extras = ["tools"], version = ">=0.74.2,<1.0.0" }
+crewai = { extras = ["tools"], version = ">=0.76.2,<1.0.0" }
 asyncio = "*"
 
 [tool.poetry.scripts]

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

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

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

@@ -5,6 +5,6 @@ description = "Power up your crews with {{folder_name}}"
 readme = "README.md"
 requires-python = ">=3.10,<=3.13"
 dependencies = [
-    "crewai[tools]>=0.74.2"
+    "crewai[tools]>=0.76.2"
 ]
 

src/crewai/cli/update_crew.py

@@ -2,7 +2,8 @@ import os
 import shutil
 
 import tomli_w
-import tomllib
+
+from crewai.cli.utils import read_toml
 
 
 def update_crew() -> None:
@@ -18,10 +19,9 @@ def migrate_pyproject(input_file, output_file):
     And it will be used to migrate the pyproject.toml to the new format when uv is used.
     When the time comes that uv supports the new format, this function will be deprecated.
     """
-
+    poetry_data = {}
     # Read the input pyproject.toml
-    with open(input_file, "rb") as f:
-        pyproject = tomllib.load(f)
+    pyproject_data = read_toml()
 
     # Initialize the new project structure
     new_pyproject = {
@@ -30,30 +30,30 @@ def migrate_pyproject(input_file, output_file):
     }
 
     # Migrate project metadata
-    if "tool" in pyproject and "poetry" in pyproject["tool"]:
-        poetry = pyproject["tool"]["poetry"]
-        new_pyproject["project"]["name"] = poetry.get("name")
-        new_pyproject["project"]["version"] = poetry.get("version")
-        new_pyproject["project"]["description"] = poetry.get("description")
+    if "tool" in pyproject_data and "poetry" in pyproject_data["tool"]:
+        poetry_data = pyproject_data["tool"]["poetry"]
+        new_pyproject["project"]["name"] = poetry_data.get("name")
+        new_pyproject["project"]["version"] = poetry_data.get("version")
+        new_pyproject["project"]["description"] = poetry_data.get("description")
         new_pyproject["project"]["authors"] = [
             {
                 "name": author.split("<")[0].strip(),
                 "email": author.split("<")[1].strip(">").strip(),
             }
-            for author in poetry.get("authors", [])
+            for author in poetry_data.get("authors", [])
         ]
-        new_pyproject["project"]["requires-python"] = poetry.get("python")
+        new_pyproject["project"]["requires-python"] = poetry_data.get("python")
     else:
         # If it's already in the new format, just copy the project section
-        new_pyproject["project"] = pyproject.get("project", {})
+        new_pyproject["project"] = pyproject_data.get("project", {})
 
     # Migrate or copy dependencies
     if "dependencies" in new_pyproject["project"]:
         # If dependencies are already in the new format, keep them as is
         pass
-    elif "dependencies" in poetry:
+    elif poetry_data and "dependencies" in poetry_data:
         new_pyproject["project"]["dependencies"] = []
-        for dep, version in poetry["dependencies"].items():
+        for dep, version in poetry_data["dependencies"].items():
             if isinstance(version, dict):  # Handle extras
                 extras = ",".join(version.get("extras", []))
                 new_dep = f"{dep}[{extras}]"
@@ -67,10 +67,10 @@ def migrate_pyproject(input_file, output_file):
             new_pyproject["project"]["dependencies"].append(new_dep)
 
     # Migrate or copy scripts
-    if "scripts" in poetry:
-        new_pyproject["project"]["scripts"] = poetry["scripts"]
-    elif "scripts" in pyproject.get("project", {}):
-        new_pyproject["project"]["scripts"] = pyproject["project"]["scripts"]
+    if poetry_data and "scripts" in poetry_data:
+        new_pyproject["project"]["scripts"] = poetry_data["scripts"]
+    elif pyproject_data.get("project", {}) and "scripts" in pyproject_data["project"]:
+        new_pyproject["project"]["scripts"] = pyproject_data["project"]["scripts"]
     else:
         new_pyproject["project"]["scripts"] = {}
 
@@ -87,8 +87,8 @@ def migrate_pyproject(input_file, output_file):
         new_pyproject["project"]["scripts"]["run_crew"] = f"{module_name}.main:run"
 
     # Migrate optional dependencies
-    if "extras" in poetry:
-        new_pyproject["project"]["optional-dependencies"] = poetry["extras"]
+    if poetry_data and "extras" in poetry_data:
+        new_pyproject["project"]["optional-dependencies"] = poetry_data["extras"]
 
     # Backup the old pyproject.toml
     backup_file = "pyproject-old.toml"

src/crewai/cli/utils.py

@@ -6,6 +6,7 @@ from functools import reduce
 from typing import Any, Dict, List
 
 import click
+import tomli
 from rich.console import Console
 
 from crewai.cli.authentication.utils import TokenManager
@@ -54,6 +55,13 @@ def simple_toml_parser(content):
     return result
 
 
+def read_toml(file_path: str = "pyproject.toml"):
+    """Read the content of a TOML file and return it as a dictionary."""
+    with open(file_path, "rb") as f:
+        toml_dict = tomli.load(f)
+    return toml_dict
+
+
 def parse_toml(content):
     if sys.version_info >= (3, 11):
         return tomllib.loads(content)

src/crewai/crew.py

@@ -435,15 +435,16 @@ class Crew(BaseModel):
         self, n_iterations: int, filename: str, inputs: Optional[Dict[str, Any]] = {}
     ) -> None:
         """Trains the crew for a given number of iterations."""
-        self._setup_for_training(filename)
+        train_crew = self.copy()
+        train_crew._setup_for_training(filename)
 
         for n_iteration in range(n_iterations):
-            self._train_iteration = n_iteration
-            self.kickoff(inputs=inputs)
+            train_crew._train_iteration = n_iteration
+            train_crew.kickoff(inputs=inputs)
 
         training_data = CrewTrainingHandler(TRAINING_DATA_FILE).load()
 
-        for agent in self.agents:
+        for agent in train_crew.agents:
             result = TaskEvaluator(agent).evaluate_training_data(
                 training_data=training_data, agent_id=str(agent.id)
             )
@@ -987,17 +988,19 @@ class Crew(BaseModel):
         inputs: Optional[Dict[str, Any]] = None,
     ) -> None:
         """Test and evaluate the Crew with the given inputs for n iterations concurrently using concurrent.futures."""
-        self._test_execution_span = self._telemetry.test_execution_span(
-            self,
+        test_crew = self.copy()
+
+        self._test_execution_span = test_crew._telemetry.test_execution_span(
+            test_crew,
             n_iterations,
             inputs,
             openai_model_name,  # type: ignore[arg-type]
         )  # type: ignore[arg-type]
-        evaluator = CrewEvaluator(self, openai_model_name)  # type: ignore[arg-type]
+        evaluator = CrewEvaluator(test_crew, openai_model_name)  # type: ignore[arg-type]
 
         for i in range(1, n_iterations + 1):
             evaluator.set_iteration(i)
-            self.kickoff(inputs=inputs)
+            test_crew.kickoff(inputs=inputs)
 
         evaluator.print_crew_evaluation_result()
 

src/crewai/memory/entity/entity_memory.py

@@ -16,7 +16,7 @@ class EntityMemory(Memory):
             if storage
             else RAGStorage(
                 type="entities",
-                allow_reset=False,
+                allow_reset=True,
                 embedder_config=embedder_config,
                 crew=crew,
             )

src/crewai/memory/storage/rag_storage.py

@@ -8,6 +8,9 @@ from typing import Any, Dict, List, Optional
 from crewai.memory.storage.base_rag_storage import BaseRAGStorage
 from crewai.utilities.paths import db_storage_path
 from chromadb.api import ClientAPI
+from chromadb.api.types import validate_embedding_function
+from chromadb import Documents, EmbeddingFunction, Embeddings
+from typing import cast
 
 
 @contextlib.contextmanager
@@ -41,16 +44,93 @@ class RAGStorage(BaseRAGStorage):
         self.agents = agents
 
         self.type = type
-        self.embedder_config = embedder_config or self._create_embedding_function()
+
         self.allow_reset = allow_reset
         self._initialize_app()
 
+    def _set_embedder_config(self):
+        import chromadb.utils.embedding_functions as embedding_functions
+
+        if self.embedder_config is None:
+            self.embedder_config = self._create_default_embedding_function()
+
+        if isinstance(self.embedder_config, dict):
+            provider = self.embedder_config.get("provider")
+            config = self.embedder_config.get("config", {})
+            model_name = config.get("model")
+            if provider == "openai":
+                self.embedder_config = embedding_functions.OpenAIEmbeddingFunction(
+                    api_key=config.get("api_key") or os.getenv("OPENAI_API_KEY"),
+                    model_name=model_name,
+                )
+            elif provider == "azure":
+                self.embedder_config = embedding_functions.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,
+                )
+            elif provider == "ollama":
+                from openai import OpenAI
+
+                class OllamaEmbeddingFunction(EmbeddingFunction):
+                    def __call__(self, input: Documents) -> Embeddings:
+                        client = OpenAI(
+                            base_url="http://localhost:11434/v1",
+                            api_key=config.get("api_key", "ollama"),
+                        )
+                        try:
+                            response = client.embeddings.create(
+                                input=input, model=model_name
+                            )
+                            embeddings = [item.embedding for item in response.data]
+                            return cast(Embeddings, embeddings)
+                        except Exception as e:
+                            raise e
+
+                self.embedder_config = OllamaEmbeddingFunction()
+            elif provider == "vertexai":
+                self.embedder_config = (
+                    embedding_functions.GoogleVertexEmbeddingFunction(
+                        model_name=model_name,
+                        api_key=config.get("api_key"),
+                    )
+                )
+            elif provider == "google":
+                self.embedder_config = (
+                    embedding_functions.GoogleGenerativeAiEmbeddingFunction(
+                        model_name=model_name,
+                        api_key=config.get("api_key"),
+                    )
+                )
+            elif provider == "cohere":
+                self.embedder_config = embedding_functions.CohereEmbeddingFunction(
+                    model_name=model_name,
+                    api_key=config.get("api_key"),
+                )
+            elif provider == "huggingface":
+                self.embedder_config = embedding_functions.HuggingFaceEmbeddingServer(
+                    url=config.get("api_url"),
+                )
+            else:
+                raise Exception(
+                    f"Unsupported embedding provider: {provider}, supported providers: [openai, azure, ollama, vertexai, google, cohere, huggingface]"
+                )
+        else:
+            validate_embedding_function(self.embedder_config)  # type: ignore # used for validating embedder_config if defined a embedding function/class
+            self.embedder_config = self.embedder_config
+
     def _initialize_app(self):
         import chromadb
+        from chromadb.config import Settings
 
+        self._set_embedder_config()
         chroma_client = chromadb.PersistentClient(
-            path=f"{db_storage_path()}/{self.type}/{self.agents}"
+            path=f"{db_storage_path()}/{self.type}/{self.agents}",
+            settings=Settings(allow_reset=self.allow_reset),
         )
+
         self.app = chroma_client
 
         try:
@@ -122,11 +202,15 @@ class RAGStorage(BaseRAGStorage):
             if self.app:
                 self.app.reset()
         except Exception as e:
-            raise Exception(
-                f"An error occurred while resetting the {self.type} memory: {e}"
-            )
+            if "attempt to write a readonly database" in str(e):
+                # Ignore this specific error
+                pass
+            else:
+                raise Exception(
+                    f"An error occurred while resetting the {self.type} memory: {e}"
+                )
 
-    def _create_embedding_function(self):
+    def _create_default_embedding_function(self):
         import chromadb.utils.embedding_functions as embedding_functions
 
         return embedding_functions.OpenAIEmbeddingFunction(

tests/cli/cli_test.py

@@ -1,7 +1,9 @@
+from pathlib import Path
 from unittest import mock
 
 import pytest
 from click.testing import CliRunner
+
 from crewai.cli.cli import (
     deploy_create,
     deploy_list,
@@ -9,6 +11,7 @@ from crewai.cli.cli import (
     deploy_push,
     deploy_remove,
     deply_status,
+    flow_add_crew,
     reset_memories,
     signup,
     test,
@@ -277,3 +280,42 @@ def test_deploy_remove_no_uuid(command, runner):
 
     assert result.exit_code == 0
     mock_deploy.remove_crew.assert_called_once_with(uuid=None)
+
+
+@mock.patch("crewai.cli.add_crew_to_flow.create_embedded_crew")
+@mock.patch("pathlib.Path.exists", return_value=True)  # Mock the existence check
+def test_flow_add_crew(mock_path_exists, mock_create_embedded_crew, runner):
+    crew_name = "new_crew"
+    result = runner.invoke(flow_add_crew, [crew_name])
+
+    # Log the output for debugging
+    print(result.output)
+
+    assert result.exit_code == 0, f"Command failed with output: {result.output}"
+    assert f"Adding crew {crew_name} to the flow" in result.output
+
+    # Verify that create_embedded_crew was called with the correct arguments
+    mock_create_embedded_crew.assert_called_once()
+    call_args, call_kwargs = mock_create_embedded_crew.call_args
+    assert call_args[0] == crew_name
+    assert "parent_folder" in call_kwargs
+    assert isinstance(call_kwargs["parent_folder"], Path)
+
+
+def test_add_crew_to_flow_not_in_root(runner):
+    # Simulate not being in the root of a flow project
+    with mock.patch("pathlib.Path.exists", autospec=True) as mock_exists:
+        # Mock Path.exists to return False when checking for pyproject.toml
+        def exists_side_effect(self):
+            if self.name == "pyproject.toml":
+                return False  # Simulate that pyproject.toml does not exist
+            return True  # All other paths exist
+
+        mock_exists.side_effect = exists_side_effect
+
+        result = runner.invoke(flow_add_crew, ["new_crew"])
+
+        assert result.exit_code != 0
+        assert "This command must be run from the root of a flow project." in str(
+            result.output
+        )

tests/crew_test.py

@@ -9,6 +9,7 @@ from unittest.mock import MagicMock, patch
 import instructor
 import pydantic_core
 import pytest
+
 from crewai.agent import Agent
 from crewai.agents.cache import CacheHandler
 from crewai.crew import Crew
@@ -497,6 +498,7 @@ def test_cache_hitting_between_agents():
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_api_calls_throttling(capsys):
     from unittest.mock import patch
+
     from crewai_tools import tool
 
     @tool
@@ -779,11 +781,14 @@ def test_async_task_execution_call_count():
     list_important_history.output = mock_task_output
     write_article.output = mock_task_output
 
-    with patch.object(
-        Task, "execute_sync", return_value=mock_task_output
-    ) as mock_execute_sync, patch.object(
-        Task, "execute_async", return_value=mock_future
-    ) as mock_execute_async:
+    with (
+        patch.object(
+            Task, "execute_sync", return_value=mock_task_output
+        ) as mock_execute_sync,
+        patch.object(
+            Task, "execute_async", return_value=mock_future
+        ) as mock_execute_async,
+    ):
         crew.kickoff()
 
         assert mock_execute_async.call_count == 2
@@ -1105,6 +1110,7 @@ def test_dont_set_agents_step_callback_if_already_set():
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_crew_function_calling_llm():
     from unittest.mock import patch
+
     from crewai_tools import tool
 
     llm = "gpt-4o"
@@ -1448,52 +1454,6 @@ def test_crew_does_not_interpolate_without_inputs():
             interpolate_task_inputs.assert_not_called()
 
 
-# def test_crew_partial_inputs():
-#     agent = Agent(
-#         role="{topic} Researcher",
-#         goal="Express hot takes on {topic}.",
-#         backstory="You have a lot of experience with {topic}.",
-#     )
-
-#     task = Task(
-#         description="Give me an analysis around {topic}.",
-#         expected_output="{points} bullet points about {topic}.",
-#     )
-
-#     crew = Crew(agents=[agent], tasks=[task], inputs={"topic": "AI"})
-#     inputs = {"topic": "AI"}
-#     crew._interpolate_inputs(inputs=inputs)  # Manual call for now
-
-#     assert crew.tasks[0].description == "Give me an analysis around AI."
-#     assert crew.tasks[0].expected_output == "{points} bullet points about AI."
-#     assert crew.agents[0].role == "AI Researcher"
-#     assert crew.agents[0].goal == "Express hot takes on AI."
-#     assert crew.agents[0].backstory == "You have a lot of experience with AI."
-
-
-# def test_crew_invalid_inputs():
-#     agent = Agent(
-#         role="{topic} Researcher",
-#         goal="Express hot takes on {topic}.",
-#         backstory="You have a lot of experience with {topic}.",
-#     )
-
-#     task = Task(
-#         description="Give me an analysis around {topic}.",
-#         expected_output="{points} bullet points about {topic}.",
-#     )
-
-#     crew = Crew(agents=[agent], tasks=[task], inputs={"subject": "AI"})
-#     inputs = {"subject": "AI"}
-#     crew._interpolate_inputs(inputs=inputs)  # Manual call for now
-
-#     assert crew.tasks[0].description == "Give me an analysis around {topic}."
-#     assert crew.tasks[0].expected_output == "{points} bullet points about {topic}."
-#     assert crew.agents[0].role == "{topic} Researcher"
-#     assert crew.agents[0].goal == "Express hot takes on {topic}."
-#     assert crew.agents[0].backstory == "You have a lot of experience with {topic}."
-
-
 def test_task_callback_on_crew():
     from unittest.mock import MagicMock, patch
 
@@ -1770,7 +1730,10 @@ def test_manager_agent_with_tools_raises_exception():
 @patch("crewai.crew.Crew.kickoff")
 @patch("crewai.crew.CrewTrainingHandler")
 @patch("crewai.crew.TaskEvaluator")
-def test_crew_train_success(task_evaluator, crew_training_handler, kickoff):
+@patch("crewai.crew.Crew.copy")
+def test_crew_train_success(
+    copy_mock, task_evaluator, crew_training_handler, kickoff_mock
+):
     task = Task(
         description="Come up with a list of 5 interesting ideas to explore for an article, then write one amazing paragraph highlight for each idea that showcases how good an article about this topic could be. Return the list of ideas with their paragraph and your notes.",
         expected_output="5 bullet points with a paragraph for each idea.",
@@ -1781,9 +1744,19 @@ def test_crew_train_success(task_evaluator, crew_training_handler, kickoff):
         agents=[researcher, writer],
         tasks=[task],
     )
+
+    # Create a mock for the copied crew
+    copy_mock.return_value = crew
+
     crew.train(
         n_iterations=2, inputs={"topic": "AI"}, filename="trained_agents_data.pkl"
     )
+
+    # Ensure kickoff is called on the copied crew
+    kickoff_mock.assert_has_calls(
+        [mock.call(inputs={"topic": "AI"}), mock.call(inputs={"topic": "AI"})]
+    )
+
     task_evaluator.assert_has_calls(
         [
             mock.call(researcher),
@@ -1822,10 +1795,6 @@ def test_crew_train_success(task_evaluator, crew_training_handler, kickoff):
         ]
     )
 
-    kickoff.assert_has_calls(
-        [mock.call(inputs={"topic": "AI"}), mock.call(inputs={"topic": "AI"})]
-    )
-
 
 def test_crew_train_error():
     task = Task(
@@ -1840,7 +1809,7 @@ def test_crew_train_error():
     )
 
     with pytest.raises(TypeError) as e:
-        crew.train()
+        crew.train()  # type: ignore purposefully throwing err
         assert "train() missing 1 required positional argument: 'n_iterations'" in str(
             e
         )
@@ -2536,8 +2505,9 @@ def test_conditional_should_execute():
 
 
 @mock.patch("crewai.crew.CrewEvaluator")
+@mock.patch("crewai.crew.Crew.copy")
 @mock.patch("crewai.crew.Crew.kickoff")
-def test_crew_testing_function(mock_kickoff, crew_evaluator):
+def test_crew_testing_function(kickoff_mock, copy_mock, crew_evaluator):
     task = Task(
         description="Come up with a list of 5 interesting ideas to explore for an article, then write one amazing paragraph highlight for each idea that showcases how good an article about this topic could be. Return the list of ideas with their paragraph and your notes.",
         expected_output="5 bullet points with a paragraph for each idea.",
@@ -2548,11 +2518,15 @@ def test_crew_testing_function(mock_kickoff, crew_evaluator):
         agents=[researcher],
         tasks=[task],
     )
+
+    # Create a mock for the copied crew
+    copy_mock.return_value = crew
+
     n_iterations = 2
     crew.test(n_iterations, openai_model_name="gpt-4o-mini", inputs={"topic": "AI"})
 
-    assert len(mock_kickoff.mock_calls) == n_iterations
-    mock_kickoff.assert_has_calls(
+    # Ensure kickoff is called on the copied crew
+    kickoff_mock.assert_has_calls(
         [mock.call(inputs={"topic": "AI"}), mock.call(inputs={"topic": "AI"})]
     )