fix unnecessary deps

- refactor code to multiple functions
- Added ability for users to select provider and model when uing crewai create command and ave API key to .env

README.md

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

docs/concepts/agents.mdx

@@ -31,17 +31,16 @@ 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
 
@@ -84,7 +83,6 @@ 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'
 )
 ```
 
@@ -158,4 +156,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. The `code_execution_mode` attribute provides flexibility in how agents execute code, allowing for both secure and direct execution options.
+you can create sophisticated AI systems that leverage the power of collaborative intelligence.

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 & flows.
+The CrewAI CLI provides a set of commands to interact with CrewAI, allowing you to create, train, run, and manage crews and pipelines.
 
 ## Installation
 
@@ -146,34 +146,3 @@ 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

@@ -23,9 +23,9 @@ Flows allow you to create structured, event-driven workflows. They provide a sea
 Let's create a simple Flow where you will use OpenAI to generate a random city in one task and then use that city to generate a fun fact in another task.
 
 ```python Code
+import asyncio
 
 from crewai.flow.flow import Flow, listen, start
-from dotenv import load_dotenv
 from litellm import completion
 
 
@@ -67,19 +67,19 @@ class ExampleFlow(Flow):
         return fun_fact
 
 
+async def main():
+    flow = ExampleFlow()
+    result = await flow.kickoff()
 
-flow = ExampleFlow()
-result = flow.kickoff()
+    print(f"Generated fun fact: {result}")
 
-print(f"Generated fun fact: {result}")
+asyncio.run(main())
 ```
 
 In the above example, we have created a simple Flow that generates a random city using OpenAI and then generates a fun fact about that city. The Flow consists of two tasks: `generate_city` and `generate_fun_fact`. The `generate_city` task is the starting point of the Flow, and the `generate_fun_fact` task listens for the output of the `generate_city` task.
 
 When you run the Flow, it will generate a random city and then generate a fun fact about that city. The output will be printed to the console.
 
-**Note:** Ensure you have set up your `.env` file to store your `OPENAI_API_KEY`. This key is necessary for authenticating requests to the OpenAI API.
-
 ### @start()
 
 The `@start()` decorator is used to mark a method as the starting point of a Flow. When a Flow is started, all the methods decorated with `@start()` are executed in parallel. You can have multiple start methods in a Flow, and they will all be executed when the Flow is started.
@@ -119,6 +119,7 @@ Here's how you can access the final output:
 
 <CodeGroup>
 ```python Code
+import asyncio
 from crewai.flow.flow import Flow, listen, start
 
 class OutputExampleFlow(Flow):
@@ -130,24 +131,26 @@ class OutputExampleFlow(Flow):
     def second_method(self, first_output):
         return f"Second method received: {first_output}"
 
+async def main():
+    flow = OutputExampleFlow()
+    final_output = await flow.kickoff()
+    print("---- Final Output ----")
+    print(final_output)
 
-flow = OutputExampleFlow()
-final_output = flow.kickoff()
-
-print("---- Final Output ----")
-print(final_output)
-````
+asyncio.run(main())
+```
 
 ``` text Output
 ---- Final Output ----
 Second method received: Output from first_method
-````
+```
 
 </CodeGroup>
 
 In this example, the `second_method` is the last method to complete, so its output will be the final output of the Flow. 
 The `kickoff()` method will return the final output, which is then printed to the console.
 
+
 #### Accessing and Updating State
 
 In addition to retrieving the final output, you can also access and update the state within your Flow. The state can be used to store and share data between different methods in the Flow. After the Flow has run, you can access the state to retrieve any information that was added or updated during the execution.
@@ -157,6 +160,7 @@ Here's an example of how to update and access the state:
 <CodeGroup>
 
 ```python Code
+import asyncio
 from crewai.flow.flow import Flow, listen, start
 from pydantic import BaseModel
 
@@ -177,19 +181,21 @@ class StateExampleFlow(Flow[ExampleState]):
         self.state.counter += 1
         return self.state.message
 
-flow = StateExampleFlow()
-final_output = flow.kickoff()
-print(f"Final Output: {final_output}")
-print("Final State:")
-print(flow.state)
+async def main():
+    flow = StateExampleFlow()
+    final_output = await flow.kickoff()
+    print(f"Final Output: {final_output}")
+    print("Final State:")
+    print(flow.state)
+
+asyncio.run(main())
 ```
 
-```text Output
+``` text Output
 Final Output: Hello from first_method - updated by second_method
 Final State:
 counter=2 message='Hello from first_method - updated by second_method'
 ```
-
 </CodeGroup>
 
 In this example, the state is updated by both `first_method` and `second_method`. 
@@ -209,6 +215,8 @@ In unstructured state management, all state is stored in the `state` attribute o
 This approach offers flexibility, enabling developers to add or modify state attributes on the fly without defining a strict schema.
 
 ```python Code
+import asyncio
+
 from crewai.flow.flow import Flow, listen, start
 
 class UntructuredExampleFlow(Flow):
@@ -231,8 +239,12 @@ class UntructuredExampleFlow(Flow):
         print(f"State after third_method: {self.state}")
 
 
-flow = UntructuredExampleFlow()
-flow.kickoff()
+async def main():
+    flow = UntructuredExampleFlow()
+    await flow.kickoff()
+
+
+asyncio.run(main())
 ```
 
 **Key Points:**
@@ -246,6 +258,8 @@ Structured state management leverages predefined schemas to ensure consistency a
 By using models like Pydantic's `BaseModel`, developers can define the exact shape of the state, enabling better validation and auto-completion in development environments.
 
 ```python Code
+import asyncio
+
 from crewai.flow.flow import Flow, listen, start
 from pydantic import BaseModel
 
@@ -274,8 +288,12 @@ class StructuredExampleFlow(Flow[ExampleState]):
         print(f"State after third_method: {self.state}")
 
 
-flow = StructuredExampleFlow()
-flow.kickoff()
+async def main():
+    flow = StructuredExampleFlow()
+    await flow.kickoff()
+
+
+asyncio.run(main())
 ```
 
 **Key Points:**
@@ -308,6 +326,7 @@ The `or_` function in Flows allows you to listen to multiple methods and trigger
 <CodeGroup>
 
 ```python Code
+import asyncio
 from crewai.flow.flow import Flow, listen, or_, start
 
 class OrExampleFlow(Flow):
@@ -325,12 +344,15 @@ class OrExampleFlow(Flow):
         print(f"Logger: {result}")
 
 
+async def main():
+    flow = OrExampleFlow()
+    await flow.kickoff()
 
-flow = OrExampleFlow()
-flow.kickoff()
+
+asyncio.run(main())
 ```
 
-```text Output
+``` text Output
 Logger: Hello from the start method
 Logger: Hello from the second method
 ```
@@ -347,6 +369,7 @@ The `and_` function in Flows allows you to listen to multiple methods and trigge
 <CodeGroup>
 
 ```python Code
+import asyncio
 from crewai.flow.flow import Flow, and_, listen, start
 
 class AndExampleFlow(Flow):
@@ -364,11 +387,16 @@ class AndExampleFlow(Flow):
         print("---- Logger ----")
         print(self.state)
 
-flow = AndExampleFlow()
-flow.kickoff()
+
+async def main():
+    flow = AndExampleFlow()
+    await flow.kickoff()
+
+
+asyncio.run(main())
 ```
 
-```text Output
+``` text Output
 ---- Logger ----
 {'greeting': 'Hello from the start method', 'joke': 'What do computers eat? Microchips.'}
 ```
@@ -386,6 +414,7 @@ You can specify different routes based on the output of the method, allowing you
 <CodeGroup>
 
 ```python Code
+import asyncio
 import random
 from crewai.flow.flow import Flow, listen, router, start
 from pydantic import BaseModel
@@ -417,11 +446,15 @@ class RouterFlow(Flow[ExampleState]):
         print("Fourth method running")
 
 
-flow = RouterFlow()
-flow.kickoff()
+async def main():
+    flow = RouterFlow()
+    await flow.kickoff()
+
+
+asyncio.run(main())
 ```
 
-```text Output
+``` text Output
 Starting the structured flow
 Third method running
 Fourth method running
@@ -452,21 +485,22 @@ This command will generate a new CrewAI project with the necessary folder struct
 
 After running the `crewai create flow name_of_flow` command, you will see a folder structure similar to the following:
 
-| Directory/File         | Description                                                        |
-| :--------------------- | :----------------------------------------------------------------- |
-| `name_of_flow/`        | Root directory for the flow.                                       |
-| ├── `crews/`           | Contains directories for specific crews.                           |
-| │ └── `poem_crew/`     | Directory for the "poem_crew" with its configurations and scripts. |
-| │ ├── `config/`        | Configuration files directory for the "poem_crew".                 |
-| │ │ ├── `agents.yaml`  | YAML file defining the agents for "poem_crew".                     |
-| │ │ └── `tasks.yaml`   | YAML file defining the tasks for "poem_crew".                      |
-| │ ├── `poem_crew.py`   | Script for "poem_crew" functionality.                              |
-| ├── `tools/`           | Directory for additional tools used in the flow.                   |
-| │ └── `custom_tool.py` | Custom tool implementation.                                        |
-| ├── `main.py`          | Main script for running the flow.                                  |
-| ├── `README.md`        | Project description and instructions.                              |
-| ├── `pyproject.toml`   | Configuration file for project dependencies and settings.          |
-| └── `.gitignore`       | Specifies files and directories to ignore in version control.      |
+| Directory/File                   | Description                                                       |
+|:---------------------------------|:------------------------------------------------------------------|
+| `name_of_flow/`                  | Root directory for the flow.                                      |
+| ├── `crews/`                     | Contains directories for specific crews.                          |
+| │   └── `poem_crew/`             | Directory for the "poem_crew" with its configurations and scripts.|
+| │       ├── `config/`            | Configuration files directory for the "poem_crew".                |
+| │       │   ├── `agents.yaml`    | YAML file defining the agents for "poem_crew".                    |
+| │       │   └── `tasks.yaml`     | YAML file defining the tasks for "poem_crew".                     |
+| │       ├── `poem_crew.py`       | Script for "poem_crew" functionality.                             |
+| ├── `tools/`                     | Directory for additional tools used in the flow.                  |
+| │   └── `custom_tool.py`         | Custom tool implementation.                                       |
+| ├── `main.py`                    | Main script for running the flow.                                 |
+| ├── `README.md`                  | Project description and instructions.                             |
+| ├── `pyproject.toml`             | Configuration file for project dependencies and settings.         |
+| └── `.gitignore`                 | Specifies files and directories to ignore in version control.     |
+
 
 ### Building Your Crews
 
@@ -486,6 +520,7 @@ Here's an example of how you can connect the `poem_crew` in the `main.py` file:
 
 ```python Code
 #!/usr/bin/env python
+import asyncio
 from random import randint
 
 from pydantic import BaseModel
@@ -501,12 +536,14 @@ class PoemFlow(Flow[PoemState]):
     @start()
     def generate_sentence_count(self):
         print("Generating sentence count")
+        # Generate a number between 1 and 5
         self.state.sentence_count = randint(1, 5)
 
     @listen(generate_sentence_count)
     def generate_poem(self):
         print("Generating poem")
-        result = PoemCrew().crew().kickoff(inputs={"sentence_count": self.state.sentence_count})
+        poem_crew = PoemCrew().crew()
+        result = poem_crew.kickoff(inputs={"sentence_count": self.state.sentence_count})
 
         print("Poem generated", result.raw)
         self.state.poem = result.raw
@@ -517,17 +554,18 @@ class PoemFlow(Flow[PoemState]):
         with open("poem.txt", "w") as f:
             f.write(self.state.poem)
 
-def kickoff():
+async def run():
+    """
+    Run the flow.
+    """
     poem_flow = PoemFlow()
-    poem_flow.kickoff()
+    await poem_flow.kickoff()
 
-
-def plot():
-    poem_flow = PoemFlow()
-    poem_flow.plot()
+def main():
+    asyncio.run(run())
 
 if __name__ == "__main__":
-    kickoff()
+    main()
 ```
 
 In this example, the `PoemFlow` class defines a flow that generates a sentence count, uses the `PoemCrew` to generate a poem, and then saves the poem to a file. The flow is kicked off by calling the `kickoff()` method.
