Merge branch 'main' into feat/improve-tooling-docs

* improve tool text descriptoin and args

* fix lint

* Drop print

* add back in docstring

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/flows.mdx

@@ -599,13 +599,114 @@ The generated plot will display nodes representing the tasks in your flow, with
 
 By visualizing your flows, you can gain a clearer understanding of the workflow's structure, making it easier to debug, optimize, and communicate your AI processes to others.
 
-### Conclusion
 
-Plotting your flows is a powerful feature of CrewAI that enhances your ability to design and manage complex AI workflows. Whether you choose to use the `plot()` method or the command line, generating plots will provide you with a visual representation of your workflows, aiding in both development and presentation.
+## Advanced
+
+In this section, we explore more complex use cases of CrewAI Flows, starting with a self-evaluation loop. This pattern is crucial for developing AI systems that can iteratively improve their outputs through feedback.
+
+### 1) Self-Evaluation Loop
+
+The self-evaluation loop is a powerful pattern that allows AI workflows to automatically assess and refine their outputs. This example demonstrates how to set up a flow that generates content, evaluates it, and iterates based on feedback until the desired quality is achieved.
+
+#### Overview
+
+The self-evaluation loop involves two main Crews:
+
+1. **ShakespeareanXPostCrew**: Generates a Shakespearean-style post on a given topic.
+2. **XPostReviewCrew**: Evaluates the generated post, providing feedback on its validity and quality.
+
+The process iterates until the post meets the criteria or a maximum retry limit is reached. This approach ensures high-quality outputs through iterative refinement.
+
+#### Importance
+
+This pattern is essential for building robust AI systems that can adapt and improve over time. By automating the evaluation and feedback loop, developers can ensure that their AI workflows produce reliable and high-quality results.
+
+#### Main Code Highlights
+
+Below is the `main.py` file for the self-evaluation loop flow:
+
+```python
+from typing import Optional
+from crewai.flow.flow import Flow, listen, router, start
+from pydantic import BaseModel
+from self_evaluation_loop_flow.crews.shakespeare_crew.shakespeare_crew import (
+    ShakespeareanXPostCrew,
+)
+from self_evaluation_loop_flow.crews.x_post_review_crew.x_post_review_crew import (
+    XPostReviewCrew,
+)
+
+class ShakespeareXPostFlowState(BaseModel):
+    x_post: str = ""
+    feedback: Optional[str] = None
+    valid: bool = False
+    retry_count: int = 0
+
+class ShakespeareXPostFlow(Flow[ShakespeareXPostFlowState]):
+
+    @start("retry")
+    def generate_shakespeare_x_post(self):
+        print("Generating Shakespearean X post")
+        topic = "Flying cars"
+        result = (
+            ShakespeareanXPostCrew()
+            .crew()
+            .kickoff(inputs={"topic": topic, "feedback": self.state.feedback})
+        )
+        print("X post generated", result.raw)
+        self.state.x_post = result.raw
+
+    @router(generate_shakespeare_x_post)
+    def evaluate_x_post(self):
+        if self.state.retry_count > 3:
+            return "max_retry_exceeded"
+        result = XPostReviewCrew().crew().kickoff(inputs={"x_post": self.state.x_post})
+        self.state.valid = result["valid"]
+        self.state.feedback = result["feedback"]
+        print("valid", self.state.valid)
+        print("feedback", self.state.feedback)
+        self.state.retry_count += 1
+        if self.state.valid:
+            return "complete"
+        return "retry"
+
+    @listen("complete")
+    def save_result(self):
+        print("X post is valid")
+        print("X post:", self.state.x_post)
+        with open("x_post.txt", "w") as file:
+            file.write(self.state.x_post)
+
+    @listen("max_retry_exceeded")
+    def max_retry_exceeded_exit(self):
+        print("Max retry count exceeded")
+        print("X post:", self.state.x_post)
+        print("Feedback:", self.state.feedback)
+
+def kickoff():
+    shakespeare_flow = ShakespeareXPostFlow()
+    shakespeare_flow.kickoff()
+
+def plot():
+    shakespeare_flow = ShakespeareXPostFlow()
+    shakespeare_flow.plot()
+
+if __name__ == "__main__":
+    kickoff()
+```
+
+#### Code Highlights
+
+- **Retry Mechanism**: The flow uses a retry mechanism to regenerate the post if it doesn't meet the criteria, up to a maximum of three retries.
+- **Feedback Loop**: Feedback from the `XPostReviewCrew` is used to refine the post iteratively.
+- **State Management**: The flow maintains state using a Pydantic model, ensuring type safety and clarity.
+
+For a complete example and further details, please refer to the [Self Evaluation Loop Flow repository](https://github.com/crewAIInc/crewAI-examples/tree/main/self_evaluation_loop_flow).
+
 
 ## Next Steps
 
-If you're interested in exploring additional examples of flows, we have a variety of recommendations in our examples repository. Here are four specific flow examples, each showcasing unique use cases to help you match your current problem type to a specific example:
+If you're interested in exploring additional examples of flows, we have a variety of recommendations in our examples repository. Here are five specific flow examples, each showcasing unique use cases to help you match your current problem type to a specific example:
 
 1. **Email Auto Responder Flow**: This example demonstrates an infinite loop where a background job continually runs to automate email responses. It's a great use case for tasks that need to be performed repeatedly without manual intervention. [View Example](https://github.com/crewAIInc/crewAI-examples/tree/main/email_auto_responder_flow)
 
@@ -615,6 +716,8 @@ If you're interested in exploring additional examples of flows, we have a variet
 
 4. **Meeting Assistant Flow**: This flow demonstrates how to broadcast one event to trigger multiple follow-up actions. For instance, after a meeting is completed, the flow can update a Trello board, send a Slack message, and save the results. It's a great example of handling multiple outcomes from a single event, making it ideal for comprehensive task management and notification systems. [View Example](https://github.com/crewAIInc/crewAI-examples/tree/main/meeting_assistant_flow)
 
+5. **Self Evaluation Loop Flow**: This flow demonstrates a self-evaluation loop where AI workflows automatically assess and refine their outputs through feedback. It involves generating content, evaluating it, and iterating until the desired quality is achieved. This pattern is crucial for developing robust AI systems that can adapt and improve over time. [View Example](https://github.com/crewAIInc/crewAI-examples/tree/main/self_evaluation_loop_flow)
+
 By exploring these examples, you can gain insights into how to leverage CrewAI Flows for various use cases, from automating repetitive tasks to managing complex, multi-step processes with dynamic decision-making and human feedback.
 
 Also, check out our YouTube video on how to use flows in CrewAI below!

docs/concepts/memory.mdx

@@ -118,7 +118,7 @@ Alternatively, you can directly pass the OpenAIEmbeddingFunction to the embedder
 Example:
 ```python Code
 from crewai import Crew, Agent, Task, Process
-from chromadb.utils.embedding_functions.openai_embedding_function import OpenAIEmbeddingFunction
+from chromadb.utils.embedding_functions import OpenAIEmbeddingFunction
 
 my_crew = Crew(
     agents=[...],
@@ -174,6 +174,7 @@ my_crew = Crew(
 ### Using Azure OpenAI embeddings
 
 ```python Code
+from chromadb.utils.embedding_functions import OpenAIEmbeddingFunction
 from crewai import Crew, Agent, Task, Process
 
 my_crew = Crew(
@@ -182,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",
@@ -195,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(
@@ -203,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",

docs/how-to/create-custom-tools.mdx

@@ -20,14 +20,21 @@ pip install 'crewai[tools]'
 
 ### Subclassing `BaseTool`
 
-To create a personalized tool, inherit from `BaseTool` and define the necessary attributes and the `_run` method.
+To create a personalized tool, inherit from `BaseTool` and define the necessary attributes, including the `args_schema` for input validation, and the `_run` method.
 
 ```python Code
+from typing import Type
 from crewai_tools import BaseTool
+from pydantic import BaseModel, Field
+
+class MyToolInput(BaseModel):
+    """Input schema for MyCustomTool."""
+    argument: str = Field(..., description="Description of the argument.")
 
 class MyCustomTool(BaseTool):
     name: str = "Name of my tool"
     description: str = "What this tool does. It's vital for effective utilization."
+    args_schema: Type[BaseModel] = MyToolInput
 
     def _run(self, argument: str) -> str:
         # Your tool's logic here

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "crewai"
-version = "0.75.1"
+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.75.1"
+__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/cli.py

@@ -33,10 +33,11 @@ def crewai():
 @click.argument("type", type=click.Choice(["crew", "pipeline", "flow"]))
 @click.argument("name")
 @click.option("--provider", type=str, help="The provider to use for the crew")
-def create(type, name, provider):
+@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, provider)
+        create_crew(name, provider, skip_provider)
     elif type == "pipeline":
         create_pipeline(name)
     elif type == "flow":
@@ -177,10 +178,14 @@ 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()

src/crewai/cli/create_crew.py

@@ -81,77 +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
 
-    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
+        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
 
-    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")
+        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
+
+        provider_models = get_provider_data()
+        if not provider_models:
             return
 
-    provider_models = get_provider_data()
-    if not provider_models:
-        return
+        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_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"
+            )
 
-    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="",
+            )
 
-    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 = ""
+        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 = ""
 
-    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")
+        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"] = selected_model
-    click.secho(f"Selected model: {selected_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/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.75.1,<1.0.0"
+    "crewai[tools]>=0.76.2,<1.0.0"
 ]
 
 [project.scripts]

src/crewai/cli/templates/crew/tools/custom_tool.py

@@ -1,11 +1,17 @@
+from typing import Type
 from crewai_tools import BaseTool
+from pydantic import BaseModel, Field
 
+class MyCustomToolInput(BaseModel):
+    """Input schema for MyCustomTool."""
+    argument: str = Field(..., description="Description of the argument.")
 
 class MyCustomTool(BaseTool):
     name: str = "Name of my tool"
     description: str = (
         "Clear description for what this tool is useful for, you agent will need this information to use it."
     )
+    args_schema: Type[BaseModel] = MyCustomToolInput
 
     def _run(self, argument: str) -> str:
         # Implementation goes here

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

src/crewai/cli/templates/flow/tools/custom_tool.py

@@ -1,4 +1,13 @@
+from typing import Type
+
 from crewai_tools import BaseTool
+from pydantic import BaseModel, Field
+
+
+class MyCustomToolInput(BaseModel):
+    """Input schema for MyCustomTool."""
+
+    argument: str = Field(..., description="Description of the argument.")
 
 
 class MyCustomTool(BaseTool):
@@ -6,6 +15,7 @@ class MyCustomTool(BaseTool):
     description: str = (
         "Clear description for what this tool is useful for, you agent will need this information to use it."
     )
+    args_schema: Type[BaseModel] = MyCustomToolInput
 
     def _run(self, argument: str) -> str:
         # Implementation goes here

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.75.1,<1.0.0" }
+crewai = { extras = ["tools"], version = ">=0.76.2,<1.0.0" }
 asyncio = "*"
 
 [tool.poetry.scripts]

src/crewai/cli/templates/pipeline/tools/custom_tool.py

@@ -1,11 +1,17 @@
+from typing import Type
 from crewai_tools import BaseTool
+from pydantic import BaseModel, Field
 
+class MyCustomToolInput(BaseModel):
+    """Input schema for MyCustomTool."""
+    argument: str = Field(..., description="Description of the argument.")
 
 class MyCustomTool(BaseTool):
     name: str = "Name of my tool"
     description: str = (
         "Clear description for what this tool is useful for, you agent will need this information to use it."
     )
+    args_schema: Type[BaseModel] = MyCustomToolInput
 
     def _run(self, argument: str) -> str:
         # Implementation goes here

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

src/crewai/cli/templates/pipeline_router/tools/custom_tool.py

@@ -1,11 +1,17 @@
+from typing import Type
 from crewai_tools import BaseTool
+from pydantic import BaseModel, Field
 
+class MyCustomToolInput(BaseModel):
+    """Input schema for MyCustomTool."""
+    argument: str = Field(..., description="Description of the argument.")
 
 class MyCustomTool(BaseTool):
     name: str = "Name of my tool"
     description: str = (
         "Clear description for what this tool is useful for, you agent will need this information to use it."
     )
+    args_schema: Type[BaseModel] = MyCustomToolInput
 
     def _run(self, argument: str) -> str:
         # Implementation goes here

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.75.1"
+    "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)