@@ -549,13 +587,13 @@ source .venv/bin/activate
 After activating the virtual environment, you can run the flow by executing one of the following commands:
 
 ```bash
-crewai flow kickoff
+crewai flow run
 ```
 
 or
 
 ```bash
-uv run kickoff
+uv run run_flow
 ```
 
 The flow will execute, and you should see the output in the console.
@@ -599,114 +637,13 @@ 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
 
-## 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).
-
+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.
 
 ## Next Steps
 
-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:
+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:
 
 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)
 
@@ -716,19 +653,17 @@ 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!
 
 <iframe 
-  width="560"
-  height="315"
-  src="https://www.youtube.com/embed/MTb5my6VOT8"
-  title="YouTube video player"
-  frameborder="0"
-  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
-  referrerpolicy="strict-origin-when-cross-origin"
-  allowfullscreen
+    width="560" 
+    height="315" 
+    src="https://www.youtube.com/embed/MTb5my6VOT8" 
+    title="YouTube video player" 
+    frameborder="0" 
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" 
+    referrerpolicy="strict-origin-when-cross-origin" 
+    allowfullscreen
 ></iframe>    

docs/concepts/llms.mdx

@@ -62,8 +62,6 @@ os.environ["OPENAI_API_BASE"] = "https://api.your-provider.com/v1"
 2. Using LLM class attributes:
 
 ```python Code
-from crewai import LLM
-
 llm = LLM(
     model="custom-model-name",
     api_key="your-api-key",
@@ -97,11 +95,9 @@ When configuring an LLM for your agent, you have access to a wide range of param
 | **api_key**          | `str`             | Your API key for authentication.                                                                 |
 
 
-## OpenAI Example Configuration
+Example:
 
 ```python Code
-from crewai import LLM
-
 llm = LLM(
     model="gpt-4",
     temperature=0.8,
@@ -116,31 +112,15 @@ llm = LLM(
 )
 agent = Agent(llm=llm, ...)
 ```
-
-## Cerebras Example Configuration
-
-```python Code
-from crewai import LLM
-
-llm = LLM(
-    model="cerebras/llama-3.1-70b",
-    base_url="https://api.cerebras.ai/v1",
-    api_key="your-api-key-here"
-)
-agent = Agent(llm=llm, ...) 
-```
-
 ## Using Ollama (Local LLMs)
 
-CrewAI supports using Ollama for running open-source models locally:
+crewAI supports using Ollama for running open-source models locally:
 
 1. Install Ollama: [ollama.ai](https://ollama.ai/)
 2. Run a model: `ollama run llama2`
 3. Configure agent:
 
 ```python Code
-from crewai import LLM
-
 agent = Agent(
     llm=LLM(model="ollama/llama3.1", base_url="http://localhost:11434"),
     ...
@@ -152,8 +132,6 @@ agent = Agent(
 You can change the base API URL for any LLM provider by setting the `base_url` parameter:
 
 ```python Code
-from crewai import LLM
-
 llm = LLM(
     model="custom-model-name",
     base_url="https://api.your-provider.com/v1",

docs/concepts/memory.mdx

@@ -34,7 +34,7 @@ By default, the memory system is disabled, and you can ensure it is active by se
 The memory will use OpenAI embeddings by default, but you can change it by setting `embedder` to a different model. 
 It's also possible to initialize the memory instance with your own instance.
 
-The 'embedder' only applies to **Short-Term Memory** which uses Chroma for RAG.
+The 'embedder' only applies to **Short-Term Memory** which uses Chroma for RAG using the EmbedChain package.
 The **Long-Term Memory** uses SQLite3 to store task results. Currently, there is no way to override these storage implementations.
 The data storage files are saved into a platform-specific location found using the appdirs package,
 and the name of the project can be overridden using the **CREWAI_STORAGE_DIR** environment variable.
@@ -113,42 +113,6 @@ my_crew = Crew(
     }
 )
 ```
-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"
-        }
-    }
-)
-```
 
 ### Using Google AI embeddings
 
@@ -164,8 +128,9 @@ my_crew = Crew(
     embedder={
         "provider": "google",
         "config": {
-            "api_key": "<YOUR_API_KEY>",
-            "model_name": "<model_name>"
+            "model": 'models/embedding-001',
+            "task_type": "retrieval_document",
+            "title": "Embeddings for Embedchain"
         }
     }
 )
@@ -174,7 +139,6 @@ 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(
@@ -183,20 +147,36 @@ my_crew = Crew(
     process=Process.sequential,
     memory=True,
     verbose=True,
-    embedder=OpenAIEmbeddingFunction(
-        api_key="YOUR_API_KEY",
-        api_base="YOUR_API_BASE_PATH",
-        api_type="azure",
-        api_version="YOUR_API_VERSION",
-        model_name="text-embedding-3-small"
-    )
+    embedder={
+        "provider": "azure_openai",
+        "config": {
+            "model": 'text-embedding-ada-002',
+            "deployment_name": "your_embedding_model_deployment_name"
+        }
+    }
+)
+```
+
+### Using GPT4ALL embeddings
+
+```python Code
+from crewai import Crew, Agent, Task, Process
+
+my_crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process=Process.sequential,
+    memory=True,
+    verbose=True,
+    embedder={
+        "provider": "gpt4all"
+    }
 )
 ```
 
 ### Using Vertex AI embeddings
 
 ```python Code
-from chromadb.utils.embedding_functions import GoogleVertexEmbeddingFunction
 from crewai import Crew, Agent, Task, Process
 
 my_crew = Crew(
@@ -205,12 +185,12 @@ my_crew = Crew(
     process=Process.sequential,
     memory=True,
     verbose=True,
-    embedder=GoogleVertexEmbeddingFunction(
-        project_id="YOUR_PROJECT_ID",
-        region="YOUR_REGION",
-        api_key="YOUR_API_KEY",
-        model_name="textembedding-gecko"
-    )
+    embedder={
+        "provider": "vertexai",
+        "config": {
+            "model": 'textembedding-gecko'
+        }
+    }
 )
 ```
 
@@ -228,27 +208,8 @@ my_crew = Crew(
     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>",
+            "model": "embed-english-v3.0",
+            "vector_dimension": 1024
         }
     }
 )

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

@@ -20,21 +20,14 @@ pip install 'crewai[tools]'
 
 ### Subclassing `BaseTool`
 
-To create a personalized tool, inherit from `BaseTool` and define the necessary attributes, including the `args_schema` for input validation, and the `_run` method.
+To create a personalized tool, inherit from `BaseTool` and define the necessary attributes 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

docs/tools/visiontool.mdx

@@ -11,10 +11,10 @@ icon: eye
 This tool is used to extract text from images. When passed to the agent it will extract the text from the image and then use it to generate a response, report or any other output. 
 The URL or the PATH of the image should be passed to the Agent.
 
+
 ## Installation
 
 Install the crewai_tools package
-
 ```shell
 pip install 'crewai[tools]'
 ```
@@ -44,6 +44,7 @@ def researcher(self) -> Agent:
 
 The VisionTool requires the following arguments:
 
-| Argument           | Type     | Description                                                                      |
-| :----------------- | :------- | :------------------------------------------------------------------------------- |
-| **image_path_url** | `string` | **Mandatory**. The path to the image file from which text needs to be extracted. |
+| Argument       | Type     | Description                                                                                                                         |
+|:---------------|:---------|:-------------------------------------------------------------------------------------------------------------------------------------|
+| **image_path** | `string` | **Mandatory**. The path to the image file from which text needs to be extracted.                                                |
+

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "crewai"
-version = "0.76.2"
+version = "0.70.1"
 description = "Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks."
 readme = "README.md"
 requires-python = ">=3.10,<=3.13"
@@ -16,19 +16,19 @@ dependencies = [
     "opentelemetry-exporter-otlp-proto-http>=1.22.0",
     "instructor>=1.3.3",
     "regex>=2024.9.11",
-    "crewai-tools>=0.13.2",
+    "crewai-tools>=0.12.1",
     "click>=8.1.7",
     "python-dotenv>=1.0.0",
     "appdirs>=1.4.4",
     "jsonref>=1.1.0",
+    "agentops>=0.3.0",
+    "embedchain>=0.1.114",
     "json-repair>=0.25.2",
     "auth0-python>=4.7.1",
     "litellm>=1.44.22",
     "pyvis>=0.3.2",
-    "uv>=0.4.25",
+    "uv>=0.4.18",
     "tomli-w>=1.1.0",
-    "chromadb>=0.4.24",
-    "tomli>=2.0.2",
 ]
 
 [project.urls]
@@ -37,7 +37,7 @@ Documentation = "https://docs.crewai.com"
 Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
-tools = ["crewai-tools>=0.13.2"]
+tools = ["crewai-tools>=0.12.1"]
 agentops = ["agentops>=0.3.0"]
 
 [tool.uv]
@@ -52,7 +52,7 @@ dev-dependencies = [
     "mkdocs-material-extensions>=1.3.1",
     "pillow>=10.2.0",
     "cairosvg>=2.7.1",
-    "crewai-tools>=0.13.2",
+    "crewai-tools>=0.12.1",
     "pytest>=8.0.0",
     "pytest-vcr>=1.0.2",
     "python-dotenv>=1.0.0",

src/crewai/__init__.py

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

src/crewai/agent.py

@@ -1,7 +1,6 @@
 import os
-import shutil
-import subprocess
-from typing import Any, List, Literal, Optional, Union
+from inspect import signature
+from typing import Any, List, Optional, Union
 
 from pydantic import Field, InstanceOf, PrivateAttr, model_validator
 
@@ -113,10 +112,6 @@ 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):
@@ -178,9 +173,6 @@ 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):
@@ -316,9 +308,7 @@ class Agent(BaseAgent):
         try:
             from crewai_tools import 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)]
+            return [CodeInterpreterTool()]
         except ModuleNotFoundError:
             self._logger.log(
                 "info", "Coding tools not available. Install crewai_tools. "
@@ -394,49 +384,30 @@ 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 = {
-                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}"
-            )
+            args_schema = str(tool.args)
+            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}"
+                )
             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/agents/agent_builder/base_agent_executor_mixin.py

@@ -17,7 +17,7 @@ if TYPE_CHECKING:
 
 class CrewAgentExecutorMixin:
     crew: Optional["Crew"]
-    agent: Optional["BaseAgent"]
+    crew_agent: Optional["BaseAgent"]
     task: Optional["Task"]
     iterations: int
     have_forced_answer: bool
@@ -33,9 +33,9 @@ class CrewAgentExecutorMixin:
         """Create and save a short-term memory item if conditions are met."""
         if (
             self.crew
-            and self.agent
+            and self.crew_agent
             and self.task
-            and "Action: Delegate work to coworker" not in output.text
+            and "Action: Delegate work to coworker" not in output.log
         ):
             try:
                 if (
@@ -43,11 +43,11 @@ class CrewAgentExecutorMixin:
                     and self.crew._short_term_memory
                 ):
                     self.crew._short_term_memory.save(
-                        value=output.text,
+                        value=output.log,
                         metadata={
                             "observation": self.task.description,
                         },
-                        agent=self.agent.role,
+                        agent=self.crew_agent.role,
                     )
             except Exception as e:
                 print(f"Failed to add to short term memory: {e}")
@@ -61,18 +61,18 @@ class CrewAgentExecutorMixin:
             and self.crew._long_term_memory
             and self.crew._entity_memory
             and self.task
-            and self.agent
+            and self.crew_agent
         ):
             try:
-                ltm_agent = TaskEvaluator(self.agent)
-                evaluation = ltm_agent.evaluate(self.task, output.text)
+                ltm_agent = TaskEvaluator(self.crew_agent)
+                evaluation = ltm_agent.evaluate(self.task, output.log)
 
                 if isinstance(evaluation, ConverterError):
                     return
 
                 long_term_memory = LongTermMemoryItem(
                     task=self.task.description,
-                    agent=self.agent.role,
+                    agent=self.crew_agent.role,
                     quality=evaluation.quality,
                     datetime=str(time.time()),
                     expected_output=self.task.expected_output,

src/crewai/agents/crew_agent_executor.py

@@ -2,7 +2,6 @@ import json
 import re
 from typing import Any, Dict, List, Union
 
-from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.agents.agent_builder.base_agent_executor_mixin import CrewAgentExecutorMixin
 from crewai.agents.parser import (
     FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE,
@@ -30,7 +29,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         llm: Any,
         task: Any,
         crew: Any,
-        agent: BaseAgent,
+        agent: Any,
         prompt: dict[str, str],
         max_iter: int,
         tools: List[Any],
@@ -104,8 +103,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
 
             if self.crew and self.crew._train:
                 self._handle_crew_training_output(formatted_answer)
-        self._create_short_term_memory(formatted_answer)
-        self._create_long_term_memory(formatted_answer)
+
         return {"output": formatted_answer.output}
 
     def _invoke_loop(self, formatted_answer=None):
@@ -178,8 +176,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         return formatted_answer
 
     def _show_start_logs(self):
-        if self.agent is None:
-            raise ValueError("Agent cannot be None")
         if self.agent.verbose or (
             hasattr(self, "crew") and getattr(self.crew, "verbose", False)
         ):
@@ -192,8 +188,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             )
 
     def _show_logs(self, formatted_answer: Union[AgentAction, AgentFinish]):
-        if self.agent is None:
-            raise ValueError("Agent cannot be None")
         if self.agent.verbose or (
             hasattr(self, "crew") and getattr(self.crew, "verbose", False)
         ):
@@ -312,7 +306,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         self, result: AgentFinish, human_feedback: str | None = None
     ) -> None:
         """Function to handle the process of the training data."""
-        agent_id = str(self.agent.id)  # type: ignore
+        agent_id = str(self.agent.id)
 
         # Load training data
         training_handler = CrewTrainingHandler(TRAINING_DATA_FILE)
@@ -323,9 +317,9 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             if self.crew is not None and hasattr(self.crew, "_train_iteration"):
                 train_iteration = self.crew._train_iteration
                 if agent_id in training_data and isinstance(train_iteration, int):
-                    training_data[agent_id][train_iteration][
-                        "improved_output"
-                    ] = result.output
+                    training_data[agent_id][train_iteration]["improved_output"] = (
+                        result.output
+                    )
                     training_handler.save(training_data)
                 else:
                     self._logger.log(
@@ -345,7 +339,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                 "initial_output": result.output,
                 "human_feedback": human_feedback,
                 "agent": agent_id,
-                "agent_role": self.agent.role,  # type: ignore
+                "agent_role": self.agent.role,
             }
             if self.crew is not None and hasattr(self.crew, "_train_iteration"):
                 train_iteration = self.crew._train_iteration

src/crewai/cli/cli.py

@@ -14,11 +14,11 @@ from .authentication.main import AuthenticationCommand
 from .deploy.main import DeployCommand
 from .evaluate_crew import evaluate_crew
 from .install_crew import install_crew
-from .kickoff_flow import kickoff_flow
 from .plot_flow import plot_flow
 from .replay_from_task import replay_task_command
 from .reset_memories_command import reset_memories_command
 from .run_crew import run_crew
+from .run_flow import run_flow
 from .tools.main import ToolCommand
 from .train_crew import train_crew
 from .update_crew import update_crew
@@ -32,12 +32,10 @@ def crewai():
 @crewai.command()
 @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")
-@click.option("--skip_provider", is_flag=True, help="Skip provider validation")
-def create(type, name, provider, skip_provider=False):
+def create(type, name):
     """Create a new crew, pipeline, or flow."""
     if type == "crew":
-        create_crew(name, provider, skip_provider)
+        create_crew(name)
     elif type == "pipeline":
         create_pipeline(name)
     elif type == "flow":
@@ -178,14 +176,10 @@ def test(n_iterations: int, model: str):
     evaluate_crew(n_iterations, model)
 
 
-@crewai.command(context_settings=dict(
-    ignore_unknown_options=True,
-    allow_extra_args=True,
-))
-@click.pass_context
-def install(context):
+@crewai.command()
+def install():
     """Install the Crew."""
-    install_crew(context.args)
+    install_crew()
 
 
 @crewai.command()
@@ -310,11 +304,11 @@ def flow():
     pass
 
 
-@flow.command(name="kickoff")
+@flow.command(name="run")
 def flow_run():
-    """Kickoff the Flow."""
+    """Run the Flow."""
     click.echo("Running the Flow")
-    kickoff_flow()
+    run_flow()
 
 
 @flow.command(name="plot")

src/crewai/cli/create_crew.py

@@ -1,17 +1,8 @@
-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, select_model, 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):
     folder_name = name.replace(" ", "_").replace("-", "_").lower()
@@ -22,19 +13,11 @@ def create_folder_structure(name, parent_folder=None):
     else:
         folder_path = Path(folder_name)
 
-    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,
-        )
+    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)
@@ -43,10 +26,16 @@ 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
 
 
+
 def copy_template_files(folder_path, name, class_name, parent_folder):
     package_dir = Path(__file__).parent
     templates_dir = package_dir / "templates" / "crew"
@@ -65,9 +54,7 @@ def copy_template_files(folder_path, name, class_name, parent_folder):
         dst_file = folder_path / file_name
         copy_template(src_file, dst_file, name, class_name, folder_path.name)
 
-    src_folder = (
-        folder_path / "src" / folder_path.name if not parent_folder else folder_path
-    )
+    src_folder = folder_path / "src" / folder_path.name if not parent_folder else folder_path
 
     for file_name in src_template_files:
         src_file = templates_dir / file_name
@@ -81,84 +68,37 @@ 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, provider=None, skip_provider=False, parent_folder=None):
+def create_crew(name, 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
+    provider_models = get_provider_data()
+    if not provider_models:
+        return
 
-        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_provider = select_provider(provider_models)
+    if not selected_provider:
+        return
+    provider = selected_provider
 
-        provider_models = get_provider_data()
-        if not provider_models:
-            return
+    selected_model = select_model(provider, provider_models)
+    if not selected_model:
+        return
+    model = selected_model
 
-        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,
+    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
         )
-        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"
-            )
+    env_vars = {api_key_var: "YOUR_API_KEY_HERE"}
+    write_env_file(folder_path, env_vars)
 
-        env_vars["MODEL"] = selected_model
-        click.secho(f"Selected model: {selected_model}", fg="green")
+    env_vars['MODEL'] = model
+    click.secho(f"Selected model: {model}", fg="green")
 
     package_dir = Path(__file__).parent
     templates_dir = package_dir / "templates" / "crew"

src/crewai/cli/install_crew.py

@@ -3,13 +3,12 @@ import subprocess
 import click
 
 
-def install_crew(proxy_options: list[str]) -> None:
+def install_crew() -> None:
     """
     Install the crew by running the UV command to lock and install.
     """
     try:
-        command = ["uv", "sync"] + proxy_options
-        subprocess.run(command, check=True, capture_output=False, text=True)
+        subprocess.run(["uv", "sync"], 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"]
+    command = ["uv", "run", "plot_flow"]
 
     try:
         result = subprocess.run(command, capture_output=False, text=True, check=True)

src/crewai/cli/provider.py

@@ -1,13 +1,10 @@
 import json
 import time
-from collections import defaultdict
-from pathlib import Path
-
-import click
 import requests
-
-from crewai.cli.constants import JSON_URL, MODELS, PROVIDERS
-
+from collections import defaultdict
+import click
+from pathlib import Path 
+from crewai.cli.constants import PROVIDERS, MODELS, JSON_URL
 
 def select_choice(prompt_message, choices):
     """
@@ -18,37 +15,20 @@ def select_choice(prompt_message, choices):
     - choices (list): A list of options to present to the user.
     
     Returns:
-    - str: The selected choice from the list, or None if the user chooses to quit.
+    - str: The selected choice from the list, or None if the operation is aborted or an invalid selection is made.
     """
-
-    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")
-    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",
-        )
-
+    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]
 
 def select_provider(provider_models):
     """
@@ -58,25 +38,21 @@ def select_provider(provider_models):
     - provider_models (dict): A dictionary of provider models.
     
     Returns:
-    - str: The selected provider
-    - None: If user explicitly quits
+    - str: The selected provider, or None if the operation is aborted or an invalid selection is made.
     """
     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 provider is None:  # User typed 'q'
+    provider = select_choice("Select a provider to set up:", predefined_providers + ['other'])
+    if not provider:
         return None
+    provider = provider.lower()
 
-    if provider == "other":
+    if provider == 'other':
         provider = select_choice("Select a provider from the full list:", all_providers)
-        if provider is None:  # User typed 'q'
+        if not provider:
             return None
-
-    return provider.lower() if provider else False
-
+    return provider
 
 def select_model(provider, provider_models):
     """
@@ -100,12 +76,9 @@ 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.
@@ -118,24 +91,15 @@ def load_provider_data(cache_file, cache_expiry):
     - 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.
@@ -152,7 +116,6 @@ 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.
@@ -176,7 +139,6 @@ 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.
@@ -187,19 +149,16 @@ def download_data(response):
     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():
     """
@@ -208,9 +167,9 @@ def get_provider_data():
     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_file = cache_dir / 'provider_cache.json'
     cache_expiry = 24 * 3600 
 
     data = load_provider_data(cache_file, cache_expiry)
@@ -220,7 +179,7 @@ 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)

src/crewai/cli/run_crew.py

@@ -1,9 +1,10 @@
 import subprocess
 
 import click
+import tomllib
 from packaging import version
 
-from crewai.cli.utils import get_crewai_version, read_toml
+from crewai.cli.utils import get_crewai_version
 
 
 def run_crew() -> None:
@@ -14,9 +15,10 @@ def run_crew() -> None:
     crewai_version = get_crewai_version()
     min_required_version = "0.71.0"
 
-    pyproject_data = read_toml()
+    with open("pyproject.toml", "rb") as f:
+        data = tomllib.load(f)
 
-    if pyproject_data.get("tool", {}).get("poetry") and (
+    if data.get("tool", {}).get("poetry") and (
         version.parse(crewai_version) < version.parse(min_required_version)
     ):
         click.secho(
@@ -33,7 +35,10 @@ 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)
 
-        if pyproject_data.get("tool", {}).get("poetry"):
+        with open("pyproject.toml", "rb") as f:
+            data = tomllib.load(f)
+
+        if 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/run_flow.py

@@ -3,11 +3,11 @@ import subprocess
 import click
 
 
-def kickoff_flow() -> None:
+def run_flow() -> None:
     """
-    Kickoff the flow by running a command in the UV environment.
+    Run the flow by running a command in the UV environment.
     """
-    command = ["uv", "run", "kickoff"]
+    command = ["uv", "run", "run_flow"]
 
     try:
         result = subprocess.run(command, capture_output=False, text=True, check=True)

src/crewai/cli/templates/crew/main.py

@@ -3,7 +3,7 @@ import sys
 from {{folder_name}}.crew import {{crew_name}}Crew
 
 # This main file is intended to be a way for you to run your
-# crew locally, so refrain from adding unnecessary logic into this file.
+# crew locally, so refrain from adding necessary logic into this file.
 # Replace with inputs you want to test with, it will automatically
 # interpolate any tasks and agents information
 

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

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

@@ -1,17 +1,11 @@
-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/main.py

@@ -1,53 +1,65 @@
 #!/usr/bin/env python
+import asyncio
 from random import randint
 
 from pydantic import BaseModel
-
 from crewai.flow.flow import Flow, listen, start
-
 from .crews.poem_crew.poem_crew import PoemCrew
 
-
 class PoemState(BaseModel):
     sentence_count: int = 1
     poem: str = ""
 
-
 class PoemFlow(Flow[PoemState]):
 
     @start()
     def generate_sentence_count(self):
         print("Generating sentence count")
+        # Generate a number between 1 and 5
         self.state.sentence_count = randint(1, 5)  
 
     @listen(generate_sentence_count)
     def generate_poem(self):
         print("Generating poem")
-        result = (
-            PoemCrew()
-            .crew()
-            .kickoff(inputs={"sentence_count": self.state.sentence_count})
-        )
+        print(f"State before poem: {self.state}")
+        result = PoemCrew().crew().kickoff(inputs={"sentence_count": self.state.sentence_count})
         
         print("Poem generated", result.raw)
         self.state.poem = result.raw
         
+        print(f"State after generate_poem: {self.state}")
+
     @listen(generate_poem)
     def save_poem(self):
         print("Saving poem")
+        print(f"State before save_poem: {self.state}")
         with open("poem.txt", "w") as f:
             f.write(self.state.poem)
+        print(f"State after save_poem: {self.state}")
 
-
-def kickoff():
+async def run_flow():
+    """
+    Run the flow.
+    """
     poem_flow = PoemFlow()
-    poem_flow.kickoff()
+    await poem_flow.kickoff()
 
-
-def plot():
+async def plot_flow():
+    """
+    Plot the flow.
+    """
     poem_flow = PoemFlow()
     poem_flow.plot()
 
 
+def main():
+    asyncio.run(run_flow())
+
+
+def plot():
+    asyncio.run(plot_flow())
+
+
+
 if __name__ == "__main__":
-    kickoff()
+    main()

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

@@ -5,12 +5,14 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<=3.13"
 dependencies = [
-    "crewai[tools]>=0.76.2,<1.0.0",
+    "crewai[tools]>=0.67.1,<1.0.0",
+    "asyncio"
 ]
 
 [project.scripts]
-kickoff = "{{folder_name}}.main:kickoff"
-plot = "{{folder_name}}.main:plot"
+{{folder_name}} = "{{folder_name}}.main:main"
+run_flow = "{{folder_name}}.main:main"
+plot_flow = "{{folder_name}}.main:plot"
 
 [build-system]
 requires = ["hatchling"]

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

@@ -1,13 +1,4 @@
-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):
@@ -15,7 +6,6 @@ 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.76.2,<1.0.0" }
+crewai = { extras = ["tools"], version = ">=0.70.1,<1.0.0" }
 asyncio = "*"
 
 [tool.poetry.scripts]

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

@@ -1,17 +1,11 @@
-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.76.2,<1.0.0"
+    "crewai[tools]>=0.67.1,<1.0.0"
 ]
 
 [project.scripts]

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

@@ -1,17 +1,11 @@
-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.76.2"
+    "crewai[tools]>=0.70.1"
 ]
 

src/crewai/cli/tools/main.py

@@ -28,6 +28,8 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
     A class to handle tool repository related operations for CrewAI projects.
     """
 
+    BASE_URL = "https://app.crewai.com/pypi/"
+
     def __init__(self):
         BaseCommand.__init__(self)
         PlusAPIMixin.__init__(self, telemetry=self._telemetry)
@@ -176,14 +178,12 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
     def _add_package(self, tool_details):
         tool_handle = tool_details["handle"]
         repository_handle = tool_details["repository"]["handle"]
-        repository_url = tool_details["repository"]["url"]
-        index = f"{repository_handle}={repository_url}"
 
         add_package_command = [
             "uv",
             "add",
-            "--index",
-            index,
+            "--extra-index-url",
+            self.BASE_URL + repository_handle,
             tool_handle,
         ]
         add_package_result = subprocess.run(

src/crewai/cli/update_crew.py

@@ -1,9 +1,7 @@
-import os
 import shutil
 
 import tomli_w
-
-from crewai.cli.utils import read_toml
+import tomllib
 
 
 def update_crew() -> None:
@@ -19,9 +17,10 @@ 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
-    pyproject_data = read_toml()
+    with open(input_file, "rb") as f:
+        pyproject = tomllib.load(f)
 
     # Initialize the new project structure
     new_pyproject = {
@@ -30,30 +29,30 @@ def migrate_pyproject(input_file, output_file):
     }
 
     # Migrate project metadata
-    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")
+    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")
         new_pyproject["project"]["authors"] = [
             {
                 "name": author.split("<")[0].strip(),
                 "email": author.split("<")[1].strip(">").strip(),
             }
-            for author in poetry_data.get("authors", [])
+            for author in poetry.get("authors", [])
         ]
-        new_pyproject["project"]["requires-python"] = poetry_data.get("python")
+        new_pyproject["project"]["requires-python"] = poetry.get("python")
     else:
         # If it's already in the new format, just copy the project section
-        new_pyproject["project"] = pyproject_data.get("project", {})
+        new_pyproject["project"] = pyproject.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 poetry_data and "dependencies" in poetry_data:
+    elif "dependencies" in poetry:
         new_pyproject["project"]["dependencies"] = []
-        for dep, version in poetry_data["dependencies"].items():
+        for dep, version in poetry["dependencies"].items():
             if isinstance(version, dict):  # Handle extras
                 extras = ",".join(version.get("extras", []))
                 new_dep = f"{dep}[{extras}]"
@@ -67,10 +66,10 @@ def migrate_pyproject(input_file, output_file):
             new_pyproject["project"]["dependencies"].append(new_dep)
 
     # Migrate or copy 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"]
+    if "scripts" in poetry:
+        new_pyproject["project"]["scripts"] = poetry["scripts"]
+    elif "scripts" in pyproject.get("project", {}):
+        new_pyproject["project"]["scripts"] = pyproject["project"]["scripts"]
     else:
         new_pyproject["project"]["scripts"] = {}
 
@@ -87,23 +86,14 @@ def migrate_pyproject(input_file, output_file):
         new_pyproject["project"]["scripts"]["run_crew"] = f"{module_name}.main:run"
 
     # Migrate optional dependencies
-    if poetry_data and "extras" in poetry_data:
-        new_pyproject["project"]["optional-dependencies"] = poetry_data["extras"]
+    if "extras" in poetry:
+        new_pyproject["project"]["optional-dependencies"] = poetry["extras"]
 
     # Backup the old pyproject.toml
     backup_file = "pyproject-old.toml"
     shutil.copy2(input_file, backup_file)
     print(f"Original pyproject.toml backed up as {backup_file}")
 
-    # Rename the poetry.lock file
-    lock_file = "poetry.lock"
-    lock_backup = "poetry-old.lock"
-    if os.path.exists(lock_file):
-        os.rename(lock_file, lock_backup)
-        print(f"Original poetry.lock renamed to {lock_backup}")
-    else:
-        print("No poetry.lock file found to rename.")
-
     # Write the new pyproject.toml
     with open(output_file, "wb") as f:
         tomli_w.dump(new_pyproject, f)

src/crewai/cli/utils.py

@@ -6,7 +6,6 @@ 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
@@ -55,13 +54,6 @@ 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

@@ -126,8 +126,8 @@ class Crew(BaseModel):
         default=None,
         description="An Instance of the EntityMemory to be used by the Crew",
     )
-    embedder: Optional[Any] = Field(
-        default=None,
+    embedder: Optional[dict] = Field(
+        default={"provider": "openai"},
         description="Configuration for the embedder to be used for the crew.",
     )
     usage_metrics: Optional[UsageMetrics] = Field(
@@ -435,16 +435,15 @@ class Crew(BaseModel):
         self, n_iterations: int, filename: str, inputs: Optional[Dict[str, Any]] = {}
     ) -> None:
         """Trains the crew for a given number of iterations."""
-        train_crew = self.copy()
-        train_crew._setup_for_training(filename)
+        self._setup_for_training(filename)
 
         for n_iteration in range(n_iterations):
-            train_crew._train_iteration = n_iteration
-            train_crew.kickoff(inputs=inputs)
+            self._train_iteration = n_iteration
+            self.kickoff(inputs=inputs)
 
         training_data = CrewTrainingHandler(TRAINING_DATA_FILE).load()
 
-        for agent in train_crew.agents:
+        for agent in self.agents:
             result = TaskEvaluator(agent).evaluate_training_data(
                 training_data=training_data, agent_id=str(agent.id)
             )
@@ -775,9 +774,7 @@ class Crew(BaseModel):
 
     def _log_task_start(self, task: Task, role: str = "None"):
         if self.output_log_file:
-            self._file_handler.log(
-                task_name=task.name, task=task.description, agent=role, status="started"
-            )
+            self._file_handler.log(task_name=task.name, task=task.description, agent=role, status="started")
 
     def _update_manager_tools(self, task: Task):
         if self.manager_agent:
@@ -799,13 +796,7 @@ class Crew(BaseModel):
     def _process_task_result(self, task: Task, output: TaskOutput) -> None:
         role = task.agent.role if task.agent is not None else "None"
         if self.output_log_file:
-            self._file_handler.log(
-                task_name=task.name,
-                task=task.description,
-                agent=role,
-                status="completed",
-                output=output.raw,
-            )
+            self._file_handler.log(task_name=task.name, task=task.description, agent=role, status="completed", output=output.raw)
 
     def _create_crew_output(self, task_outputs: List[TaskOutput]) -> CrewOutput:
         if len(task_outputs) != 1:
@@ -988,19 +979,17 @@ 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."""
-        test_crew = self.copy()
-
-        self._test_execution_span = test_crew._telemetry.test_execution_span(
-            test_crew,
+        self._test_execution_span = self._telemetry.test_execution_span(
+            self,
             n_iterations,
             inputs,
             openai_model_name,  # type: ignore[arg-type]
         )  # type: ignore[arg-type]
-        evaluator = CrewEvaluator(test_crew, openai_model_name)  # type: ignore[arg-type]
+        evaluator = CrewEvaluator(self, openai_model_name)  # type: ignore[arg-type]
 
         for i in range(1, n_iterations + 1):
             evaluator.set_iteration(i)
-            test_crew.kickoff(inputs=inputs)
+            self.kickoff(inputs=inputs)
 
         evaluator.print_crew_evaluation_result()
 

src/crewai/flow/flow.py

@@ -190,10 +190,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
         """Returns the list of all outputs from executed methods."""
         return self._method_outputs
 
-    def kickoff(self) -> Any:
-        return asyncio.run(self.kickoff_async())
-
-    async def kickoff_async(self) -> Any:
+    async def kickoff(self) -> Any:
         if not self._start_methods:
             raise ValueError("No start method defined")
 

src/crewai/memory/contextual/contextual_memory.py

@@ -31,9 +31,7 @@ class ContextualMemory:
         formatted as bullet points.
         """
         stm_results = self.stm.search(query)
-        formatted_results = "\n".join(
-            [f"- {result['context']}" for result in stm_results]
-        )
+        formatted_results = "\n".join([f"- {result}" for result in stm_results])
         return f"Recent Insights:\n{formatted_results}" if stm_results else ""
 
     def _fetch_ltm_context(self, task) -> Optional[str]:

src/crewai/memory/entity/entity_memory.py

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

src/crewai/memory/long_term/long_term_memory.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List
+from typing import Any, Dict
 
 from crewai.memory.long_term.long_term_memory_item import LongTermMemoryItem
 from crewai.memory.memory import Memory
@@ -28,7 +28,7 @@ class LongTermMemory(Memory):
             datetime=item.datetime,
         )
 
-    def search(self, task: str, latest_n: int = 3) -> List[Dict[str, Any]]:  # type: ignore # signature of "search" incompatible with supertype "Memory"
+    def search(self, task: str, latest_n: int = 3) -> Dict[str, Any]:
         return self.storage.load(task, latest_n)  # type: ignore # BUG?: "Storage" has no attribute "load"
 
     def reset(self) -> None:

src/crewai/memory/memory.py

@@ -1,6 +1,6 @@
-from typing import Any, Dict, Optional, List
+from typing import Any, Dict, Optional
 
-from crewai.memory.storage.rag_storage import RAGStorage
+from crewai.memory.storage.interface import Storage
 
 
 class Memory:
@@ -8,7 +8,7 @@ class Memory:
     Base class for memory, now supporting agent tags and generic metadata.
     """
 
-    def __init__(self, storage: RAGStorage):
+    def __init__(self, storage: Storage):
         self.storage = storage
 
     def save(
@@ -23,5 +23,5 @@ class Memory:
 
         self.storage.save(value, metadata)
 
-    def search(self, query: str) -> List[Dict[str, Any]]:
+    def search(self, query: str) -> Dict[str, Any]:
         return self.storage.search(query)

src/crewai/memory/storage/base_rag_storage.py

@@ -1,76 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional
-
-
-class BaseRAGStorage(ABC):
-    """
-    Base class for RAG-based Storage implementations.
-    """
-
-    app: Any | None = None
-
-    def __init__(
-        self,
-        type: str,
-        allow_reset: bool = True,
-        embedder_config: Optional[Any] = None,
-        crew: Any = None,
-    ):
-        self.type = type
-        self.allow_reset = allow_reset
-        self.embedder_config = embedder_config
-        self.crew = crew
-        self.agents = self._initialize_agents()
-
-    def _initialize_agents(self) -> str:
-        if self.crew:
-            return "_".join(
-                [self._sanitize_role(agent.role) for agent in self.crew.agents]
-            )
-        return ""
-
-    @abstractmethod
-    def _sanitize_role(self, role: str) -> str:
-        """Sanitizes agent roles to ensure valid directory names."""
-        pass
-
-    @abstractmethod
-    def save(self, value: Any, metadata: Dict[str, Any]) -> None:
-        """Save a value with metadata to the storage."""
-        pass
-
-    @abstractmethod
-    def search(
-        self,
-        query: str,
-        limit: int = 3,
-        filter: Optional[dict] = None,
-        score_threshold: float = 0.35,
-    ) -> List[Any]:
-        """Search for entries in the storage."""
-        pass
-
-    @abstractmethod
-    def reset(self) -> None:
-        """Reset the storage."""
-        pass
-
-    @abstractmethod
-    def _generate_embedding(
-        self, text: str, metadata: Optional[Dict[str, Any]] = None
-    ) -> Any:
-        """Generate an embedding for the given text and metadata."""
-        pass
-
-    @abstractmethod
-    def _initialize_app(self):
-        """Initialize the vector db."""
-        pass
-
-    def setup_config(self, config: Dict[str, Any]):
-        """Setup the config of the storage."""
-        pass
-
-    def initialize_client(self):
-        """Initialize the client of the storage. This should setup the app and the db collection"""
-        pass

src/crewai/memory/storage/interface.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List
+from typing import Any, Dict
 
 
 class Storage:
@@ -7,7 +7,7 @@ class Storage:
     def save(self, value: Any, metadata: Dict[str, Any]) -> None:
         pass
 
-    def search(self, key: str) -> List[Dict[str, Any]]:  # type: ignore
+    def search(self, key: str) -> Dict[str, Any]:  # type: ignore
         pass
 
     def reset(self) -> None:

src/crewai/memory/storage/rag_storage.py

@@ -3,14 +3,10 @@ import io
 import logging
 import os
 import shutil
-import uuid
 from typing import Any, Dict, List, Optional
-from crewai.memory.storage.base_rag_storage import BaseRAGStorage
+
+from crewai.memory.storage.interface import Storage
 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
@@ -28,119 +24,61 @@ def suppress_logging(
     logger.setLevel(original_level)
 
 
-class RAGStorage(BaseRAGStorage):
+class RAGStorage(Storage):
     """
     Extends Storage to handle embeddings for memory entries, improving
     search efficiency.
     """
 
-    app: ClientAPI | None = None
-
     def __init__(self, type, allow_reset=True, embedder_config=None, crew=None):
-        super().__init__(type, allow_reset, embedder_config, crew)
+        super().__init__()
+        if (
+            not os.getenv("OPENAI_API_KEY")
+            and not os.getenv("OPENAI_BASE_URL") == "https://api.openai.com/v1"
+        ):
+            os.environ["OPENAI_API_KEY"] = "fake"
+
         agents = crew.agents if crew else []
         agents = [self._sanitize_role(agent.role) for agent in agents]
         agents = "_".join(agents)
-        self.agents = agents
 
+        config = {
+            "app": {
+                "config": {"name": type, "collect_metrics": False, "log_level": "ERROR"}
+            },
+            "chunker": {
+                "chunk_size": 5000,
+                "chunk_overlap": 100,
+                "length_function": "len",
+                "min_chunk_size": 150,
+            },
+            "vectordb": {
+                "provider": "chroma",
+                "config": {
+                    "collection_name": type,
+                    "dir": f"{db_storage_path()}/{type}/{agents}",
+                    "allow_reset": allow_reset,
+                },
+            },
+        }
+
+        if embedder_config:
+            config["embedder"] = embedder_config
         self.type = type
-
+        self.config = config
         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
+        from embedchain import App
+        from embedchain.llm.base import BaseLlm
 
-        self._set_embedder_config()
-        chroma_client = chromadb.PersistentClient(
-            path=f"{db_storage_path()}/{self.type}/{self.agents}",
-            settings=Settings(allow_reset=self.allow_reset),
-        )
+        class FakeLLM(BaseLlm):
+            pass
 
-        self.app = chroma_client
-
-        try:
-            self.collection = self.app.get_collection(
-                name=self.type, embedding_function=self.embedder_config
-            )
-        except Exception:
-            self.collection = self.app.create_collection(
-                name=self.type, embedding_function=self.embedder_config
-            )
+        self.app = App.from_config(config=self.config)
+        self.app.llm = FakeLLM()
+        if self.allow_reset:
+            self.app.reset()
 
     def _sanitize_role(self, role: str) -> str:
         """
@@ -149,14 +87,11 @@ class RAGStorage(BaseRAGStorage):
         return role.replace("\n", "").replace(" ", "_").replace("/", "_")
 
     def save(self, value: Any, metadata: Dict[str, Any]) -> None:
-        if not hasattr(self, "app") or not hasattr(self, "collection"):
+        if not hasattr(self, "app"):
             self._initialize_app()
-        try:
-            self._generate_embedding(value, metadata)
-        except Exception as e:
-            logging.error(f"Error during {self.type} save: {str(e)}")
+        self._generate_embedding(value, metadata)
 
-    def search(
+    def search(  # type: ignore # BUG?: Signature of "search" incompatible with supertype "Storage"
         self,
         query: str,
         limit: int = 3,
@@ -165,54 +100,31 @@ class RAGStorage(BaseRAGStorage):
     ) -> List[Any]:
         if not hasattr(self, "app"):
             self._initialize_app()
+        from embedchain.vectordb.chroma import InvalidDimensionException
 
-        try:
-            with suppress_logging():
-                response = self.collection.query(query_texts=query, n_results=limit)
+        with suppress_logging():
+            try:
+                results = (
+                    self.app.search(query, limit, where=filter)
+                    if filter
+                    else self.app.search(query, limit)
+                )
+            except InvalidDimensionException:
+                self.app.reset()
+                return []
+        return [r for r in results if r["metadata"]["score"] >= score_threshold]
 
-            results = []
-            for i in range(len(response["ids"][0])):
-                result = {
-                    "id": response["ids"][0][i],
-                    "metadata": response["metadatas"][0][i],
-                    "context": response["documents"][0][i],
-                    "score": response["distances"][0][i],
-                }
-                if result["score"] >= score_threshold:
-                    results.append(result)
-
-            return results
-        except Exception as e:
-            logging.error(f"Error during {self.type} search: {str(e)}")
-            return []
-
-    def _generate_embedding(self, text: str, metadata: Dict[str, Any]) -> None:  # type: ignore
-        if not hasattr(self, "app") or not hasattr(self, "collection"):
+    def _generate_embedding(self, text: str, metadata: Dict[str, Any]) -> Any:
+        if not hasattr(self, "app"):
             self._initialize_app()
+        from embedchain.models.data_type import DataType
 
-        self.collection.add(
-            documents=[text],
-            metadatas=[metadata or {}],
-            ids=[str(uuid.uuid4())],
-        )
+        self.app.add(text, data_type=DataType.TEXT, metadata=metadata)
 
     def reset(self) -> None:
         try:
             shutil.rmtree(f"{db_storage_path()}/{self.type}")
-            if self.app:
-                self.app.reset()
         except Exception as 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_default_embedding_function(self):
-        import chromadb.utils.embedding_functions as embedding_functions
-
-        return embedding_functions.OpenAIEmbeddingFunction(
-            api_key=os.getenv("OPENAI_API_KEY"), model_name="text-embedding-3-small"
-        )
+            raise Exception(
+                f"An error occurred while resetting the {self.type} memory: {e}"
+            )

src/crewai/project/annotations.py

@@ -76,13 +76,27 @@ def crew(func) -> Callable[..., Crew]:
         instantiated_agents = []
         agent_roles = set()
 
-        # Use the preserved task and agent information
-        tasks = self._original_tasks.items()
-        agents = self._original_agents.items()
+        # Collect methods from crew in order
+        all_functions = [
+            (name, getattr(self, name))
+            for name, attr in self.__class__.__dict__.items()
+            if callable(attr)
+        ]
+        tasks = [
+            (name, method)
+            for name, method in all_functions
+            if hasattr(method, "is_task")
+        ]
+
+        agents = [
+            (name, method)
+            for name, method in all_functions
+            if hasattr(method, "is_agent")
+        ]
 
         # Instantiate tasks in order
         for task_name, task_method in tasks:
-            task_instance = task_method(self)
+            task_instance = task_method()
             instantiated_tasks.append(task_instance)
             agent_instance = getattr(task_instance, "agent", None)
             if agent_instance and agent_instance.role not in agent_roles:
@@ -91,7 +105,7 @@ def crew(func) -> Callable[..., Crew]:
 
         # Instantiate agents not included by tasks
         for agent_name, agent_method in agents:
-            agent_instance = agent_method(self)
+            agent_instance = agent_method()
             if agent_instance.role not in agent_roles:
                 instantiated_agents.append(agent_instance)
                 agent_roles.add(agent_instance.role)

src/crewai/project/crew_base.py

@@ -34,18 +34,6 @@ def CrewBase(cls: T) -> T:
             self.map_all_agent_variables()
             self.map_all_task_variables()
 
-            # Preserve task and agent information
-            self._original_tasks = {
-                name: method
-                for name, method in cls.__dict__.items()
-                if hasattr(method, "is_task") and method.is_task
-            }
-            self._original_agents = {
-                name: method
-                for name, method in cls.__dict__.items()
-                if hasattr(method, "is_agent") and method.is_agent
-            }
-
         @staticmethod
         def load_yaml(config_path: Path):
             try:

src/crewai/telemetry/telemetry.py

@@ -65,7 +65,7 @@ class Telemetry:
 
             self.provider.add_span_processor(processor)
             self.ready = True
-        except Exception as e:
+        except BaseException as e:
             if isinstance(
                 e,
                 (SystemExit, KeyboardInterrupt, GeneratorExit, asyncio.CancelledError),
@@ -83,33 +83,404 @@ class Telemetry:
                 self.ready = False
                 self.trace_set = False
 
-    def _safe_telemetry_operation(self, operation):
-        if not self.ready:
-            return
-        try:
-            operation()
-        except Exception:
-            pass
-
     def crew_creation(self, crew: Crew, inputs: dict[str, Any] | None):
         """Records the creation of a crew."""
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Crew Created")
+                self._add_attribute(
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
+                self._add_attribute(span, "python_version", platform.python_version())
+                self._add_attribute(span, "crew_key", crew.key)
+                self._add_attribute(span, "crew_id", str(crew.id))
+                self._add_attribute(span, "crew_process", crew.process)
+                self._add_attribute(span, "crew_memory", crew.memory)
+                self._add_attribute(span, "crew_number_of_tasks", len(crew.tasks))
+                self._add_attribute(span, "crew_number_of_agents", len(crew.agents))
+                if crew.share_crew:
+                    self._add_attribute(
+                        span,
+                        "crew_agents",
+                        json.dumps(
+                            [
+                                {
+                                    "key": agent.key,
+                                    "id": str(agent.id),
+                                    "role": agent.role,
+                                    "goal": agent.goal,
+                                    "backstory": agent.backstory,
+                                    "verbose?": agent.verbose,
+                                    "max_iter": agent.max_iter,
+                                    "max_rpm": agent.max_rpm,
+                                    "i18n": agent.i18n.prompt_file,
+                                    "function_calling_llm": (
+                                        agent.function_calling_llm.model
+                                        if agent.function_calling_llm
+                                        else ""
+                                    ),
+                                    "llm": agent.llm.model,
+                                    "delegation_enabled?": agent.allow_delegation,
+                                    "allow_code_execution?": agent.allow_code_execution,
+                                    "max_retry_limit": agent.max_retry_limit,
+                                    "tools_names": [
+                                        tool.name.casefold()
+                                        for tool in agent.tools or []
+                                    ],
+                                }
+                                for agent in crew.agents
+                            ]
+                        ),
+                    )
+                    self._add_attribute(
+                        span,
+                        "crew_tasks",
+                        json.dumps(
+                            [
+                                {
+                                    "key": task.key,
+                                    "id": str(task.id),
+                                    "description": task.description,
+                                    "expected_output": task.expected_output,
+                                    "async_execution?": task.async_execution,
+                                    "human_input?": task.human_input,
+                                    "agent_role": (
+                                        task.agent.role if task.agent else "None"
+                                    ),
+                                    "agent_key": task.agent.key if task.agent else None,
+                                    "context": (
+                                        [task.description for task in task.context]
+                                        if task.context
+                                        else None
+                                    ),
+                                    "tools_names": [
+                                        tool.name.casefold()
+                                        for tool in task.tools or []
+                                    ],
+                                }
+                                for task in crew.tasks
+                            ]
+                        ),
+                    )
+                    self._add_attribute(span, "platform", platform.platform())
+                    self._add_attribute(span, "platform_release", platform.release())
+                    self._add_attribute(span, "platform_system", platform.system())
+                    self._add_attribute(span, "platform_version", platform.version())
+                    self._add_attribute(span, "cpus", os.cpu_count())
+                    self._add_attribute(
+                        span, "crew_inputs", json.dumps(inputs) if inputs else None
+                    )
+                else:
+                    self._add_attribute(
+                        span,
+                        "crew_agents",
+                        json.dumps(
+                            [
+                                {
+                                    "key": agent.key,
+                                    "id": str(agent.id),
+                                    "role": agent.role,
+                                    "verbose?": agent.verbose,
+                                    "max_iter": agent.max_iter,
+                                    "max_rpm": agent.max_rpm,
+                                    "function_calling_llm": (
+                                        agent.function_calling_llm.model
+                                        if agent.function_calling_llm
+                                        else ""
+                                    ),
+                                    "llm": agent.llm.model,
+                                    "delegation_enabled?": agent.allow_delegation,
+                                    "allow_code_execution?": agent.allow_code_execution,
+                                    "max_retry_limit": agent.max_retry_limit,
+                                    "tools_names": [
+                                        tool.name.casefold()
+                                        for tool in agent.tools or []
+                                    ],
+                                }
+                                for agent in crew.agents
+                            ]
+                        ),
+                    )
+                    self._add_attribute(
+                        span,
+                        "crew_tasks",
+                        json.dumps(
+                            [
+                                {
+                                    "key": task.key,
+                                    "id": str(task.id),
+                                    "async_execution?": task.async_execution,
+                                    "human_input?": task.human_input,
+                                    "agent_role": (
+                                        task.agent.role if task.agent else "None"
+                                    ),
+                                    "agent_key": task.agent.key if task.agent else None,
+                                    "tools_names": [
+                                        tool.name.casefold()
+                                        for tool in task.tools or []
+                                    ],
+                                }
+                                for task in crew.tasks
+                            ]
+                        ),
+                    )
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
 
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Crew Created")
-            self._add_attribute(
-                span,
-                "crewai_version",
-                pkg_resources.get_distribution("crewai").version,
-            )
-            self._add_attribute(span, "python_version", platform.python_version())
-            self._add_attribute(span, "crew_key", crew.key)
-            self._add_attribute(span, "crew_id", str(crew.id))
-            self._add_attribute(span, "crew_process", crew.process)
-            self._add_attribute(span, "crew_memory", crew.memory)
-            self._add_attribute(span, "crew_number_of_tasks", len(crew.tasks))
-            self._add_attribute(span, "crew_number_of_agents", len(crew.agents))
-            if crew.share_crew:
+    def task_started(self, crew: Crew, task: Task) -> Span | None:
+        """Records task started in a crew."""
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+
+                created_span = tracer.start_span("Task Created")
+
+                self._add_attribute(created_span, "crew_key", crew.key)
+                self._add_attribute(created_span, "crew_id", str(crew.id))
+                self._add_attribute(created_span, "task_key", task.key)
+                self._add_attribute(created_span, "task_id", str(task.id))
+
+                if crew.share_crew:
+                    self._add_attribute(
+                        created_span, "formatted_description", task.description
+                    )
+                    self._add_attribute(
+                        created_span, "formatted_expected_output", task.expected_output
+                    )
+
+                created_span.set_status(Status(StatusCode.OK))
+                created_span.end()
+
+                span = tracer.start_span("Task Execution")
+
+                self._add_attribute(span, "crew_key", crew.key)
+                self._add_attribute(span, "crew_id", str(crew.id))
+                self._add_attribute(span, "task_key", task.key)
+                self._add_attribute(span, "task_id", str(task.id))
+
+                if crew.share_crew:
+                    self._add_attribute(span, "formatted_description", task.description)
+                    self._add_attribute(
+                        span, "formatted_expected_output", task.expected_output
+                    )
+
+                return span
+            except Exception:
+                pass
+
+        return None
+
+    def task_ended(self, span: Span, task: Task, crew: Crew):
+        """Records task execution in a crew."""
+        if self.ready:
+            try:
+                if crew.share_crew:
+                    self._add_attribute(
+                        span,
+                        "task_output",
+                        task.output.raw if task.output else "",
+                    )
+
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def tool_repeated_usage(self, llm: Any, tool_name: str, attempts: int):
+        """Records the repeated usage 'error' of a tool by an agent."""
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Tool Repeated Usage")
+                self._add_attribute(
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
+                self._add_attribute(span, "tool_name", tool_name)
+                self._add_attribute(span, "attempts", attempts)
+                if llm:
+                    self._add_attribute(span, "llm", llm.model)
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def tool_usage(self, llm: Any, tool_name: str, attempts: int):
+        """Records the usage of a tool by an agent."""
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Tool Usage")
+                self._add_attribute(
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
+                self._add_attribute(span, "tool_name", tool_name)
+                self._add_attribute(span, "attempts", attempts)
+                if llm:
+                    self._add_attribute(span, "llm", llm.model)
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def tool_usage_error(self, llm: Any):
+        """Records the usage of a tool by an agent."""
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Tool Usage Error")
+                self._add_attribute(
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
+                if llm:
+                    self._add_attribute(span, "llm", llm.model)
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def individual_test_result_span(
+        self, crew: Crew, quality: float, exec_time: int, model_name: str
+    ):
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Crew Individual Test Result")
+
+                self._add_attribute(
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
+                self._add_attribute(span, "crew_key", crew.key)
+                self._add_attribute(span, "crew_id", str(crew.id))
+                self._add_attribute(span, "quality", str(quality))
+                self._add_attribute(span, "exec_time", str(exec_time))
+                self._add_attribute(span, "model_name", model_name)
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def test_execution_span(
+        self,
+        crew: Crew,
+        iterations: int,
+        inputs: dict[str, Any] | None,
+        model_name: str,
+    ):
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Crew Test Execution")
+
+                self._add_attribute(
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
+                self._add_attribute(span, "crew_key", crew.key)
+                self._add_attribute(span, "crew_id", str(crew.id))
+                self._add_attribute(span, "iterations", str(iterations))
+                self._add_attribute(span, "model_name", model_name)
+
+                if crew.share_crew:
+                    self._add_attribute(
+                        span, "inputs", json.dumps(inputs) if inputs else None
+                    )
+
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def deploy_signup_error_span(self):
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Deploy Signup Error")
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def start_deployment_span(self, uuid: Optional[str] = None):
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Start Deployment")
+                if uuid:
+                    self._add_attribute(span, "uuid", uuid)
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def create_crew_deployment_span(self):
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Create Crew Deployment")
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def get_crew_logs_span(self, uuid: Optional[str], log_type: str = "deployment"):
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Get Crew Logs")
+                self._add_attribute(span, "log_type", log_type)
+                if uuid:
+                    self._add_attribute(span, "uuid", uuid)
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def remove_crew_span(self, uuid: Optional[str] = None):
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Remove Crew")
+                if uuid:
+                    self._add_attribute(span, "uuid", uuid)
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
+
+    def crew_execution_span(self, crew: Crew, inputs: dict[str, Any] | None):
+        """Records the complete execution of a crew.
+        This is only collected if the user has opted-in to share the crew.
+        """
+        self.crew_creation(crew, inputs)
+
+        if (self.ready) and (crew.share_crew):
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Crew Execution")
+                self._add_attribute(
+                    span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
+                )
+                self._add_attribute(span, "crew_key", crew.key)
+                self._add_attribute(span, "crew_id", str(crew.id))
+                self._add_attribute(
+                    span, "crew_inputs", json.dumps(inputs) if inputs else None
+                )
                 self._add_attribute(
                     span,
                     "crew_agents",
@@ -125,15 +496,8 @@ class Telemetry:
                                 "max_iter": agent.max_iter,
                                 "max_rpm": agent.max_rpm,
                                 "i18n": agent.i18n.prompt_file,
-                                "function_calling_llm": (
-                                    agent.function_calling_llm.model
-                                    if agent.function_calling_llm
-                                    else ""
-                                ),
                                 "llm": agent.llm.model,
                                 "delegation_enabled?": agent.allow_delegation,
-                                "allow_code_execution?": agent.allow_code_execution,
-                                "max_retry_limit": agent.max_retry_limit,
                                 "tools_names": [
                                     tool.name.casefold() for tool in agent.tools or []
                                 ],
@@ -148,15 +512,12 @@ class Telemetry:
                     json.dumps(
                         [
                             {
-                                "key": task.key,
                                 "id": str(task.id),
                                 "description": task.description,
                                 "expected_output": task.expected_output,
                                 "async_execution?": task.async_execution,
                                 "human_input?": task.human_input,
-                                "agent_role": (
-                                    task.agent.role if task.agent else "None"
-                                ),
+                                "agent_role": task.agent.role if task.agent else "None",
                                 "agent_key": task.agent.key if task.agent else None,
                                 "context": (
                                     [task.description for task in task.context]
@@ -171,433 +532,78 @@ class Telemetry:
                         ]
                     ),
                 )
-                self._add_attribute(span, "platform", platform.platform())
-                self._add_attribute(span, "platform_release", platform.release())
-                self._add_attribute(span, "platform_system", platform.system())
-                self._add_attribute(span, "platform_version", platform.version())
-                self._add_attribute(span, "cpus", os.cpu_count())
+                return span
+            except Exception:
+                pass
+
+    def end_crew(self, crew, final_string_output):
+        if (self.ready) and (crew.share_crew):
+            try:
                 self._add_attribute(
-                    span, "crew_inputs", json.dumps(inputs) if inputs else None
+                    crew._execution_span,
+                    "crewai_version",
+                    pkg_resources.get_distribution("crewai").version,
                 )
-            else:
                 self._add_attribute(
-                    span,
-                    "crew_agents",
+                    crew._execution_span, "crew_output", final_string_output
+                )
+                self._add_attribute(
+                    crew._execution_span,
+                    "crew_tasks_output",
                     json.dumps(
                         [
                             {
-                                "key": agent.key,
-                                "id": str(agent.id),
-                                "role": agent.role,
-                                "verbose?": agent.verbose,
-                                "max_iter": agent.max_iter,
-                                "max_rpm": agent.max_rpm,
-                                "function_calling_llm": (
-                                    agent.function_calling_llm.model
-                                    if agent.function_calling_llm
-                                    else ""
-                                ),
-                                "llm": agent.llm.model,
-                                "delegation_enabled?": agent.allow_delegation,
-                                "allow_code_execution?": agent.allow_code_execution,
-                                "max_retry_limit": agent.max_retry_limit,
-                                "tools_names": [
-                                    tool.name.casefold() for tool in agent.tools or []
-                                ],
-                            }
-                            for agent in crew.agents
-                        ]
-                    ),
-                )
-                self._add_attribute(
-                    span,
-                    "crew_tasks",
-                    json.dumps(
-                        [
-                            {
-                                "key": task.key,
                                 "id": str(task.id),
-                                "async_execution?": task.async_execution,
-                                "human_input?": task.human_input,
-                                "agent_role": (
-                                    task.agent.role if task.agent else "None"
-                                ),
-                                "agent_key": task.agent.key if task.agent else None,
-                                "tools_names": [
-                                    tool.name.casefold() for tool in task.tools or []
-                                ],
+                                "description": task.description,
+                                "output": task.output.raw_output,
                             }
                             for task in crew.tasks
                         ]
                     ),
                 )
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def task_started(self, crew: Crew, task: Task) -> Span | None:
-        """Records task started in a crew."""
-
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-
-            created_span = tracer.start_span("Task Created")
-
-            self._add_attribute(created_span, "crew_key", crew.key)
-            self._add_attribute(created_span, "crew_id", str(crew.id))
-            self._add_attribute(created_span, "task_key", task.key)
-            self._add_attribute(created_span, "task_id", str(task.id))
-
-            if crew.share_crew:
-                self._add_attribute(
-                    created_span, "formatted_description", task.description
-                )
-                self._add_attribute(
-                    created_span, "formatted_expected_output", task.expected_output
-                )
-
-            created_span.set_status(Status(StatusCode.OK))
-            created_span.end()
-
-            span = tracer.start_span("Task Execution")
-
-            self._add_attribute(span, "crew_key", crew.key)
-            self._add_attribute(span, "crew_id", str(crew.id))
-            self._add_attribute(span, "task_key", task.key)
-            self._add_attribute(span, "task_id", str(task.id))
-
-            if crew.share_crew:
-                self._add_attribute(span, "formatted_description", task.description)
-                self._add_attribute(
-                    span, "formatted_expected_output", task.expected_output
-                )
-
-            return span
-
-        return self._safe_telemetry_operation(operation)
-
-    def task_ended(self, span: Span, task: Task, crew: Crew):
-        """Records task execution in a crew."""
-
-        def operation():
-            if crew.share_crew:
-                self._add_attribute(
-                    span,
-                    "task_output",
-                    task.output.raw if task.output else "",
-                )
-
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def tool_repeated_usage(self, llm: Any, tool_name: str, attempts: int):
-        """Records the repeated usage 'error' of a tool by an agent."""
-
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Tool Repeated Usage")
-            self._add_attribute(
-                span,
-                "crewai_version",
-                pkg_resources.get_distribution("crewai").version,
-            )
-            self._add_attribute(span, "tool_name", tool_name)
-            self._add_attribute(span, "attempts", attempts)
-            if llm:
-                self._add_attribute(span, "llm", llm.model)
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def tool_usage(self, llm: Any, tool_name: str, attempts: int):
-        """Records the usage of a tool by an agent."""
-
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Tool Usage")
-            self._add_attribute(
-                span,
-                "crewai_version",
-                pkg_resources.get_distribution("crewai").version,
-            )
-            self._add_attribute(span, "tool_name", tool_name)
-            self._add_attribute(span, "attempts", attempts)
-            if llm:
-                self._add_attribute(span, "llm", llm.model)
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def tool_usage_error(self, llm: Any):
-        """Records the usage of a tool by an agent."""
-
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Tool Usage Error")
-            self._add_attribute(
-                span,
-                "crewai_version",
-                pkg_resources.get_distribution("crewai").version,
-            )
-            if llm:
-                self._add_attribute(span, "llm", llm.model)
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def individual_test_result_span(
-        self, crew: Crew, quality: float, exec_time: int, model_name: str
-    ):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Crew Individual Test Result")
-
-            self._add_attribute(
-                span,
-                "crewai_version",
-                pkg_resources.get_distribution("crewai").version,
-            )
-            self._add_attribute(span, "crew_key", crew.key)
-            self._add_attribute(span, "crew_id", str(crew.id))
-            self._add_attribute(span, "quality", str(quality))
-            self._add_attribute(span, "exec_time", str(exec_time))
-            self._add_attribute(span, "model_name", model_name)
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def test_execution_span(
-        self,
-        crew: Crew,
-        iterations: int,
-        inputs: dict[str, Any] | None,
-        model_name: str,
-    ):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Crew Test Execution")
-
-            self._add_attribute(
-                span,
-                "crewai_version",
-                pkg_resources.get_distribution("crewai").version,
-            )
-            self._add_attribute(span, "crew_key", crew.key)
-            self._add_attribute(span, "crew_id", str(crew.id))
-            self._add_attribute(span, "iterations", str(iterations))
-            self._add_attribute(span, "model_name", model_name)
-
-            if crew.share_crew:
-                self._add_attribute(
-                    span, "inputs", json.dumps(inputs) if inputs else None
-                )
-
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def deploy_signup_error_span(self):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Deploy Signup Error")
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def start_deployment_span(self, uuid: Optional[str] = None):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Start Deployment")
-            if uuid:
-                self._add_attribute(span, "uuid", uuid)
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def create_crew_deployment_span(self):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Create Crew Deployment")
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def get_crew_logs_span(self, uuid: Optional[str], log_type: str = "deployment"):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Get Crew Logs")
-            self._add_attribute(span, "log_type", log_type)
-            if uuid:
-                self._add_attribute(span, "uuid", uuid)
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def remove_crew_span(self, uuid: Optional[str] = None):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Remove Crew")
-            if uuid:
-                self._add_attribute(span, "uuid", uuid)
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
-
-    def crew_execution_span(self, crew: Crew, inputs: dict[str, Any] | None):
-        """Records the complete execution of a crew.
-        This is only collected if the user has opted-in to share the crew.
-        """
-        self.crew_creation(crew, inputs)
-
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Crew Execution")
-            self._add_attribute(
-                span,
-                "crewai_version",
-                pkg_resources.get_distribution("crewai").version,
-            )
-            self._add_attribute(span, "crew_key", crew.key)
-            self._add_attribute(span, "crew_id", str(crew.id))
-            self._add_attribute(
-                span, "crew_inputs", json.dumps(inputs) if inputs else None
-            )
-            self._add_attribute(
-                span,
-                "crew_agents",
-                json.dumps(
-                    [
-                        {
-                            "key": agent.key,
-                            "id": str(agent.id),
-                            "role": agent.role,
-                            "goal": agent.goal,
-                            "backstory": agent.backstory,
-                            "verbose?": agent.verbose,
-                            "max_iter": agent.max_iter,
-                            "max_rpm": agent.max_rpm,
-                            "i18n": agent.i18n.prompt_file,
-                            "llm": agent.llm.model,
-                            "delegation_enabled?": agent.allow_delegation,
-                            "tools_names": [
-                                tool.name.casefold() for tool in agent.tools or []
-                            ],
-                        }
-                        for agent in crew.agents
-                    ]
-                ),
-            )
-            self._add_attribute(
-                span,
-                "crew_tasks",
-                json.dumps(
-                    [
-                        {
-                            "id": str(task.id),
-                            "description": task.description,
-                            "expected_output": task.expected_output,
-                            "async_execution?": task.async_execution,
-                            "human_input?": task.human_input,
-                            "agent_role": task.agent.role if task.agent else "None",
-                            "agent_key": task.agent.key if task.agent else None,
-                            "context": (
-                                [task.description for task in task.context]
-                                if task.context
-                                else None
-                            ),
-                            "tools_names": [
-                                tool.name.casefold() for tool in task.tools or []
-                            ],
-                        }
-                        for task in crew.tasks
-                    ]
-                ),
-            )
-            return span
-
-        if crew.share_crew:
-            return self._safe_telemetry_operation(operation)
-        return None
-
-    def end_crew(self, crew, final_string_output):
-        def operation():
-            self._add_attribute(
-                crew._execution_span,
-                "crewai_version",
-                pkg_resources.get_distribution("crewai").version,
-            )
-            self._add_attribute(
-                crew._execution_span, "crew_output", final_string_output
-            )
-            self._add_attribute(
-                crew._execution_span,
-                "crew_tasks_output",
-                json.dumps(
-                    [
-                        {
-                            "id": str(task.id),
-                            "description": task.description,
-                            "output": task.output.raw_output,
-                        }
-                        for task in crew.tasks
-                    ]
-                ),
-            )
-            crew._execution_span.set_status(Status(StatusCode.OK))
-            crew._execution_span.end()
-
-        if crew.share_crew:
-            self._safe_telemetry_operation(operation)
+                crew._execution_span.set_status(Status(StatusCode.OK))
+                crew._execution_span.end()
+            except Exception:
+                pass
 
     def _add_attribute(self, span, key, value):
         """Add an attribute to a span."""
-
-        def operation():
+        try:
             return span.set_attribute(key, value)
-
-        self._safe_telemetry_operation(operation)
+        except Exception:
+            pass
 
     def flow_creation_span(self, flow_name: str):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Flow Creation")
-            self._add_attribute(span, "flow_name", flow_name)
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Flow Creation")
+                self._add_attribute(span, "flow_name", flow_name)
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
 
     def flow_plotting_span(self, flow_name: str, node_names: list[str]):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Flow Plotting")
-            self._add_attribute(span, "flow_name", flow_name)
-            self._add_attribute(span, "node_names", json.dumps(node_names))
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Flow Plotting")
+                self._add_attribute(span, "flow_name", flow_name)
+                self._add_attribute(span, "node_names", json.dumps(node_names))
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass
 
     def flow_execution_span(self, flow_name: str, node_names: list[str]):
-        def operation():
-            tracer = trace.get_tracer("crewai.telemetry")
-            span = tracer.start_span("Flow Execution")
-            self._add_attribute(span, "flow_name", flow_name)
-            self._add_attribute(span, "node_names", json.dumps(node_names))
-            span.set_status(Status(StatusCode.OK))
-            span.end()
-
-        self._safe_telemetry_operation(operation)
+        if self.ready:
+            try:
+                tracer = trace.get_tracer("crewai.telemetry")
+                span = tracer.start_span("Flow Execution")
+                self._add_attribute(span, "flow_name", flow_name)
+                self._add_attribute(span, "node_names", json.dumps(node_names))
+                span.set_status(Status(StatusCode.OK))
+                span.end()
+            except Exception:
+                pass

src/crewai/tools/tool_usage.py

@@ -6,13 +6,14 @@ from difflib import SequenceMatcher
 from textwrap import dedent
 from typing import Any, List, Union
 
-import crewai.utilities.events as events
 from crewai.agents.tools_handler import ToolsHandler
 from crewai.task import Task
 from crewai.telemetry import Telemetry
 from crewai.tools.tool_calling import InstructorToolCalling, ToolCalling
 from crewai.tools.tool_usage_events import ToolUsageError, ToolUsageFinished
 from crewai.utilities import I18N, Converter, ConverterError, Printer
+import crewai.utilities.events as events
+
 
 agentops = None
 if os.environ.get("AGENTOPS_API_KEY"):
@@ -299,11 +300,8 @@ class ToolUsage:
         descriptions = []
         for tool in self.tools:
             args = {
-                name: {
-                    "description": field.description,
-                    "type": field.annotation.__name__,
-                }
-                for name, field in tool.args_schema.model_fields.items()
+                k: {k2: v2 for k2, v2 in v.items() if k2 in ["description", "type"]}
+                for k, v in tool.args.items()
             }
             descriptions.append(
                 "\n".join(

tests/cli/tools/test_main.py

@@ -75,8 +75,8 @@ def test_install_success(mock_get, mock_subprocess_run):
         [
             "uv",
             "add",
-            "--index",
-            "sample-repo=https://example.com/repo",
+            "--extra-index-url",
+            "https://app.crewai.com/pypi/sample-repo",
             "sample-tool",
         ],
         capture_output=False,

tests/crew_test.py

@@ -9,7 +9,6 @@ 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
@@ -498,7 +497,6 @@ 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
@@ -781,14 +779,11 @@ 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
@@ -1110,7 +1105,6 @@ 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"
@@ -1454,6 +1448,52 @@ 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
 
@@ -1730,10 +1770,7 @@ def test_manager_agent_with_tools_raises_exception():
 @patch("crewai.crew.Crew.kickoff")
 @patch("crewai.crew.CrewTrainingHandler")
 @patch("crewai.crew.TaskEvaluator")
-@patch("crewai.crew.Crew.copy")
-def test_crew_train_success(
-    copy_mock, task_evaluator, crew_training_handler, kickoff_mock
-):
+def test_crew_train_success(task_evaluator, crew_training_handler, kickoff):
     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.",
@@ -1744,19 +1781,9 @@ def test_crew_train_success(
         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),
@@ -1795,6 +1822,10 @@ def test_crew_train_success(
         ]
     )
 
+    kickoff.assert_has_calls(
+        [mock.call(inputs={"topic": "AI"}), mock.call(inputs={"topic": "AI"})]
+    )
+
 
 def test_crew_train_error():
     task = Task(
@@ -1809,7 +1840,7 @@ def test_crew_train_error():
     )
 
     with pytest.raises(TypeError) as e:
-        crew.train()  # type: ignore purposefully throwing err
+        crew.train()
         assert "train() missing 1 required positional argument: 'n_iterations'" in str(
             e
         )
@@ -2505,9 +2536,8 @@ 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(kickoff_mock, copy_mock, crew_evaluator):
+def test_crew_testing_function(mock_kickoff, 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.",
@@ -2518,15 +2548,11 @@ def test_crew_testing_function(kickoff_mock, copy_mock, 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"})
 
-    # Ensure kickoff is called on the copied crew
-    kickoff_mock.assert_has_calls(
+    assert len(mock_kickoff.mock_calls) == n_iterations
+    mock_kickoff.assert_has_calls(
         [mock.call(inputs={"topic": "AI"}), mock.call(inputs={"topic": "AI"})]
     )
 

tests/memory/short_term_memory_test.py

@@ -1,5 +1,5 @@
 import pytest
-from unittest.mock import patch
+
 from crewai.agent import Agent
 from crewai.crew import Crew
 from crewai.memory.short_term.short_term_memory import ShortTermMemory
@@ -26,6 +26,7 @@ def short_term_memory():
     return ShortTermMemory(crew=Crew(agents=[agent], tasks=[task]))
 
 
+@pytest.mark.vcr(filter_headers=["authorization"])
 def test_save_and_search(short_term_memory):
     memory = ShortTermMemoryItem(
         data="""test value test value test value test value test value test value
@@ -34,28 +35,12 @@ def test_save_and_search(short_term_memory):
         agent="test_agent",
         metadata={"task": "test_task"},
     )
+    short_term_memory.save(
+        value=memory.data,
+        metadata=memory.metadata,
+        agent=memory.agent,
+    )
 
-    with patch.object(ShortTermMemory, "save") as mock_save:
-        short_term_memory.save(
-            value=memory.data,
-            metadata=memory.metadata,
-            agent=memory.agent,
-        )
-
-        mock_save.assert_called_once_with(
-            value=memory.data,
-            metadata=memory.metadata,
-            agent=memory.agent,
-        )
-
-    expected_result = [
-        {
-            "context": memory.data,
-            "metadata": {"agent": "test_agent"},
-            "score": 0.95,
-        }
-    ]
-    with patch.object(ShortTermMemory, "search", return_value=expected_result):
-        find = short_term_memory.search("test value", score_threshold=0.01)[0]
-        assert find["context"] == memory.data, "Data value mismatch."
-        assert find["metadata"]["agent"] == "test_agent", "Agent value mismatch."
+    find = short_term_memory.search("test value", score_threshold=0.01)[0]
+    assert find["context"] == memory.data, "Data value mismatch."
+    assert find["metadata"]["agent"] == "test_agent", "Agent value mismatch."

tests/tools/test_tool_usage.py

@@ -1,119 +0,0 @@
-import json
-import random
-from unittest.mock import MagicMock
-
-import pytest
-from crewai_tools import BaseTool
-from pydantic import BaseModel, Field
-
-from crewai import Agent, Task
-from crewai.tools.tool_usage import ToolUsage
-
-
-class RandomNumberToolInput(BaseModel):
-    min_value: int = Field(
-        ..., description="The minimum value of the range (inclusive)"
-    )
-    max_value: int = Field(
-        ..., description="The maximum value of the range (inclusive)"
-    )
-
-
-class RandomNumberTool(BaseTool):
-    name: str = "Random Number Generator"
-    description: str = "Generates a random number within a specified range"
-    args_schema: type[BaseModel] = RandomNumberToolInput
-
-    def _run(self, min_value: int, max_value: int) -> int:
-        return random.randint(min_value, max_value)
-
-
-# Example agent and task
-example_agent = Agent(
-    role="Number Generator",
-    goal="Generate random numbers for various purposes",
-    backstory="You are an AI agent specialized in generating random numbers within specified ranges.",
-    tools=[RandomNumberTool()],
-    verbose=True,
-)
-
-example_task = Task(
-    description="Generate a random number between 1 and 100",
-    expected_output="A random number between 1 and 100",
-    agent=example_agent,
-)
-
-
-def test_random_number_tool_range():
-    tool = RandomNumberTool()
-    result = tool._run(1, 10)
-    assert 1 <= result <= 10
-
-
-def test_random_number_tool_invalid_range():
-    tool = RandomNumberTool()
-    with pytest.raises(ValueError):
-        tool._run(10, 1)  # min_value > max_value
-
-
-def test_random_number_tool_schema():
-    tool = RandomNumberTool()
-
-    # Get the schema using model_json_schema()
-    schema = tool.args_schema.model_json_schema()
-
-    # Convert the schema to a string
-    schema_str = json.dumps(schema)
-
-    # Check if the schema string contains the expected fields
-    assert "min_value" in schema_str
-    assert "max_value" in schema_str
-
-    # Parse the schema string back to a dictionary
-    schema_dict = json.loads(schema_str)
-
-    # Check if the schema contains the correct field types
-    assert schema_dict["properties"]["min_value"]["type"] == "integer"
-    assert schema_dict["properties"]["max_value"]["type"] == "integer"
-
-    # Check if the schema contains the field descriptions
-    assert (
-        "minimum value" in schema_dict["properties"]["min_value"]["description"].lower()
-    )
-    assert (
-        "maximum value" in schema_dict["properties"]["max_value"]["description"].lower()
-    )
-
-
-def test_tool_usage_render():
-    tool = RandomNumberTool()
-
-    tool_usage = ToolUsage(
-        tools_handler=MagicMock(),
-        tools=[tool],
-        original_tools=[tool],
-        tools_description="Sample tool for testing",
-        tools_names="random_number_generator",
-        task=MagicMock(),
-        function_calling_llm=MagicMock(),
-        agent=MagicMock(),
-        action=MagicMock(),
-    )
-
-    rendered = tool_usage._render()
-
-    # Updated checks to match the actual output
-    assert "Tool Name: random number generator" in rendered
-    assert (
-        "Random Number Generator(min_value: 'integer', max_value: 'integer') - Generates a random number within a specified range min_value: 'The minimum value of the range (inclusive)', max_value: 'The maximum value of the range (inclusive)'"
-        in rendered
-    )
-    assert "Tool Arguments:" in rendered
-    assert (
-        "'min_value': {'description': 'The minimum value of the range (inclusive)', 'type': 'int'}"
-        in rendered
-    )
-    assert (
-        "'max_value': {'description': 'The maximum value of the range (inclusive)', 'type': 'int'}"
-        in rendered
-    )