linted

rm unused
fix test
2026-02-20 04:48:18 +00:00 · 2024-11-27 11:30:56 -08:00 · 2024-11-27 11:30:21 -08:00 · 2024-11-27 11:27:27 -08:00 · 2024-11-27 10:50:48 -08:00 · 2024-11-27 10:47:03 -08:00
43 changed files with 953 additions and 2020 deletions
--- a/README.md
+++ b/README.md
@@ -376,7 +376,7 @@ pip install dist/*.tar.gz

 CrewAI uses anonymous telemetry to collect usage data with the main purpose of helping us improve the library by focusing our efforts on the most used features, integrations and tools.

-It's pivotal to understand that **NO data is collected** concerning prompts, task descriptions, agents' backstories or goals, usage of tools, API calls, responses, any data processed by the agents, or secrets and environment variables, with the exception of the conditions mentioned. When the `share_crew` feature is enabled, detailed data including task descriptions, agents' backstories or goals, and other specific attributes are collected to provide deeper insights while respecting user privacy. Users can disable telemetry by setting the environment variable OTEL_SDK_DISABLED to true.
+It's pivotal to understand that **NO data is collected** concerning prompts, task descriptions, agents' backstories or goals, usage of tools, API calls, responses, any data processed by the agents, or secrets and environment variables, with the exception of the conditions mentioned. When the `share_crew` feature is enabled, detailed data including task descriptions, agents' backstories or goals, and other specific attributes are collected to provide deeper insights while respecting user privacy. We don't offer a way to disable it now, but we will in the future.

 Data collected includes:

--- a/docs/concepts/agents.mdx
+++ b/docs/concepts/agents.mdx
@@ -1,343 +1,161 @@
 ---
 title: Agents
-description: Detailed guide on creating and managing agents within the CrewAI framework.
+description: What are CrewAI Agents and how to use them.
 icon: robot
 ---

-## Overview of an Agent
+## What is an agent?

-In the CrewAI framework, an `Agent` is an autonomous unit that can:
- Perform specific tasks
- Make decisions based on its role and goal
- Use tools to accomplish objectives
- Communicate and collaborate with other agents
- Maintain memory of interactions
- Delegate tasks when allowed
+An agent is an **autonomous unit** programmed to:
+<ul>
+    <li class='leading-3'>Perform tasks</li>
+    <li class='leading-3'>Make decisions</li>
+    <li class='leading-3'>Communicate with other agents</li>
+</ul>

 <Tip>
-Think of an agent as a specialized team member with specific skills, expertise, and responsibilities. For example, a `Researcher` agent might excel at gathering and analyzing information, while a `Writer` agent might be better at creating content.
+Think of an agent as a member of a team, with specific skills and a particular job to do. Agents can have different roles like `Researcher`, `Writer`, or `Customer Support`, each contributing to the overall goal of the crew.
 </Tip>

-## Agent Attributes
+## Agent attributes

-| Attribute                               | Parameter                | Type                          | Description                                                                                                          |
-| :-------------------------------------- | :----------------------- | :---------------------------- | :------------------------------------------------------------------------------------------------------------------- |
-| **Role**                                | `role`                   | `str`                         | Defines the agent's function and expertise within the crew.                                                           |
-| **Goal**                                | `goal`                   | `str`                         | The individual objective that guides the agent's decision-making.                                                     |
-| **Backstory**                           | `backstory`              | `str`                         | Provides context and personality to the agent, enriching interactions.                                                |
-| **LLM** _(optional)_                    | `llm`                    | `Union[str, LLM, Any]`        | Language model that powers the agent. Defaults to the model specified in `OPENAI_MODEL_NAME` or "gpt-4".              |
-| **Tools** _(optional)_                  | `tools`                  | `List[BaseTool]`              | Capabilities or functions available to the agent. Defaults to an empty list.                                          |
-| **Function Calling LLM** _(optional)_   | `function_calling_llm`   | `Optional[Any]`               | Language model for tool calling, overrides crew's LLM if specified.                                                   |
-| **Max Iterations** _(optional)_         | `max_iter`               | `int`                         | Maximum iterations before the agent must provide its best answer. Default is 20.                                      |
-| **Max RPM** _(optional)_                | `max_rpm`                | `Optional[int]`               | Maximum requests per minute to avoid rate limits.                                                                     |
-| **Max Execution Time** _(optional)_     | `max_execution_time`     | `Optional[int]`               | Maximum time (in seconds) for task execution.                                                                         |
-| **Memory** _(optional)_                 | `memory`                 | `bool`                        | Whether the agent should maintain memory of interactions. Default is True.                                            |
-| **Verbose** _(optional)_                | `verbose`                | `bool`                        | Enable detailed execution logs for debugging. Default is False.                                                       |
-| **Allow Delegation** _(optional)_       | `allow_delegation`       | `bool`                        | Allow the agent to delegate tasks to other agents. Default is False.                                                  |
-| **Step Callback** _(optional)_          | `step_callback`          | `Optional[Any]`               | Function called after each agent step, overrides crew callback.                                                       |
-| **Cache** _(optional)_                  | `cache`                  | `bool`                        | Enable caching for tool usage. Default is True.                                                                       |
-| **System Template** _(optional)_        | `system_template`        | `Optional[str]`               | Custom system prompt template for the agent.                                                                          |
-| **Prompt Template** _(optional)_        | `prompt_template`        | `Optional[str]`               | Custom prompt template for the agent.                                                                                 |
-| **Response Template** _(optional)_      | `response_template`      | `Optional[str]`               | Custom response template for the agent.                                                                               |
-| **Allow Code Execution** _(optional)_   | `allow_code_execution`   | `Optional[bool]`              | Enable code execution for the agent. Default is False.                                                                |
-| **Max Retry Limit** _(optional)_        | `max_retry_limit`        | `int`                         | Maximum number of retries when an error occurs. Default is 2.                                                         |
-| **Respect Context Window** _(optional)_ | `respect_context_window` | `bool`                        | Keep messages under context window size by summarizing. Default is True.                                              |
-| **Code Execution Mode** _(optional)_    | `code_execution_mode`    | `Literal["safe", "unsafe"]`   | Mode for code execution: 'safe' (using Docker) or 'unsafe' (direct). Default is 'safe'.                               |
-| **Embedder Config** _(optional)_        | `embedder_config`        | `Optional[Dict[str, Any]]`    | Configuration for the embedder used by the agent.                                                                     |
-| **Knowledge Sources** _(optional)_      | `knowledge_sources`      | `Optional[List[BaseKnowledgeSource]]` | Knowledge sources available to the agent.                                                                     |
-| **Use System Prompt** _(optional)_      | `use_system_prompt`      | `Optional[bool]`              | Whether to use system prompt (for o1 model support). Default is True.                                                 |
+| Attribute                  | Parameter  | Description                                                                                                                                                                                                                                    |
+| :------------------------- | :--------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Role**                   | `role`     | Defines the agent's function within the crew. It determines the kind of tasks the agent is best suited for.                                                                                                                                    |
+| **Goal**                   | `goal`     | The individual objective that the agent aims to achieve. It guides the agent's decision-making process.                                                                                                                                        |
+| **Backstory**              | `backstory`| Provides context to the agent's role and goal, enriching the interaction and collaboration dynamics.                                                                                                                                           |
+| **LLM** *(optional)*       | `llm`      | Represents the language model that will run the agent. It dynamically fetches the model name from the `OPENAI_MODEL_NAME` environment variable, defaulting to "gpt-4" if not specified.                                                         |
+| **Tools** *(optional)*     | `tools`    | Set of capabilities or functions that the agent can use to perform tasks. Expected to be instances of custom classes compatible with the agent's execution environment. Tools are initialized with a default value of an empty list.             |
+| **Function Calling LLM** *(optional)* | `function_calling_llm`  | Specifies the language model that will handle the tool calling for this agent, overriding the crew function calling LLM if passed. Default is `None`.                                                                                          |
+| **Max Iter** *(optional)*  | `max_iter` | Max Iter is the maximum number of iterations the agent can perform before being forced to give its best answer. Default is `25`.                                                                                                                           |
+| **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`.                                                                                                      |
+| **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`.                                                                                                                                                                  |
+| **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 Agents
-
-There are two ways to create agents in CrewAI: using **YAML configuration (recommended)** or defining them **directly in code**.
-
-### YAML Configuration (Recommended)
-
-Using YAML configuration provides a cleaner, more maintainable way to define agents. We strongly recommend using this approach in your CrewAI projects.
-
-After creating your CrewAI project as outlined in the [Installation](/installation) section, navigate to the `src/latest_ai_development/config/agents.yaml` file and modify the template to match your requirements.
+## Creating an agent

 <Note>
-Variables in your YAML files (like `{topic}`) will be replaced with values from your inputs when running the crew:
-```python Code
-crew.kickoff(inputs={'topic': 'AI Agents'})
-```
+  **Agent interaction**: Agents can interact with each other using CrewAI's built-in delegation and communication mechanisms. This allows for dynamic task management and problem-solving within the crew.
 </Note>

-Here's an example of how to configure agents using YAML:
+To create an agent, you would typically initialize an instance of the `Agent` class with the desired properties. Here's a conceptual example including all attributes:

-```yaml agents.yaml
-# src/latest_ai_development/config/agents.yaml
-researcher:
-  role: >
-    {topic} Senior Data Researcher
-  goal: >
-    Uncover cutting-edge developments in {topic}
-  backstory: >
-    You're a seasoned researcher with a knack for uncovering the latest
-    developments in {topic}. Known for your ability to find the most relevant
-    information and present it in a clear and concise manner.
-
-reporting_analyst:
-  role: >
-    {topic} Reporting Analyst
-  goal: >
-    Create detailed reports based on {topic} data analysis and research findings
-  backstory: >
-    You're a meticulous analyst with a keen eye for detail. You're known for
-    your ability to turn complex data into clear and concise reports, making
-    it easy for others to understand and act on the information you provide.
-```
-
-To use this YAML configuration in your code, create a crew class that inherits from `CrewBase`:
-
-```python Code
-# src/latest_ai_development/crew.py
-from crewai import Agent, Crew, Process
-from crewai.project import CrewBase, agent, crew
-from crewai_tools import SerperDevTool
-
-@CrewBase
-class LatestAiDevelopmentCrew():
-  """LatestAiDevelopment crew"""
-
-  @agent
-  def researcher(self) -> Agent:
-    return Agent(
-      config=self.agents_config['researcher'],
-      verbose=True,
-      tools=[SerperDevTool()]
-    )
-
-  @agent
-  def reporting_analyst(self) -> Agent:
-    return Agent(
-      config=self.agents_config['reporting_analyst'],
-      verbose=True
-    )
-```
-
-<Note>
-The names you use in your YAML files (`agents.yaml`) should match the method names in your Python code.
-</Note>
-
-### Direct Code Definition
-
-You can create agents directly in code by instantiating the `Agent` class. Here's a comprehensive example showing all available parameters:
-
-```python Code
+```python Code example
 from crewai import Agent
-from crewai_tools import SerperDevTool

-# Create an agent with all available parameters
 agent = Agent(
-    role="Senior Data Scientist",
-    goal="Analyze and interpret complex datasets to provide actionable insights",
-    backstory="With over 10 years of experience in data science and machine learning, "
-              "you excel at finding patterns in complex datasets.",
-    llm="gpt-4",  # Default: OPENAI_MODEL_NAME or "gpt-4"
-    function_calling_llm=None,  # Optional: Separate LLM for tool calling
-    memory=True,  # Default: True
-    verbose=False,  # Default: False
-    allow_delegation=False,  # Default: False
-    max_iter=20,  # Default: 20 iterations
-    max_rpm=None,  # Optional: Rate limit for API calls
-    max_execution_time=None,  # Optional: Maximum execution time in seconds
-    max_retry_limit=2,  # Default: 2 retries on error
-    allow_code_execution=False,  # Default: False
-    code_execution_mode="safe",  # Default: "safe" (options: "safe", "unsafe")
-    respect_context_window=True,  # Default: True
-    use_system_prompt=True,  # Default: True
-    tools=[SerperDevTool()],  # Optional: List of tools
-    knowledge_sources=None,  # Optional: List of knowledge sources
-    embedder_config=None,  # Optional: Custom embedder configuration
-    system_template=None,  # Optional: Custom system prompt template
-    prompt_template=None,  # Optional: Custom prompt template
-    response_template=None,  # Optional: Custom response template
-    step_callback=None,  # Optional: Callback function for monitoring
+  role='Data Analyst',
+  goal='Extract actionable insights',
+  backstory="""You're a data analyst at a large company.
+    You're responsible for analyzing data and providing insights
+    to the business.
+    You're currently working on a project to analyze the
+    performance of our marketing campaigns.""",
+  tools=[my_tool1, my_tool2],  # Optional, defaults to an empty list
+  llm=my_llm,  # Optional
+  function_calling_llm=my_llm,  # Optional
+  max_iter=15,  # Optional
+  max_rpm=None, # Optional
+  max_execution_time=None, # Optional
+  verbose=True,  # Optional
+  allow_delegation=False,  # Optional
+  step_callback=my_intermediate_step_callback,  # Optional
+  cache=True,  # Optional
+  system_template=my_system_template,  # Optional
+  prompt_template=my_prompt_template,  # Optional
+  response_template=my_response_template,  # Optional
+  config=my_config,  # Optional
+  crew=my_crew,  # Optional
+  tools_handler=my_tools_handler,  # Optional
+  cache_handler=my_cache_handler,  # Optional
+  callbacks=[callback1, callback2],  # Optional
+  allow_code_execution=True,  # Optional
+  max_retry_limit=2,  # Optional
+  use_system_prompt=True,  # Optional
+  respect_context_window=True,  # Optional
+  code_execution_mode='safe',  # Optional, defaults to 'safe'
 )
 ```

-Let's break down some key parameter combinations for common use cases:
+## Setting prompt templates

-#### Basic Research Agent
-```python Code
-research_agent = Agent(
-    role="Research Analyst",
-    goal="Find and summarize information about specific topics",
-    backstory="You are an experienced researcher with attention to detail",
-    tools=[SerperDevTool()],
-    verbose=True  # Enable logging for debugging
-)
-```
+Prompt templates are used to format the prompt for the agent. You can use to update the system, regular and response templates for the agent. Here's an example of how to set prompt templates:

-#### Code Development Agent
-```python Code
-dev_agent = Agent(
-    role="Senior Python Developer",
-    goal="Write and debug Python code",
-    backstory="Expert Python developer with 10 years of experience",
-    allow_code_execution=True,
-    code_execution_mode="safe",  # Uses Docker for safety
-    max_execution_time=300,  # 5-minute timeout
-    max_retry_limit=3  # More retries for complex code tasks
-)
-```
-
-#### Long-Running Analysis Agent
-```python Code
-analysis_agent = Agent(
-    role="Data Analyst",
-    goal="Perform deep analysis of large datasets",
-    backstory="Specialized in big data analysis and pattern recognition",
-    memory=True,
-    respect_context_window=True,
-    max_rpm=10,  # Limit API calls
-    function_calling_llm="gpt-4o-mini"  # Cheaper model for tool calls
-)
-```
-
-#### Custom Template Agent
-```python Code
-custom_agent = Agent(
-    role="Customer Service Representative",
-    goal="Assist customers with their inquiries",
-    backstory="Experienced in customer support with a focus on satisfaction",
-    system_template="""<|start_header_id|>system<|end_header_id|>
+```python Code example
+agent = Agent(
+        role="{topic} specialist",
+        goal="Figure {goal} out",
+        backstory="I am the master of {role}",
+        system_template="""<|start_header_id|>system<|end_header_id|>
                        {{ .System }}<|eot_id|>""",
-    prompt_template="""<|start_header_id|>user<|end_header_id|>
+        prompt_template="""<|start_header_id|>user<|end_header_id|>
                        {{ .Prompt }}<|eot_id|>""",
-    response_template="""<|start_header_id|>assistant<|end_header_id|>
+        response_template="""<|start_header_id|>assistant<|end_header_id|>
                        {{ .Response }}<|eot_id|>""",
 )
 ```

-### Parameter Details
+## Bring your third-party agents

-#### Critical Parameters
- `role`, `goal`, and `backstory` are required and shape the agent's behavior
- `llm` determines the language model used (default: OpenAI's GPT-4)
+Extend your third-party agents like LlamaIndex, Langchain, Autogen or fully custom agents using the the CrewAI's `BaseAgent` class.

-#### Memory and Context
- `memory`: Enable to maintain conversation history
- `respect_context_window`: Prevents token limit issues
- `knowledge_sources`: Add domain-specific knowledge bases
-
-#### Execution Control
- `max_iter`: Maximum attempts before giving best answer
- `max_execution_time`: Timeout in seconds
- `max_rpm`: Rate limiting for API calls
- `max_retry_limit`: Retries on error
-
-#### Code Execution
- `allow_code_execution`: Must be True to run code
- `code_execution_mode`: 
-  - `"safe"`: Uses Docker (recommended for production)
-  - `"unsafe"`: Direct execution (use only in trusted environments)
-
-#### Templates
- `system_template`: Defines agent's core behavior
- `prompt_template`: Structures input format
- `response_template`: Formats agent responses
-
-<Note>
-When using custom templates, you can use variables like `{role}`, `{goal}`, and `{input}` in your templates. These will be automatically populated during execution.
+<Note>   
+  **BaseAgent** includes attributes and methods required to integrate with your crews to run and delegate tasks to other agents within your own crew.
 </Note>

-## Agent Tools
+CrewAI is a universal multi-agent framework that allows for all agents to work together to automate tasks and solve problems.

-Agents can be equipped with various tools to enhance their capabilities. CrewAI supports tools from:
- [CrewAI Toolkit](https://github.com/joaomdmoura/crewai-tools)
- [LangChain Tools](https://python.langchain.com/docs/integrations/tools)
+```python Code example
+from crewai import Agent, Task, Crew
+from custom_agent import CustomAgent # You need to build and extend your own agent logic with the CrewAI BaseAgent class then import it here.

-Here's how to add tools to an agent:
+from langchain.agents import load_tools

-```python Code
-from crewai import Agent
-from crewai_tools import SerperDevTool, WikipediaTools
+langchain_tools = load_tools(["google-serper"], llm=llm)

-# Create tools
-search_tool = SerperDevTool()
-wiki_tool = WikipediaTools()
-
-# Add tools to agent
-researcher = Agent(
-    role="AI Technology Researcher",
-    goal="Research the latest AI developments",
-    tools=[search_tool, wiki_tool],
-    verbose=True
+agent1 = CustomAgent(
+    role="agent role",
+    goal="who is {input}?",
+    backstory="agent backstory",
+    verbose=True,
 )
+
+task1 = Task(
+    expected_output="a short biography of {input}",
+    description="a short biography of {input}",
+    agent=agent1,
+)
+
+agent2 = Agent(
+    role="agent role",
+    goal="summarize the short bio for {input} and if needed do more research",
+    backstory="agent backstory",
+    verbose=True,
+)
+
+task2 = Task(
+    description="a tldr summary of the short biography",
+    expected_output="5 bullet point summary of the biography",
+    agent=agent2,
+    context=[task1],
+)
+
+my_crew = Crew(agents=[agent1, agent2], tasks=[task1, task2])
+crew = my_crew.kickoff(inputs={"input": "Mark Twain"})
 ```

-## Agent Memory and Context
+## Conclusion

-Agents can maintain memory of their interactions and use context from previous tasks. This is particularly useful for complex workflows where information needs to be retained across multiple tasks.
-
-```python Code
-from crewai import Agent
-
-analyst = Agent(
-    role="Data Analyst",
-    goal="Analyze and remember complex data patterns",
-    memory=True,  # Enable memory
-    verbose=True
-)
-```
-
-<Note>
-When `memory` is enabled, the agent will maintain context across multiple interactions, improving its ability to handle complex, multi-step tasks.
-</Note>
-
-## Important Considerations and Best Practices
-
-### Security and Code Execution
- When using `allow_code_execution`, be cautious with user input and always validate it
- Use `code_execution_mode: "safe"` (Docker) in production environments
- Consider setting appropriate `max_execution_time` limits to prevent infinite loops
-
-### Performance Optimization
- Use `respect_context_window: true` to prevent token limit issues
- Set appropriate `max_rpm` to avoid rate limiting
- Enable `cache: true` to improve performance for repetitive tasks
- Adjust `max_iter` and `max_retry_limit` based on task complexity
-
-### Memory and Context Management
- Use `memory: true` for tasks requiring historical context
- Leverage `knowledge_sources` for domain-specific information
- Configure `embedder_config` when using custom embedding models
- Use custom templates (`system_template`, `prompt_template`, `response_template`) for fine-grained control over agent behavior
-
-### Agent Collaboration
- Enable `allow_delegation: true` when agents need to work together
- Use `step_callback` to monitor and log agent interactions
- Consider using different LLMs for different purposes:
-  - Main `llm` for complex reasoning
-  - `function_calling_llm` for efficient tool usage
-
-### Model Compatibility
- Set `use_system_prompt: false` for older models that don't support system messages
- Ensure your chosen `llm` supports the features you need (like function calling)
-
-## Troubleshooting Common Issues
-
-1. **Rate Limiting**: If you're hitting API rate limits:
-   - Implement appropriate `max_rpm`
-   - Use caching for repetitive operations
-   - Consider batching requests
-
-2. **Context Window Errors**: If you're exceeding context limits:
-   - Enable `respect_context_window`
-   - Use more efficient prompts
-   - Clear agent memory periodically
-
-3. **Code Execution Issues**: If code execution fails:
-   - Verify Docker is installed for safe mode
-   - Check execution permissions
-   - Review code sandbox settings
-
-4. **Memory Issues**: If agent responses seem inconsistent:
-   - Verify memory is enabled
-   - Check knowledge source configuration
-   - Review conversation history management
-
-Remember that agents are most effective when configured according to their specific use case. Take time to understand your requirements and adjust these parameters accordingly.
+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.
--- a/docs/concepts/flows.mdx
+++ b/docs/concepts/flows.mdx
@@ -18,60 +18,63 @@ Flows allow you to create structured, event-driven workflows. They provide a sea

 4. **Flexible Control Flow**: Implement conditional logic, loops, and branching within your workflows.

+5. **Input Flexibility**: Flows can accept inputs to initialize or update their state, with different handling for structured and unstructured state management.
+
 ## Getting Started

 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
+### Passing Inputs to Flows

+Flows can accept inputs to initialize or update their state before execution. The way inputs are handled depends on whether the flow uses structured or unstructured state management.
+
+#### Structured State Management
+
+In structured state management, the flow's state is defined using a Pydantic `BaseModel`. Inputs must match the model's schema, and any updates will overwrite the default values.
+
+```python
 from crewai.flow.flow import Flow, listen, start
-from dotenv import load_dotenv
-from litellm import completion
+from pydantic import BaseModel

+class ExampleState(BaseModel):
+    counter: int = 0
+    message: str = ""

-class ExampleFlow(Flow):
-    model = "gpt-4o-mini"
-
+class StructuredExampleFlow(Flow[ExampleState]):
    @start()
-    def generate_city(self):
-        print("Starting flow")
+    def first_method(self):
+        # Implementation

-        response = completion(
-            model=self.model,
-            messages=[
-                {
-                    "role": "user",
-                    "content": "Return the name of a random city in the world.",
-                },
-            ],
-        )
+flow = StructuredExampleFlow()
+flow.kickoff(inputs={"counter": 10})
+```

-        random_city = response["choices"][0]["message"]["content"]
-        print(f"Random City: {random_city}")
+In this example, the `counter` is initialized to `10`, while `message` retains its default value.

-        return random_city
+#### Unstructured State Management

-    @listen(generate_city)
-    def generate_fun_fact(self, random_city):
-        response = completion(
-            model=self.model,
-            messages=[
-                {
-                    "role": "user",
-                    "content": f"Tell me a fun fact about {random_city}",
-                },
-            ],
-        )
+In unstructured state management, the flow's state is a dictionary. You can pass any dictionary to update the state.

-        fun_fact = response["choices"][0]["message"]["content"]
-        return fun_fact
+```python
+from crewai.flow.flow import Flow, listen, start

+class UnstructuredExampleFlow(Flow):
+    @start()
+    def first_method(self):
+        # Implementation

+flow = UnstructuredExampleFlow()
+flow.kickoff(inputs={"counter": 5, "message": "Initial message"})
+```

-flow = ExampleFlow()
-result = flow.kickoff()
+Here, both `counter` and `message` are updated based on the provided inputs.

-print(f"Generated fun fact: {result}")
+**Note:** Ensure that inputs for structured state management adhere to the defined schema to avoid validation errors.
+
+### Example Flow
+
+```python
+# Existing example code
 ```

 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.
@@ -94,14 +97,14 @@ The `@listen()` decorator can be used in several ways:

 1. **Listening to a Method by Name**: You can pass the name of the method you want to listen to as a string. When that method completes, the listener method will be triggered.

-   ```python Code
+   ```python
   @listen("generate_city")
   def generate_fun_fact(self, random_city):
       # Implementation
   ```

 2. **Listening to a Method Directly**: You can pass the method itself. When that method completes, the listener method will be triggered.
-   ```python Code
+   ```python
   @listen(generate_city)
   def generate_fun_fact(self, random_city):
       # Implementation
@@ -118,7 +121,7 @@ When you run a Flow, the final output is determined by the last method that comp
 Here's how you can access the final output:

 <CodeGroup>
-```python Code
+```python
 from crewai.flow.flow import Flow, listen, start

 class OutputExampleFlow(Flow):
@@ -130,18 +133,17 @@ class OutputExampleFlow(Flow):
    def second_method(self, first_output):
        return f"Second method received: {first_output}"

-
 flow = OutputExampleFlow()
 final_output = flow.kickoff()

 print("---- Final Output ----")
 print(final_output)
-````
+```

-``` text Output
+```text
 ---- Final Output ----
 Second method received: Output from first_method
-````
+```

 </CodeGroup>

@@ -156,7 +158,7 @@ Here's an example of how to update and access the state:

 <CodeGroup>

-```python Code
+```python
 from crewai.flow.flow import Flow, listen, start
 from pydantic import BaseModel

@@ -184,7 +186,7 @@ print("Final State:")
 print(flow.state)
 ```

-```text Output
+```text
 Final Output: Hello from first_method - updated by second_method
 Final State:
 counter=2 message='Hello from first_method - updated by second_method'
@@ -208,10 +210,10 @@ allowing developers to choose the approach that best fits their application's ne
 In unstructured state management, all state is stored in the `state` attribute of the `Flow` class.
 This approach offers flexibility, enabling developers to add or modify state attributes on the fly without defining a strict schema.

-```python Code
+```python
 from crewai.flow.flow import Flow, listen, start

-class UntructuredExampleFlow(Flow):
+class UnstructuredExampleFlow(Flow):

    @start()
    def first_method(self):
@@ -230,8 +232,7 @@ class UntructuredExampleFlow(Flow):

        print(f"State after third_method: {self.state}")

-
-flow = UntructuredExampleFlow()
+flow = UnstructuredExampleFlow()
 flow.kickoff()
 ```

@@ -245,16 +246,14 @@ flow.kickoff()
 Structured state management leverages predefined schemas to ensure consistency and type safety across the workflow.
 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
+```python
 from crewai.flow.flow import Flow, listen, start
 from pydantic import BaseModel

-
 class ExampleState(BaseModel):
    counter: int = 0
    message: str = ""

-
 class StructuredExampleFlow(Flow[ExampleState]):

    @start()
@@ -273,7 +272,6 @@ class StructuredExampleFlow(Flow[ExampleState]):

        print(f"State after third_method: {self.state}")

-
 flow = StructuredExampleFlow()
 flow.kickoff()
 ```
@@ -307,7 +305,7 @@ The `or_` function in Flows allows you to listen to multiple methods and trigger

 <CodeGroup>

-```python Code
+```python
 from crewai.flow.flow import Flow, listen, or_, start

 class OrExampleFlow(Flow):
@@ -324,13 +322,11 @@ class OrExampleFlow(Flow):
    def logger(self, result):
        print(f"Logger: {result}")

-
-
 flow = OrExampleFlow()
 flow.kickoff()
 ```

-```text Output
+```text
 Logger: Hello from the start method
 Logger: Hello from the second method
 ```
@@ -346,7 +342,7 @@ The `and_` function in Flows allows you to listen to multiple methods and trigge

 <CodeGroup>

-```python Code
+```python
 from crewai.flow.flow import Flow, and_, listen, start

 class AndExampleFlow(Flow):
@@ -368,7 +364,7 @@ flow = AndExampleFlow()
 flow.kickoff()
 ```

-```text Output
+```text
 ---- Logger ----
 {'greeting': 'Hello from the start method', 'joke': 'What do computers eat? Microchips.'}
 ```
@@ -385,7 +381,7 @@ You can specify different routes based on the output of the method, allowing you

 <CodeGroup>

-```python Code
+```python
 import random
 from crewai.flow.flow import Flow, listen, router, start
 from pydantic import BaseModel
@@ -416,12 +412,11 @@ class RouterFlow(Flow[ExampleState]):
    def fourth_method(self):
        print("Fourth method running")

-
 flow = RouterFlow()
 flow.kickoff()
 ```

-```text Output
+```text
 Starting the structured flow
 Third method running
 Fourth method running
@@ -484,7 +479,7 @@ The `main.py` file is where you create your flow and connect the crews together.

 Here's an example of how you can connect the `poem_crew` in the `main.py` file:

-```python Code
+```python
 #!/usr/bin/env python
 from random import randint

@@ -560,6 +555,42 @@ uv run kickoff

 The flow will execute, and you should see the output in the console.

+
+### Adding Additional Crews Using the CLI
+
+Once you have created your initial flow, you can easily add additional crews to your project using the CLI. This allows you to expand your flow's capabilities by integrating new crews without starting from scratch.
+
+To add a new crew to your existing flow, use the following command:
+
+```bash
+crewai flow add-crew <crew_name>
+```
+
+This command will create a new directory for your crew within the `crews` folder of your flow project. It will include the necessary configuration files and a crew definition file, similar to the initial setup.
+
+#### Folder Structure
+
+After adding a new crew, your folder structure will look like this:
+
+| 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.                              |
+| └── `name_of_crew/`       | Directory for the new crew.                                          |
+|     ├── `config/`         | Configuration files directory for the new crew.                     |
+|     │   ├── `agents.yaml` | YAML file defining the agents for the new crew.                     |
+|     │   └── `tasks.yaml`  | YAML file defining the tasks for the new crew.                      |
+|     └── `name_of_crew.py` | Script for the new crew functionality.                              |
+
+You can then customize the `agents.yaml` and `tasks.yaml` files to define the agents and tasks for your new crew. The `name_of_crew.py` file will contain the crew's logic, which you can modify to suit your needs.
+
+By using the CLI to add additional crews, you can efficiently build complex AI workflows that leverage multiple crews working together.
+
 ## Plot Flows

 Visualizing your AI workflows can provide valuable insights into the structure and execution paths of your flows. CrewAI offers a powerful visualization tool that allows you to generate interactive plots of your flows, making it easier to understand and optimize your AI workflows.
@@ -576,7 +607,7 @@ CrewAI provides two convenient methods to generate plots of your flows:

 If you are working directly with a flow instance, you can generate a plot by calling the `plot()` method on your flow object. This method will create an HTML file containing the interactive plot of your flow.

-```python Code
+```python
 # Assuming you have a flow instance
 flow.plot("my_flow_plot")
 ```
@@ -599,13 +630,114 @@ The generated plot will display nodes representing the tasks in your flow, with

 By visualizing your flows, you can gain a clearer understanding of the workflow's structure, making it easier to debug, optimize, and communicate your AI processes to others.

-### Conclusion

-Plotting your flows is a powerful feature of CrewAI that enhances your ability to design and manage complex AI workflows. Whether you choose to use the `plot()` method or the command line, generating plots will provide you with a visual representation of your workflows, aiding in both development and presentation.
+## Advanced
+
+In this section, we explore more complex use cases of CrewAI Flows, starting with a self-evaluation loop. This pattern is crucial for developing AI systems that can iteratively improve their outputs through feedback.
+
+### 1) Self-Evaluation Loop
+
+The self-evaluation loop is a powerful pattern that allows AI workflows to automatically assess and refine their outputs. This example demonstrates how to set up a flow that generates content, evaluates it, and iterates based on feedback until the desired quality is achieved.
+
+#### Overview
+
+The self-evaluation loop involves two main Crews:
+
+1. **ShakespeareanXPostCrew**: Generates a Shakespearean-style post on a given topic.
+2. **XPostReviewCrew**: Evaluates the generated post, providing feedback on its validity and quality.
+
+The process iterates until the post meets the criteria or a maximum retry limit is reached. This approach ensures high-quality outputs through iterative refinement.
+
+#### Importance
+
+This pattern is essential for building robust AI systems that can adapt and improve over time. By automating the evaluation and feedback loop, developers can ensure that their AI workflows produce reliable and high-quality results.
+
+#### Main Code Highlights
+
+Below is the `main.py` file for the self-evaluation loop flow:
+
+```python
+from typing import Optional
+from crewai.flow.flow import Flow, listen, router, start
+from pydantic import BaseModel
+from self_evaluation_loop_flow.crews.shakespeare_crew.shakespeare_crew import (
+    ShakespeareanXPostCrew,
+)
+from self_evaluation_loop_flow.crews.x_post_review_crew.x_post_review_crew import (
+    XPostReviewCrew,
+)
+
+class ShakespeareXPostFlowState(BaseModel):
+    x_post: str = ""
+    feedback: Optional[str] = None
+    valid: bool = False
+    retry_count: int = 0
+
+class ShakespeareXPostFlow(Flow[ShakespeareXPostFlowState]):
+
+    @start("retry")
+    def generate_shakespeare_x_post(self):
+        print("Generating Shakespearean X post")
+        topic = "Flying cars"
+        result = (
+            ShakespeareanXPostCrew()
+            .crew()
+            .kickoff(inputs={"topic": topic, "feedback": self.state.feedback})
+        )
+        print("X post generated", result.raw)
+        self.state.x_post = result.raw
+
+    @router(generate_shakespeare_x_post)
+    def evaluate_x_post(self):
+        if self.state.retry_count > 3:
+            return "max_retry_exceeded"
+        result = XPostReviewCrew().crew().kickoff(inputs={"x_post": self.state.x_post})
+        self.state.valid = result["valid"]
+        self.state.feedback = result["feedback"]
+        print("valid", self.state.valid)
+        print("feedback", self.state.feedback)
+        self.state.retry_count += 1
+        if self.state.valid:
+            return "complete"
+        return "retry"
+
+    @listen("complete")
+    def save_result(self):
+        print("X post is valid")
+        print("X post:", self.state.x_post)
+        with open("x_post.txt", "w") as file:
+            file.write(self.state.x_post)
+
+    @listen("max_retry_exceeded")
+    def max_retry_exceeded_exit(self):
+        print("Max retry count exceeded")
+        print("X post:", self.state.x_post)
+        print("Feedback:", self.state.feedback)
+
+def kickoff():
+    shakespeare_flow = ShakespeareXPostFlow()
+    shakespeare_flow.kickoff()
+
+def plot():
+    shakespeare_flow = ShakespeareXPostFlow()
+    shakespeare_flow.plot()
+
+if __name__ == "__main__":
+    kickoff()
+```
+
+#### Code Highlights
+
+- **Retry Mechanism**: The flow uses a retry mechanism to regenerate the post if it doesn't meet the criteria, up to a maximum of three retries.
+- **Feedback Loop**: Feedback from the `XPostReviewCrew` is used to refine the post iteratively.
+- **State Management**: The flow maintains state using a Pydantic model, ensuring type safety and clarity.
+
+For a complete example and further details, please refer to the [Self Evaluation Loop Flow repository](https://github.com/crewAIInc/crewAI-examples/tree/main/self_evaluation_loop_flow).
+

 ## Next Steps

-If you're interested in exploring additional examples of flows, we have a variety of recommendations in our examples repository. Here are four specific flow examples, each showcasing unique use cases to help you match your current problem type to a specific example:
+If you're interested in exploring additional examples of flows, we have a variety of recommendations in our examples repository. Here are five specific flow examples, each showcasing unique use cases to help you match your current problem type to a specific example:

 1. **Email Auto Responder Flow**: This example demonstrates an infinite loop where a background job continually runs to automate email responses. It's a great use case for tasks that need to be performed repeatedly without manual intervention. [View Example](https://github.com/crewAIInc/crewAI-examples/tree/main/email_auto_responder_flow)

@@ -615,6 +747,8 @@ If you're interested in exploring additional examples of flows, we have a variet

 4. **Meeting Assistant Flow**: This flow demonstrates how to broadcast one event to trigger multiple follow-up actions. For instance, after a meeting is completed, the flow can update a Trello board, send a Slack message, and save the results. It's a great example of handling multiple outcomes from a single event, making it ideal for comprehensive task management and notification systems. [View Example](https://github.com/crewAIInc/crewAI-examples/tree/main/meeting_assistant_flow)

+5. **Self Evaluation Loop Flow**: This flow demonstrates a self-evaluation loop where AI workflows automatically assess and refine their outputs through feedback. It involves generating content, evaluating it, and iterating until the desired quality is achieved. This pattern is crucial for developing robust AI systems that can adapt and improve over time. [View Example](https://github.com/crewAIInc/crewAI-examples/tree/main/self_evaluation_loop_flow)
+
 By exploring these examples, you can gain insights into how to leverage CrewAI Flows for various use cases, from automating repetitive tasks to managing complex, multi-step processes with dynamic decision-making and human feedback.

 Also, check out our YouTube video on how to use flows in CrewAI below!
@@ -628,4 +762,4 @@ Also, check out our YouTube video on how to use flows in CrewAI below!
  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
  referrerpolicy="strict-origin-when-cross-origin"
  allowfullscreen
-></iframe>
+></iframe>
--- a/docs/concepts/knowledge.mdx
+++ b/docs/concepts/knowledge.mdx
@@ -6,226 +6,100 @@ icon: book

 # Using Knowledge in CrewAI

+## Introduction
+
+Knowledge in CrewAI serves as a foundational component for enriching AI agents with contextual and relevant information. It enables agents to access and utilize structured data sources during their execution processes, making them more intelligent and responsive.
+
+The Knowledge class in CrewAI provides a powerful way to manage and query knowledge sources for your AI agents. This guide will show you how to implement knowledge management in your CrewAI projects.
+
 ## What is Knowledge?

-Knowledge in CrewAI is a powerful system that allows AI agents to access and utilize external information sources during their tasks. Think of it as giving your agents a reference library they can consult while working.
+The `Knowledge` class in CrewAI manages various sources that store information, which can be queried and retrieved by AI agents. This modular approach allows you to integrate diverse data formats such as text, PDFs, spreadsheets, and more into your AI workflows.

-<Info>
-  Key benefits of using Knowledge:
-  - Enhance agents with domain-specific information
-  - Support decisions with real-world data
-  - Maintain context across conversations
-  - Ground responses in factual information
-</Info>
+Additionally, we have specific tools for generate knowledge sources for strings, text files, PDF's, and Spreadsheets. You can expand on any source type by extending the `KnowledgeSource` class.

-## Supported Knowledge Sources
+## Basic Implementation

-CrewAI supports various types of knowledge sources out of the box:
-
-<CardGroup cols={2}>
-  <Card title="Text Sources" icon="text">
-    - Raw strings
-    - Text files (.txt)
-    - PDF documents
-  </Card>
-  <Card title="Structured Data" icon="table">
-    - CSV files
-    - Excel spreadsheets
-    - JSON documents
-  </Card>
-</CardGroup>
-
-## Quick Start
-
-Here's a simple example using string-based knowledge:
+Here's a simple example of how to use the Knowledge class:

 ```python
-from crewai import Agent, Task, Crew
-from crewai.knowledge import StringKnowledgeSource
+from crewai import Agent, Task, Crew, Process, LLM
+from crewai.knowledge.source.string_knowledge_source import StringKnowledgeSource

-# 1. Create a knowledge source
-product_info = StringKnowledgeSource(
-    content="""Our product X1000 has the following features:
-    - 10-hour battery life
-    - Water-resistant
-    - Available in black and silver
-    Price: $299.99""",
-    metadata={"category": "product"}
+# Create a knowledge source
+content = "Users name is John. He is 30 years old and lives in San Francisco."
+string_source = StringKnowledgeSource(
+    content=content, metadata={"preference": "personal"}
 )

-# 2. Create an agent with knowledge
-sales_agent = Agent(
-    role="Sales Representative",
-    goal="Accurately answer customer questions about products",
-    backstory="Expert in product features and customer service",
-    knowledge_sources=[product_info]  # Attach knowledge to agent
+# Create an agent with the knowledge store
+agent = Agent(
+    role="About User",
+    goal="You know everything about the user.",
+    backstory="""You are a master at understanding people and their preferences.""",
+    verbose=True
 )

-# 3. Create a task
-answer_task = Task(
-    description="Answer: What colors is the X1000 available in and how much does it cost?",
-    agent=sales_agent
+task = Task(
+    description="Answer the following questions about the user: {question}",
+    expected_output="An answer to the question.",
+    agent=agent,
 )

-# 4. Create and run the crew
-crew = Crew(
-    agents=[sales_agent],
-    tasks=[answer_task]
-)
-
-result = crew.kickoff()
-```
-
-## Knowledge Configuration
-
-### Collection Names
-
-Knowledge sources are organized into collections for better management:
-
-```python
-# Create knowledge sources with specific collections
-tech_specs = StringKnowledgeSource(
-    content="Technical specifications...",
-    collection_name="product_tech_specs"
-)
-
-pricing_info = StringKnowledgeSource(
-    content="Pricing information...",
-    collection_name="product_pricing"
-)
-```
-
-### Metadata and Filtering
-
-Add metadata to organize and filter knowledge:
-
-```python
-knowledge_source = StringKnowledgeSource(
-    content="Product details...",
-    metadata={
-        "category": "electronics",
-        "product_line": "premium",
-        "last_updated": "2024-03"
-    }
-)
-```
-
-### Chunking Configuration
-
-Control how your content is split for processing:
-
-```python
-knowledge_source = PDFKnowledgeSource(
-    file_path="product_manual.pdf",
-    chunk_size=2000,     # Characters per chunk
-    chunk_overlap=200    # Overlap between chunks
-)
-```
-
-## Advanced Usage
-
-### Custom Knowledge Sources
-
-Create your own knowledge source by extending the base class:
-
-```python
-from crewai.knowledge.source import BaseKnowledgeSource
-
-class APIKnowledgeSource(BaseKnowledgeSource):
-    def __init__(self, api_endpoint: str, **kwargs):
-        super().__init__(**kwargs)
-        self.api_endpoint = api_endpoint
-    
-    def load_content(self):
-        # Implement API data fetching
-        response = requests.get(self.api_endpoint)
-        return response.json()
-    
-    def add(self):
-        content = self.load_content()
-        # Process and store content
-        self.save_documents({"source": "api"})
-```
-
-### Embedder Configuration
-
-Customize the embedding process:
-
-```python
 crew = Crew(
    agents=[agent],
    tasks=[task],
-    knowledge_sources=[source],
-    embedder={
-        "provider": "ollama",
-        "config": {"model": "nomic-embed-text:latest"},
-    }
+    verbose=True,
+    process=Process.sequential,
+    knowledge_sources=[string_source], # Enable knowledge by adding the sources here.
 )
+
+result = crew.kickoff(inputs={"question": "What city does John live in and how old is he?"})
 ```

-### Referencing Sources
-
-You can reference knowledge sources by their collection name or metadata.
-
-* Add a directory to your crew project called `knowledge`:
-* File paths in knowledge can be referenced relative to the `knowledge` directory.
-
-Example:
-A file inside the `knowledge` directory called `example.txt` can be referenced as `example.txt`.
+## Appending Knowledge Sources To Individual Agents
+Sometimes you may want to append knowledge sources to an individual agent. You can do this by setting the `knowledge` parameter in the `Agent` class.

 ```python
-source = TextFileKnowledgeSource(
-    file_path="example.txt", # or /example.txt
-    collection_name="example"
-)
-crew = Crew(
-    agents=[agent],
-    tasks=[task],
-    knowledge_sources=[source],
+agent = Agent(
+    ...
+    knowledge_sources=[
+        StringKnowledgeSource(
+            content="Users name is John. He is 30 years old and lives in San Francisco.",
+            metadata={"preference": "personal"},
+        )
+    ],
 )
 ```

-## Best Practices
+## Agent Level Knowledge Sources

-<AccordionGroup>
-  <Accordion title="Content Organization">
-    - Use meaningful collection names
-    - Add detailed metadata for filtering
-    - Keep chunk sizes appropriate for your content
-    - Consider content overlap for context preservation
-  </Accordion>
-  
-  <Accordion title="Performance Tips">
-    - Use smaller chunk sizes for precise retrieval
-    - Implement metadata filtering for faster searches
-    - Choose appropriate embedding models for your use case
-    - Cache frequently accessed knowledge
-  </Accordion>
-  
-  <Accordion title="Error Handling">
-    - Validate knowledge source content
-    - Handle missing or corrupted files
-    - Monitor embedding generation
-    - Implement fallback options
-  </Accordion>
-</AccordionGroup>
+You can also append knowledge sources to an individual agent by setting the `knowledge_sources` parameter in the `Agent` class.

-## Common Issues and Solutions
+```python
+string_source = StringKnowledgeSource(
+    content="Users name is John. He is 30 years old and lives in San Francisco.",
+    metadata={"preference": "personal"},
+)
+agent = Agent(
+    ...
+    knowledge_sources=[string_source],
+)
+```

-<AccordionGroup>
-  <Accordion title="Content Not Found">
-    If agents can't find relevant information:
-    - Check chunk sizes
-    - Verify knowledge source loading
-    - Review metadata filters
-    - Test with simpler queries first
-  </Accordion>
-  
-  <Accordion title="Performance Issues">
-    If knowledge retrieval is slow:
-    - Reduce chunk sizes
-    - Optimize metadata filtering
-    - Consider using a lighter embedding model
-    - Cache frequently accessed content
-  </Accordion>
-</AccordionGroup>
+## Embedder Configuration
+
+You can also configure the embedder for the knowledge store. This is useful if you want to use a different embedder for the knowledge store than the one used for the agents.
+
+```python
+...
+string_source = StringKnowledgeSource(
+    content="Users name is John. He is 30 years old and lives in San Francisco.",
+    metadata={"preference": "personal"}
+)
+crew = Crew(
+    ...
+    knowledge_sources=[string_source],
+    embedder_config={"provider": "ollama", "config": {"model": "nomic-embed-text:latest"}},
+)
+```
--- a/docs/concepts/langchain-tools.mdx
+++ b/docs/concepts/langchain-tools.mdx
@@ -7,45 +7,32 @@ icon: link
 ## Using LangChain Tools

 <Info>
-    CrewAI seamlessly integrates with LangChain's comprehensive [list of tools](https://python.langchain.com/docs/integrations/tools/), all of which can be used with CrewAI.
+    CrewAI seamlessly integrates with LangChain’s comprehensive [list of tools](https://python.langchain.com/docs/integrations/tools/), all of which can be used with CrewAI.
 </Info>

 ```python Code
 import os
-from dotenv import load_dotenv
-from crewai import Agent, Task, Crew
-from crewai.tools import BaseTool
-from pydantic import Field
-from langchain_community.utilities import GoogleSerperAPIWrapper
+from crewai import Agent
+from langchain.agents import Tool
+from langchain.utilities import GoogleSerperAPIWrapper

-# Set up your SERPER_API_KEY key in an .env file, eg:
-# SERPER_API_KEY=<your api key>
-load_dotenv()
+# Setup API keys
+os.environ["SERPER_API_KEY"] = "Your Key"

 search = GoogleSerperAPIWrapper()

-class SearchTool(BaseTool):
-    name: str = "Search"
-    description: str = "Useful for search-based queries. Use this to find current information about markets, companies, and trends."
-    search: GoogleSerperAPIWrapper = Field(default_factory=GoogleSerperAPIWrapper)
+# Create and assign the search tool to an agent
+serper_tool = Tool(
+  name="Intermediate Answer",
+  func=search.run,
+  description="Useful for search-based queries",
+)

-    def _run(self, query: str) -> str:
-        """Execute the search query and return results"""
-        try:
-            return self.search.run(query)
-        except Exception as e:
-            return f"Error performing search: {str(e)}"
-
-# Create Agents
-researcher = Agent(
-    role='Research Analyst',
-    goal='Gather current market data and trends',
-    backstory="""You are an expert research analyst with years of experience in
-    gathering market intelligence. You're known for your ability to find
-    relevant and up-to-date market information and present it in a clear,
-    actionable format.""",
-    tools=[SearchTool()],
-    verbose=True
+agent = Agent(
+  role='Research Analyst',
+  goal='Provide up-to-date market analysis',
+  backstory='An expert analyst with a keen eye for market trends.',
+  tools=[serper_tool]
 )

 # rest of the code ...
@@ -53,6 +40,6 @@ researcher = Agent(

 ## Conclusion

-Tools are pivotal in extending the capabilities of CrewAI agents, enabling them to undertake a broad spectrum of tasks and collaborate effectively.
-When building solutions with CrewAI, leverage both custom and existing tools to empower your agents and enhance the AI ecosystem. Consider utilizing error handling, caching mechanisms,
-and the flexibility of tool arguments to optimize your agents' performance and capabilities.
+Tools are pivotal in extending the capabilities of CrewAI agents, enabling them to undertake a broad spectrum of tasks and collaborate effectively. 
+When building solutions with CrewAI, leverage both custom and existing tools to empower your agents and enhance the AI ecosystem. Consider utilizing error handling, caching mechanisms, 
+and the flexibility of tool arguments to optimize your agents' performance and capabilities.
--- a/docs/concepts/llms.mdx
+++ b/docs/concepts/llms.mdx
@@ -1,323 +1,205 @@
 ---
-title: 'LLMs'
-description: 'A comprehensive guide to configuring and using Large Language Models (LLMs) in your CrewAI projects'
-icon: 'microchip-ai'
+title: LLMs
+description: Learn how to configure and optimize LLMs for your CrewAI projects.
+icon: microchip-ai
 ---

-<Note>
-  CrewAI integrates with multiple LLM providers through LiteLLM, giving you the flexibility to choose the right model for your specific use case. This guide will help you understand how to configure and use different LLM providers in your CrewAI projects.
-</Note>
+# Large Language Models (LLMs) in CrewAI

-## What are LLMs?
+Large Language Models (LLMs) are the backbone of intelligent agents in the CrewAI framework. This guide will help you understand, configure, and optimize LLM usage for your CrewAI projects.

-Large Language Models (LLMs) are the core intelligence behind CrewAI agents. They enable agents to understand context, make decisions, and generate human-like responses. Here's what you need to know:
+## Key Concepts

-<CardGroup cols={2}>
-  <Card title="LLM Basics" icon="brain">
-    Large Language Models are AI systems trained on vast amounts of text data. They power the intelligence of your CrewAI agents, enabling them to understand and generate human-like text.
-  </Card>
-  <Card title="Context Window" icon="window">
-    The context window determines how much text an LLM can process at once. Larger windows (e.g., 128K tokens) allow for more context but may be more expensive and slower.
-  </Card>
-  <Card title="Temperature" icon="temperature-three-quarters">
-    Temperature (0.0 to 1.0) controls response randomness. Lower values (e.g., 0.2) produce more focused, deterministic outputs, while higher values (e.g., 0.8) increase creativity and variability.
-  </Card>
-  <Card title="Provider Selection" icon="server">
-    Each LLM provider (e.g., OpenAI, Anthropic, Google) offers different models with varying capabilities, pricing, and features. Choose based on your needs for accuracy, speed, and cost.
-  </Card>
-</CardGroup>
+- **LLM**: Large Language Model, the AI powering agent intelligence
+- **Agent**: A CrewAI entity that uses an LLM to perform tasks
+- **Provider**: A service that offers LLM capabilities (e.g., OpenAI, Anthropic, Ollama, [more providers](https://docs.litellm.ai/docs/providers))

-## Available Models and Their Capabilities
+## Configuring LLMs for Agents

-Here's a detailed breakdown of supported models and their capabilities:
+CrewAI offers flexible options for setting up LLMs:

-<Tabs>
-  <Tab title="OpenAI">
-    | Model | Context Window | Best For |
-    |-------|---------------|-----------|
-    | GPT-4 | 8,192 tokens | High-accuracy tasks, complex reasoning |
-    | GPT-4 Turbo | 128,000 tokens | Long-form content, document analysis |
-    | GPT-4o & GPT-4o-mini | 128,000 tokens | Cost-effective large context processing |
+### 1. Default Configuration

-    <Note>
-      1 token ≈ 4 characters in English. For example, 8,192 tokens ≈ 32,768 characters or about 6,000 words.
-    </Note>
-  </Tab>
-  <Tab title="Groq">
-    | Model | Context Window | Best For |
-    |-------|---------------|-----------|
-    | Llama 3.1 70B/8B | 131,072 tokens | High-performance, large context tasks |
-    | Llama 3.2 Series | 8,192 tokens | General-purpose tasks |
-    | Mixtral 8x7B | 32,768 tokens | Balanced performance and context |
-    | Gemma Series | 8,192 tokens | Efficient, smaller-scale tasks |
+By default, CrewAI uses the `gpt-4o-mini` model. It uses environment variables if no LLM is specified:
+- `OPENAI_MODEL_NAME` (defaults to "gpt-4o-mini" if not set)
+- `OPENAI_API_BASE`
+- `OPENAI_API_KEY`

-    <Tip>
-      Groq is known for its fast inference speeds, making it suitable for real-time applications.
-    </Tip>
-  </Tab>
-  <Tab title="Others">
-    | Provider | Context Window | Key Features |
-    |----------|---------------|--------------|
-    | Deepseek Chat | 128,000 tokens | Specialized in technical discussions |
-    | Claude 3 | Up to 200K tokens | Strong reasoning, code understanding |
-    | Gemini | Varies by model | Multimodal capabilities |
+### 2. Updating YAML files

-    <Info>
-      Provider selection should consider factors like:
-      - API availability in your region
-      - Pricing structure
-      - Required features (e.g., streaming, function calling)
-      - Performance requirements
-    </Info>
-  </Tab>
-</Tabs>
+You can update the `agents.yml` file to refer to the LLM you want to use:

-## Setting Up Your LLM
+```yaml Code
+researcher:
+    role: Research Specialist
+    goal: Conduct comprehensive research and analysis to gather relevant information,
+        synthesize findings, and produce well-documented insights.
+    backstory: A dedicated research professional with years of experience in academic
+        investigation, literature review, and data analysis, known for thorough and
+        methodical approaches to complex research questions.
+    verbose: true
+    llm: openai/gpt-4o
+    # llm: azure/gpt-4o-mini
+    # llm: gemini/gemini-pro
+    # llm: anthropic/claude-3-5-sonnet-20240620
+    # llm: bedrock/anthropic.claude-3-sonnet-20240229-v1:0
+    # llm: mistral/mistral-large-latest
+    # llm: ollama/llama3:70b
+    # llm: groq/llama-3.2-90b-vision-preview
+    # llm: watsonx/meta-llama/llama-3-1-70b-instruct
+    # llm: nvidia_nim/meta/llama3-70b-instruct
+    # llm: sambanova/Meta-Llama-3.1-8B-Instruct
+    # ...
+```

-There are three ways to configure LLMs in CrewAI. Choose the method that best fits your workflow:
-
-<Tabs>
-  <Tab title="1. Environment Variables">
-    The simplest way to get started. Set these variables in your environment:
-
-    ```bash
-    # Required: Your API key for authentication
-    OPENAI_API_KEY=<your-api-key>
-
-    # Optional: Default model selection
-    OPENAI_MODEL_NAME=gpt-4o-mini  # Default if not set
-
-    # Optional: Organization ID (if applicable)
-    OPENAI_ORGANIZATION_ID=<your-org-id>
-    ```
-
-    <Warning>
-      Never commit API keys to version control. Use environment files (.env) or your system's secret management.
-    </Warning>
-  </Tab>
-  <Tab title="2. YAML Configuration">
-    Create a YAML file to define your agent configurations. This method is great for version control and team collaboration:
-
-    ```yaml
-    researcher:
-        # Agent Definition
-        role: Research Specialist
-        goal: Conduct comprehensive research and analysis
-        backstory: A dedicated research professional with years of experience
-        verbose: true
-
-        # Model Selection (uncomment your choice)
-        
-        # OpenAI Models - Known for reliability and performance
-        llm: openai/gpt-4o-mini
-        # llm: openai/gpt-4        # More accurate but expensive
-        # llm: openai/gpt-4-turbo  # Fast with large context
-        # llm: openai/gpt-4o       # Optimized for longer texts
-        # llm: openai/o1-preview   # Latest features
-        # llm: openai/o1-mini      # Cost-effective
-
-        # Azure Models - For enterprise deployments
-        # llm: azure/gpt-4o-mini
-        # llm: azure/gpt-4
-        # llm: azure/gpt-35-turbo
-
-        # Anthropic Models - Strong reasoning capabilities
-        # llm: anthropic/claude-3-opus-20240229-v1:0
-        # llm: anthropic/claude-3-sonnet-20240229-v1:0
-        # llm: anthropic/claude-3-haiku-20240307-v1:0
-        # llm: anthropic/claude-2.1
-        # llm: anthropic/claude-2.0
-
-        # Google Models - Good for general tasks
-        # llm: gemini/gemini-pro
-        # llm: gemini/gemini-1.5-pro-latest
-        # llm: gemini/gemini-1.0-pro-latest
-
-        # AWS Bedrock Models - Enterprise-grade
-        # llm: bedrock/anthropic.claude-3-sonnet-20240229-v1:0
-        # llm: bedrock/anthropic.claude-v2:1
-        # llm: bedrock/amazon.titan-text-express-v1
-        # llm: bedrock/meta.llama2-70b-chat-v1
-
-        # Mistral Models - Open source alternative
-        # llm: mistral/mistral-large-latest
-        # llm: mistral/mistral-medium-latest
-        # llm: mistral/mistral-small-latest
-
-        # Groq Models - Fast inference
-        # llm: groq/mixtral-8x7b-32768
-        # llm: groq/llama-3.1-70b-versatile
-        # llm: groq/llama-3.2-90b-text-preview
-        # llm: groq/gemma2-9b-it
-        # llm: groq/gemma-7b-it
-
-        # IBM watsonx.ai Models - Enterprise features
-        # llm: watsonx/ibm/granite-13b-chat-v2
-        # llm: watsonx/meta-llama/llama-3-1-70b-instruct
-        # llm: watsonx/bigcode/starcoder2-15b
-
-        # Ollama Models - Local deployment
-        # llm: ollama/llama3:70b
-        # llm: ollama/codellama
-        # llm: ollama/mistral
-        # llm: ollama/mixtral
-        # llm: ollama/phi
-
-        # Fireworks AI Models - Specialized tasks
-        # llm: fireworks_ai/accounts/fireworks/models/llama-v3-70b-instruct
-        # llm: fireworks_ai/accounts/fireworks/models/mixtral-8x7b
-        # llm: fireworks_ai/accounts/fireworks/models/zephyr-7b-beta
-
-        # Perplexity AI Models - Research focused
-        # llm: pplx/llama-3.1-sonar-large-128k-online
-        # llm: pplx/mistral-7b-instruct
-        # llm: pplx/codellama-34b-instruct
-        # llm: pplx/mixtral-8x7b-instruct
-
-        # Hugging Face Models - Community models
-        # llm: huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct
-        # llm: huggingface/mistralai/Mixtral-8x7B-Instruct-v0.1
-        # llm: huggingface/tiiuae/falcon-180B-chat
-        # llm: huggingface/google/gemma-7b-it
-
-        # Nvidia NIM Models - GPU-optimized
-        # llm: nvidia_nim/meta/llama3-70b-instruct
-        # llm: nvidia_nim/mistral/mixtral-8x7b
-        # llm: nvidia_nim/google/gemma-7b
-
-        # SambaNova Models - Enterprise AI
-        # llm: sambanova/Meta-Llama-3.1-8B-Instruct
-        # llm: sambanova/BioMistral-7B
-        # llm: sambanova/Falcon-180B
-    ```
-
-    <Info>
-      The YAML configuration allows you to:
-      - Version control your agent settings
-      - Easily switch between different models
-      - Share configurations across team members
-      - Document model choices and their purposes
-    </Info>
-  </Tab>
-  <Tab title="3. Direct Code">
-    For maximum flexibility, configure LLMs directly in your Python code:
-
-    ```python
-    from crewai import LLM
-
-    # Basic configuration
-    llm = LLM(model="gpt-4")
-
-    # Advanced configuration with detailed parameters
-    llm = LLM(
-        model="gpt-4o-mini",
-        temperature=0.7,        # Higher for more creative outputs
-        timeout=120,           # Seconds to wait for response
-        max_tokens=4000,       # Maximum length of response
-        top_p=0.9,            # Nucleus sampling parameter
-        frequency_penalty=0.1, # Reduce repetition
-        presence_penalty=0.1,  # Encourage topic diversity
-        response_format={"type": "json"},  # For structured outputs
-        seed=42               # For reproducible results
-    )
-    ```
-
-    <Info>
-      Parameter explanations:
-      - `temperature`: Controls randomness (0.0-1.0)
-      - `timeout`: Maximum wait time for response
-      - `max_tokens`: Limits response length
-      - `top_p`: Alternative to temperature for sampling
-      - `frequency_penalty`: Reduces word repetition
-      - `presence_penalty`: Encourages new topics
-      - `response_format`: Specifies output structure
-      - `seed`: Ensures consistent outputs
-    </Info>
-  </Tab>
-</Tabs>
-
-## Advanced Features and Optimization
-
-Learn how to get the most out of your LLM configuration:
+Keep in mind that you will need to set certain ENV vars depending on the model you are
+using to account for the credentials or set a custom LLM object like described below.
+Here are some of the required ENV vars for some of the LLM integrations:

 <AccordionGroup>
-  <Accordion title="Context Window Management">
-    CrewAI includes smart context management features:
-
-    ```python
-    from crewai import LLM
-
-    # CrewAI automatically handles:
-    # 1. Token counting and tracking
-    # 2. Content summarization when needed
-    # 3. Task splitting for large contexts
-
-    llm = LLM(
-        model="gpt-4",
-        max_tokens=4000,  # Limit response length
-    )
+    <Accordion title="OpenAI">
+    ```python Code
+    OPENAI_API_KEY=<your-api-key>
+    OPENAI_API_BASE=<optional-custom-base-url>
+    OPENAI_MODEL_NAME=<openai-model-name>
+    OPENAI_ORGANIZATION=<your-org-id>       # OPTIONAL
+    OPENAI_API_BASE=<openaiai-api-base>     # OPTIONAL
    ```
+    </Accordion>

-    <Info>
-      Best practices for context management:
-      1. Choose models with appropriate context windows
-      2. Pre-process long inputs when possible
-      3. Use chunking for large documents
-      4. Monitor token usage to optimize costs
-    </Info>
-  </Accordion>
+    <Accordion title="Anthropic">
+    ```python Code
+    ANTHROPIC_API_KEY=<your-api-key>
+    ```
+    </Accordion>

-  <Accordion title="Performance Optimization">
-    <Steps>
-      <Step title="Token Usage Optimization">
-        Choose the right context window for your task:
-        - Small tasks (up to 4K tokens): Standard models
-        - Medium tasks (between 4K-32K): Enhanced models
-        - Large tasks (over 32K): Large context models
-        
-        ```python
-        # Configure model with appropriate settings
-        llm = LLM(
-            model="openai/gpt-4-turbo-preview",
-            temperature=0.7,    # Adjust based on task
-            max_tokens=4096,    # Set based on output needs
-            timeout=300        # Longer timeout for complex tasks
-        )
-        ```
-        <Tip>
-          - Lower temperature (0.1 to 0.3) for factual responses
-          - Higher temperature (0.7 to 0.9) for creative tasks
-        </Tip>
-      </Step>
+    <Accordion title="Google">
+    ```python Code
+    GEMINI_API_KEY=<your-api-key>
+    ```
+    </Accordion>

-      <Step title="Best Practices">
-        1. Monitor token usage
-        2. Implement rate limiting
-        3. Use caching when possible
-        4. Set appropriate max_tokens limits
-      </Step>
-    </Steps>
+    <Accordion title="Azure">
+    ```python Code
+    AZURE_API_KEY=<your-api-key>                    # "my-azure-api-key"
+    AZURE_API_BASE=<your-resource-url>              # "https://example-endpoint.openai.azure.com"
+    AZURE_API_VERSION=<api-version>                 # "2023-05-15"
+    AZURE_AD_TOKEN=<your-azure-ad-token>            # Optional
+    AZURE_API_TYPE=<your-azure-api-type>            # Optional
+    ```
+    </Accordion>

-    <Info>
-      Remember to regularly monitor your token usage and adjust your configuration as needed to optimize costs and performance.
-    </Info>
-  </Accordion>
+    <Accordion title="AWS Bedrock">
+    ```python Code
+    AWS_ACCESS_KEY_ID=<your-access-key>
+    AWS_SECRET_ACCESS_KEY=<your-secret-key>
+    AWS_DEFAULT_REGION=<your-region>
+    ```
+    </Accordion>
+
+    <Accordion title="Mistral">
+    ```python Code
+    MISTRAL_API_KEY=<your-api-key>
+    ```
+    </Accordion>
+
+    <Accordion title="Groq">
+    ```python Code
+    GROQ_API_KEY=<your-api-key>
+    ```
+    </Accordion>
+
+    <Accordion title="IBM watsonx.ai">
+    ```python Code
+    WATSONX_URL=<your-url>                          # (required) Base URL of your WatsonX instance
+    WATSONX_APIKEY=<your-apikey>                    # (required) IBM cloud API key
+    WATSONX_TOKEN=<your-token>                      # (required) IAM auth token (alternative to APIKEY)
+    WATSONX_PROJECT_ID=<your-project-id>            # (optional) Project ID of your WatsonX instance
+    WATSONX_DEPLOYMENT_SPACE_ID=<your-space-id>     # (optional) ID of deployment space for deployed models
+    ```
+    </Accordion>
 </AccordionGroup>

-## Provider Configuration Examples
+### 3. Custom LLM Objects
+
+Pass a custom LLM implementation or object from another library.
+
+See below for examples.
+
+<Tabs>
+    <Tab title="String Identifier">
+    ```python Code
+    agent = Agent(llm="gpt-4o", ...)
+    ```
+    </Tab>
+
+    <Tab title="LLM Instance">
+    ```python Code
+    from crewai import LLM
+
+    llm = LLM(model="gpt-4", temperature=0.7)
+    agent = Agent(llm=llm, ...)
+    ```
+    </Tab>
+</Tabs>
+
+## Connecting to OpenAI-Compatible LLMs
+
+You can connect to OpenAI-compatible LLMs using either environment variables or by setting specific attributes on the LLM class:
+
+<Tabs>
+    <Tab title="Using Environment Variables">
+    ```python Code
+    import os
+
+    os.environ["OPENAI_API_KEY"] = "your-api-key"
+    os.environ["OPENAI_API_BASE"] = "https://api.your-provider.com/v1"
+    ```
+    </Tab>
+    <Tab title="Using LLM Class Attributes">
+    ```python Code
+    from crewai import LLM
+
+    llm = LLM(
+        model="custom-model-name",
+        api_key="your-api-key",
+        base_url="https://api.your-provider.com/v1"
+    )
+    agent = Agent(llm=llm, ...)
+    ```
+    </Tab>
+</Tabs>
+
+## LLM Configuration Options
+
+When configuring an LLM for your agent, you have access to a wide range of parameters:
+
+| Parameter         | Type            | Description                                                                                      |
+|:------------------|:---------------:|:-------------------------------------------------------------------------------------------------|
+| **model**            | `str`             | Name of the model to use (e.g., "gpt-4", "gpt-3.5-turbo", "ollama/llama3.1"). For more options, visit the providers documentation. |
+| **timeout**          | `float, int`      | Maximum time (in seconds) to wait for a response.                                                |
+| **temperature**      | `float`           | Controls randomness in output (0.0 to 1.0).                                                      |
+| **top_p**            | `float`           | Controls diversity of output (0.0 to 1.0).                                                       |
+| **n**                | `int`             | Number of completions to generate.                                                               |
+| **stop**             | `str, List[str]`  | Sequence(s) where generation should stop.                                                        |
+| **max_tokens**       | `int`             | Maximum number of tokens to generate.                                                            |
+| **presence_penalty** | `float`           | Penalizes new tokens based on their presence in prior text.                                      |
+| **frequency_penalty**| `float`           | Penalizes new tokens based on their frequency in prior text.                                     |
+| **logit_bias**       | `Dict[int, float]`| Modifies likelihood of specified tokens appearing.                                              |
+| **response_format**  | `Dict[str, Any]`  | Specifies the format of the response (e.g., JSON object).                                        |
+| **seed**             | `int`             | Sets a random seed for deterministic results.                                                    |
+| **logprobs**         | `bool`            | Returns log probabilities of output tokens if enabled.                                           |
+| **top_logprobs**     | `int`             | Number of most likely tokens for which to return log probabilities.                              |
+| **base_url**         | `str`             | The base URL for the API endpoint.                                                               |
+| **api_version**      | `str`             | Version of the API to use.                                                                       |
+| **api_key**          | `str`             | Your API key for authentication.                                                                 |
+
+
+These are examples of how to configure LLMs for your agent.

 <AccordionGroup>
-  <Accordion title="OpenAI">
-    ```python Code
-    # Required
-    OPENAI_API_KEY=sk-...
-    
-    # Optional
-    OPENAI_API_BASE=<custom-base-url>
-    OPENAI_ORGANIZATION=<your-org-id>
-    ```
+    <Accordion title="OpenAI">

-    Example usage:
    ```python Code
    from crewai import LLM

@@ -329,306 +211,193 @@ Learn how to get the most out of your LLM configuration:
        frequency_penalty=0.1,
        presence_penalty=0.1,
        stop=["END"],
-        seed=42
+        seed=42,
+        base_url="https://api.openai.com/v1",
+        api_key="your-api-key-here"
    )
+    agent = Agent(llm=llm, ...)
    ```
-  </Accordion>
+    </Accordion>

-  <Accordion title="Anthropic">
-    ```python Code
-    ANTHROPIC_API_KEY=sk-ant-...
-    ```
+    <Accordion title="Cerebras">

-    Example usage:
    ```python Code
+    from crewai import LLM
+
    llm = LLM(
-        model="anthropic/claude-3-sonnet-20240229-v1:0",
-        temperature=0.7
+        model="cerebras/llama-3.1-70b",
+        api_key="your-api-key-here"
+    )
+    agent = Agent(llm=llm, ...)
+    ```
+    </Accordion>
+
+    <Accordion title="Ollama (Local LLMs)">
+
+    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"
+        ),
+        ...
    )
    ```
-  </Accordion>
+    </Accordion>

-  <Accordion title="Google">
-    ```python Code
-    GEMINI_API_KEY=<your-api-key>
-    ```
+    <Accordion title="Groq">

-    Example usage:
    ```python Code
+    from crewai import LLM
+
    llm = LLM(
-        model="gemini/gemini-pro",
-        temperature=0.7
+        model="groq/llama3-8b-8192",
+        api_key="your-api-key-here"
    )
+    agent = Agent(llm=llm, ...)
    ```
-  </Accordion>
+    </Accordion>

-  <Accordion title="Azure">
-    ```python Code
-    # Required
-    AZURE_API_KEY=<your-api-key>
-    AZURE_API_BASE=<your-resource-url>
-    AZURE_API_VERSION=<api-version>
-    
-    # Optional
-    AZURE_AD_TOKEN=<your-azure-ad-token>
-    AZURE_API_TYPE=<your-azure-api-type>
-    ```
+    <Accordion title="Anthropic">

-    Example usage:
    ```python Code
+    from crewai import LLM
+
    llm = LLM(
-        model="azure/gpt-4",
-        api_version="2023-05-15"
+        model="anthropic/claude-3-5-sonnet-20241022",
+        api_key="your-api-key-here"
    )
+    agent = Agent(llm=llm, ...)
    ```
-  </Accordion>
+    </Accordion>

-  <Accordion title="AWS Bedrock">
+    <Accordion title="Fireworks AI">
    ```python Code
-    AWS_ACCESS_KEY_ID=<your-access-key>
-    AWS_SECRET_ACCESS_KEY=<your-secret-key>
-    AWS_DEFAULT_REGION=<your-region>
-    ```
+    from crewai import LLM

-    Example usage:
-    ```python Code
    llm = LLM(
-        model="bedrock/anthropic.claude-3-sonnet-20240229-v1:0"
+        model="fireworks_ai/accounts/fireworks/models/llama-v3-70b-instruct",
+        api_key="your-api-key-here"
    )
+    agent = Agent(llm=llm, ...)
    ```
-  </Accordion>
+    </Accordion>

-  <Accordion title="Mistral">
-    ```python Code
-    MISTRAL_API_KEY=<your-api-key>
-    ```
+    <Accordion title="Gemini">

-    Example usage:
    ```python Code
+    from crewai import LLM
+
    llm = LLM(
-        model="mistral/mistral-large-latest",
-        temperature=0.7
+        model="gemini/gemini-1.5-pro-002",
+        api_key="your-api-key-here"
    )
+    agent = Agent(llm=llm, ...)
    ```
-  </Accordion>
+    </Accordion>

-  <Accordion title="Groq">
-    ```python Code
-    GROQ_API_KEY=<your-api-key>
-    ```
+    <Accordion title="Perplexity AI (pplx-api)">

-    Example usage:
    ```python Code
+    from crewai import LLM
+
    llm = LLM(
-        model="groq/llama-3.2-90b-text-preview",
-        temperature=0.7
+        model="llama-3.1-sonar-large-128k-online",
+        base_url="https://api.perplexity.ai/",
+        api_key="your-api-key-here"
    )
+    agent = Agent(llm=llm, ...)
    ```
-  </Accordion>
+    </Accordion>
+
+    <Accordion title="IBM watsonx.ai">
+    You can use IBM Watson by seeting the following ENV vars:

-  <Accordion title="IBM watsonx.ai">
    ```python Code
-    # Required
    WATSONX_URL=<your-url>
    WATSONX_APIKEY=<your-apikey>
    WATSONX_PROJECT_ID=<your-project-id>
-    
-    # Optional
-    WATSONX_TOKEN=<your-token>
-    WATSONX_DEPLOYMENT_SPACE_ID=<your-space-id>
    ```

-    Example usage:
+    You can then define your agents llms by updating the `agents.yml`
+
+    ```yaml Code
+    researcher:
+        role: Research Specialist
+        goal: Conduct comprehensive research and analysis to gather relevant information,
+            synthesize findings, and produce well-documented insights.
+        backstory: A dedicated research professional with years of experience in academic
+            investigation, literature review, and data analysis, known for thorough and
+            methodical approaches to complex research questions.
+        verbose: true
+        llm: watsonx/meta-llama/llama-3-1-70b-instruct
+    ```
+
+    You can also set up agents more dynamically as a base level LLM instance, like bellow:
+
    ```python Code
+    from crewai import LLM
+
    llm = LLM(
-        model="watsonx/meta-llama/llama-3-1-70b-instruct",
-        base_url="https://api.watsonx.ai/v1"
+        model="watsonx/ibm/granite-13b-chat-v2",
+        base_url="https://api.watsonx.ai/v1",
+        api_key="your-api-key-here"
    )
+    agent = Agent(llm=llm, ...)
    ```
-  </Accordion>
+    </Accordion>

-  <Accordion title="Ollama (Local LLMs)">
-    1. Install Ollama: [ollama.ai](https://ollama.ai/)
-    2. Run a model: `ollama run llama2`
-    3. Configure:
+    <Accordion title="Hugging Face">

    ```python Code
-    llm = LLM(
-        model="ollama/llama3:70b",
-        base_url="http://localhost:11434"
-    )
-    ```
-  </Accordion>
+    from crewai import LLM

-  <Accordion title="Fireworks AI">
-    ```python Code
-    FIREWORKS_API_KEY=<your-api-key>
-    ```
-
-    Example usage:
-    ```python Code
-    llm = LLM(
-        model="fireworks_ai/accounts/fireworks/models/llama-v3-70b-instruct",
-        temperature=0.7
-    )
-    ```
-  </Accordion>
-
-  <Accordion title="Perplexity AI">
-    ```python Code
-    PERPLEXITY_API_KEY=<your-api-key>
-    ```
-
-    Example usage:
-    ```python Code
-    llm = LLM(
-        model="llama-3.1-sonar-large-128k-online",
-        base_url="https://api.perplexity.ai/"
-    )
-    ```
-  </Accordion>
-
-  <Accordion title="Hugging Face">
-    ```python Code
-    HUGGINGFACE_API_KEY=<your-api-key>
-    ```
-
-    Example usage:
-    ```python Code
    llm = LLM(
        model="huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct",
+        api_key="your-api-key-here",
        base_url="your_api_endpoint"
    )
+    agent = Agent(llm=llm, ...)
    ```
-  </Accordion>
-
-  <Accordion title="Nvidia NIM">
-    ```python Code
-    NVIDIA_API_KEY=<your-api-key>
-    ```
-
-    Example usage:
-    ```python Code
-    llm = LLM(
-        model="nvidia_nim/meta/llama3-70b-instruct",
-        temperature=0.7
-    )
-    ```
-  </Accordion>
-
-  <Accordion title="SambaNova">
-    ```python Code
-    SAMBANOVA_API_KEY=<your-api-key>
-    ```
-
-    Example usage:
-    ```python Code
-    llm = LLM(
-        model="sambanova/Meta-Llama-3.1-8B-Instruct",
-        temperature=0.7
-    )
-    ```
-  </Accordion>
-
-  <Accordion title="Cerebras">
-    ```python Code
-    # Required
-    CEREBRAS_API_KEY=<your-api-key>
-    ```
-
-    Example usage:
-    ```python Code
-    llm = LLM(
-        model="cerebras/llama3.1-70b",
-        temperature=0.7,
-        max_tokens=8192
-    )
-    ```
-
-    <Info>
-      Cerebras features:
-      - Fast inference speeds
-      - Competitive pricing
-      - Good balance of speed and quality
-      - Support for long context windows
-    </Info>
-  </Accordion>
+    </Accordion>
 </AccordionGroup>

-## Common Issues and Solutions
+## Changing the Base API URL

-<Tabs>
-  <Tab title="Authentication">
-    <Warning>
-      Most authentication issues can be resolved by checking API key format and environment variable names.
-    </Warning>
-    
-    ```bash
-    # OpenAI
-    OPENAI_API_KEY=sk-...
-    
-    # Anthropic
-    ANTHROPIC_API_KEY=sk-ant-...
-    ```
-  </Tab>
-  <Tab title="Model Names">
-    <Check>
-      Always include the provider prefix in model names
-    </Check>
-    
-    ```python
-    # Correct
-    llm = LLM(model="openai/gpt-4")
-    
-    # Incorrect
-    llm = LLM(model="gpt-4")
-    ```
-  </Tab>
-  <Tab title="Context Length">
-    <Tip>
-      Use larger context models for extensive tasks
-    </Tip>
-    
-    ```python
-    # Large context model
-    llm = LLM(model="openai/gpt-4o")  # 128K tokens
-    ```
-  </Tab>
-</Tabs>
+You can change the base API URL for any LLM provider by setting the `base_url` parameter:

-## Getting Help
+```python Code
+from crewai import LLM

-If you need assistance, these resources are available:
+llm = LLM(
+    model="custom-model-name",
+    base_url="https://api.your-provider.com/v1",
+    api_key="your-api-key"
+)
+agent = Agent(llm=llm, ...)
+```

-<CardGroup cols={3}>
-  <Card
-    title="LiteLLM Documentation"
-    href="https://docs.litellm.ai/docs/"
-    icon="book"
-  >
-    Comprehensive documentation for LiteLLM integration and troubleshooting common issues.
-  </Card>
-  <Card
-    title="GitHub Issues"
-    href="https://github.com/joaomdmoura/crewAI/issues"
-    icon="bug"
-  >
-    Report bugs, request features, or browse existing issues for solutions.
-  </Card>
-  <Card
-    title="Community Forum"
-    href="https://community.crewai.com"
-    icon="comment-question"
-  >
-    Connect with other CrewAI users, share experiences, and get help from the community.
-  </Card>
-</CardGroup>
+This is particularly useful when working with OpenAI-compatible APIs or when you need to specify a different endpoint for your chosen provider.

-<Note>
-  Best Practices for API Key Security:
-  - Use environment variables or secure vaults
-  - Never commit keys to version control
-  - Rotate keys regularly
-  - Use separate keys for development and production
-  - Monitor key usage for unusual patterns
-</Note>
+## Best Practices
+
+1. **Choose the right model**: Balance capability and cost.
+2. **Optimize prompts**: Clear, concise instructions improve output.
+3. **Manage tokens**: Monitor and limit token usage for efficiency.
+4. **Use appropriate temperature**: Lower for factual tasks, higher for creative ones.
+5. **Implement error handling**: Gracefully manage API errors and rate limits.
+
+## Troubleshooting
+
+- **API Errors**: Check your API key, network connection, and rate limits.
+- **Unexpected Outputs**: Refine your prompts and adjust temperature or top_p.
+- **Performance Issues**: Consider using a more powerful model or optimizing your queries.
+- **Timeout Errors**: Increase the `timeout` parameter or optimize your input.
--- a/docs/concepts/tasks.mdx
+++ b/docs/concepts/tasks.mdx
@@ -1,6 +1,6 @@
 ---
 title: Tasks
-description: Detailed guide on managing and creating tasks within the CrewAI framework.
+description: Detailed guide on managing and creating tasks within the CrewAI framework, reflecting the latest codebase updates.
 icon: list-check
 ---

@@ -8,171 +8,41 @@ icon: list-check

 In the CrewAI framework, a `Task` is a specific assignment completed by an `Agent`. 

-Tasks provide all necessary details for execution, such as a description, the agent responsible, required tools, and more, facilitating a wide range of action complexities.
+They provide all necessary details for execution, such as a description, the agent responsible, required tools, and more, facilitating a wide range of action complexities.
+

 Tasks within CrewAI can be collaborative, requiring multiple agents to work together. This is managed through the task properties and orchestrated by the Crew's process, enhancing teamwork and efficiency.

-### Task Execution Flow
-
-Tasks can be executed in two ways:
- **Sequential**: Tasks are executed in the order they are defined
- **Hierarchical**: Tasks are assigned to agents based on their roles and expertise
-
-The execution flow is defined when creating the crew:
-```python Code
-crew = Crew(
-    agents=[agent1, agent2],
-    tasks=[task1, task2],
-    process=Process.sequential  # or Process.hierarchical
-)
-```
-
 ## Task Attributes

 | Attribute                        | Parameters        | Type                          | Description                                                                                                          |
 | :------------------------------- | :---------------- | :---------------------------- | :------------------------------------------------------------------------------------------------------------------- |
 | **Description**                  | `description`     | `str`                         | A clear, concise statement of what the task entails.                                                                 |
+| **Agent**                        | `agent`           | `Optional[BaseAgent]`         | The agent responsible for the task, assigned either directly or by the crew's process.                               |
 | **Expected Output**              | `expected_output` | `str`                         | A detailed description of what the task's completion looks like.                                                     |
-| **Name** _(optional)_           | `name`           | `Optional[str]`               | A name identifier for the task.                                                                                      |
-| **Agent** _(optional)_          | `agent`           | `Optional[BaseAgent]`         | The agent responsible for executing the task.                                                                        |
-| **Tools** _(optional)_          | `tools`           | `List[BaseTool]`             | The tools/resources the agent is limited to use for this task.                                                       |
-| **Context** _(optional)_         | `context`         | `Optional[List["Task"]]`      | Other tasks whose outputs will be used as context for this task.                                                     |
-| **Async Execution** _(optional)_ | `async_execution` | `Optional[bool]`              | Whether the task should be executed asynchronously. Defaults to False.                                               |
-| **Config** _(optional)_          | `config`          | `Optional[Dict[str, Any]]`    | Task-specific configuration parameters.                                                                              |
-| **Output File** _(optional)_     | `output_file`     | `Optional[str]`               | File path for storing the task output.                                                                               |
-| **Output JSON** _(optional)_     | `output_json`     | `Optional[Type[BaseModel]]`   | A Pydantic model to structure the JSON output.                                                                       |
-| **Output Pydantic** _(optional)_ | `output_pydantic` | `Optional[Type[BaseModel]]`   | A Pydantic model for task output.                                                                                    |
-| **Callback** _(optional)_        | `callback`        | `Optional[Any]`               | Function/object to be executed after task completion.                                                                |
+| **Tools** _(optional)_           | `tools`           | `Optional[List[Any]]`         | The functions or capabilities the agent can utilize to perform the task. Defaults to an empty list.                  |
+| **Async Execution** _(optional)_ | `async_execution` | `Optional[bool]`              | If set, the task executes asynchronously, allowing progression without waiting for completion. Defaults to False.    |
+| **Context** _(optional)_         | `context`         | `Optional[List["Task"]]`      | Specifies tasks whose outputs are used as context for this task.                                                     |
+| **Config** _(optional)_          | `config`          | `Optional[Dict[str, Any]]`    | Additional configuration details for the agent executing the task, allowing further customization. Defaults to None. |
+| **Output JSON** _(optional)_     | `output_json`     | `Optional[Type[BaseModel]]`   | Outputs a JSON object, requiring an OpenAI client. Only one output format can be set.                                |
+| **Output Pydantic** _(optional)_ | `output_pydantic` | `Optional[Type[BaseModel]]`   | Outputs a Pydantic model object, requiring an OpenAI client. Only one output format can be set.                      |
+| **Output File** _(optional)_     | `output_file`     | `Optional[str]`               | Saves the task output to a file. If used with `Output JSON` or `Output Pydantic`, specifies how the output is saved. |
+| **Output** _(optional)_          | `output`          | `Optional[TaskOutput]`        | An instance of `TaskOutput`, containing the raw, JSON, and Pydantic output plus additional details.                  |
+| **Callback** _(optional)_        | `callback`        | `Optional[Any]`               | A callable that is executed with the task's output upon completion.                                                  |
+| **Human Input** _(optional)_     | `human_input`     | `Optional[bool]`              | Indicates if the task should involve human review at the end, useful for tasks needing human oversight. Defaults to False.|
+| **Converter Class** _(optional)_ | `converter_cls`   | `Optional[Type[Converter]]`   | A converter class used to export structured output. Defaults to None.                                                |

-## Creating Tasks
+## Creating a Task

-There are two ways to create tasks in CrewAI: using **YAML configuration (recommended)** or defining them **directly in code**.
+Creating a task involves defining its scope, responsible agent, and any additional attributes for flexibility:

-### YAML Configuration (Recommended)
-
-Using YAML configuration provides a cleaner, more maintainable way to define tasks. We strongly recommend using this approach to define tasks in your CrewAI projects.
-
-After creating your CrewAI project as outlined in the [Installation](/installation) section, navigate to the `src/latest_ai_development/config/tasks.yaml` file and modify the template to match your specific task requirements.
-
-<Note>
-Variables in your YAML files (like `{topic}`) will be replaced with values from your inputs when running the crew:
 ```python Code
-crew.kickoff(inputs={'topic': 'AI Agents'})
-```
-</Note>
-
-Here's an example of how to configure tasks using YAML:
-
-```yaml tasks.yaml
-research_task:
-  description: >
-    Conduct a thorough research about {topic}
-    Make sure you find any interesting and relevant information given
-    the current year is 2024.
-  expected_output: >
-    A list with 10 bullet points of the most relevant information about {topic}
-  agent: researcher
-
-reporting_task:
-  description: >
-    Review the context you got and expand each topic into a full section for a report.
-    Make sure the report is detailed and contains any and all relevant information.
-  expected_output: >
-    A fully fledge reports with the mains topics, each with a full section of information.
-    Formatted as markdown without '```'
-  agent: reporting_analyst
-  output_file: report.md
-```
-
-To use this YAML configuration in your code, create a crew class that inherits from `CrewBase`:
-
-```python crew.py
-# src/latest_ai_development/crew.py
-
-from crewai import Agent, Crew, Process, Task
-from crewai.project import CrewBase, agent, crew, task
-from crewai_tools import SerperDevTool
-
-@CrewBase
-class LatestAiDevelopmentCrew():
-  """LatestAiDevelopment crew"""
-
-  @agent
-  def researcher(self) -> Agent:
-    return Agent(
-      config=self.agents_config['researcher'],
-      verbose=True,
-      tools=[SerperDevTool()]
-    )
-
-  @agent
-  def reporting_analyst(self) -> Agent:
-    return Agent(
-      config=self.agents_config['reporting_analyst'],
-      verbose=True
-    )
-
-  @task
-  def research_task(self) -> Task:
-    return Task(
-      config=self.tasks_config['research_task']
-    )
-
-  @task
-  def reporting_task(self) -> Task:
-    return Task(
-      config=self.tasks_config['reporting_task']
-    )
-
-  @crew
-  def crew(self) -> Crew:
-    return Crew(
-      agents=[
-        self.researcher(),
-        self.reporting_analyst()
-      ],
-      tasks=[
-        self.research_task(),
-        self.reporting_task()
-      ],
-      process=Process.sequential
-    )
-```
-
-<Note>
-The names you use in your YAML files (`agents.yaml` and `tasks.yaml`) should match the method names in your Python code.
-</Note>
-
-### Direct Code Definition (Alternative)
-
-Alternatively, you can define tasks directly in your code without using YAML configuration:
-
-```python task.py
 from crewai import Task

-research_task = Task(
-    description="""
-        Conduct a thorough research about AI Agents.
-        Make sure you find any interesting and relevant information given
-        the current year is 2024.
-    """,
-    expected_output="""
-        A list with 10 bullet points of the most relevant information about AI Agents
-    """,
-    agent=researcher
-)
-
-reporting_task = Task(
-    description="""
-        Review the context you got and expand each topic into a full section for a report.
-        Make sure the report is detailed and contains any and all relevant information.
-    """,
-    expected_output="""
-        A fully fledge reports with the mains topics, each with a full section of information.
-        Formatted as markdown without '```'
-    """,
-    agent=reporting_analyst,
-    output_file="report.md"
+task = Task(
+    description='Find and summarize the latest and most relevant news on AI',
+    agent=sales_agent,
+    expected_output='A bullet list summary of the top 5 most important AI news',
 )
 ```

@@ -182,8 +52,6 @@ reporting_task = Task(

 ## Task Output

-Understanding task outputs is crucial for building effective AI workflows. CrewAI provides a structured way to handle task results through the `TaskOutput` class, which supports multiple output formats and can be easily passed between tasks.
-
 The output of a task in CrewAI framework is encapsulated within the `TaskOutput` class. This class provides a structured way to access results of a task, including various formats such as raw output, JSON, and Pydantic models.

 By default, the `TaskOutput` will only include the `raw` output. A `TaskOutput` will only include the `pydantic` or `json_dict` output if the original `Task` object was configured with `output_pydantic` or `output_json`, respectively.
@@ -244,186 +112,6 @@ if task_output.pydantic:
    print(f"Pydantic Output: {task_output.pydantic}")
 ```

-## Task Dependencies and Context
-
-Tasks can depend on the output of other tasks using the `context` attribute. For example:
-
-```python Code
-research_task = Task(
-    description="Research the latest developments in AI",
-    expected_output="A list of recent AI developments",
-    agent=researcher
-)
-
-analysis_task = Task(
-    description="Analyze the research findings and identify key trends",
-    expected_output="Analysis report of AI trends",
-    agent=analyst,
-    context=[research_task]  # This task will wait for research_task to complete
-)
-```
-
-## Getting Structured Consistent Outputs from Tasks
-When you need to ensure that a task outputs a structured and consistent format, you can use the `output_pydantic` or `output_json` properties on a task. These properties allow you to define the expected output structure, making it easier to parse and utilize the results in your application. 
-
-<Note>
-It's also important to note that the output of the final task of a crew becomes the final output of the actual crew itself.
-</Note>
-
-### Using `output_pydantic`
-The `output_pydantic` property allows you to define a Pydantic model that the task output should conform to. This ensures that the output is not only structured but also validated according to the Pydantic model.
-
-Here’s an example demonstrating how to use output_pydantic:
-
-```python Code
-import json
-
-from crewai import Agent, Crew, Process, Task
-from pydantic import BaseModel
-
-
-class Blog(BaseModel):
-    title: str
-    content: str
-
-
-blog_agent = Agent(
-    role="Blog Content Generator Agent",
-    goal="Generate a blog title and content",
-    backstory="""You are an expert content creator, skilled in crafting engaging and informative blog posts.""",
-    verbose=False,
-    allow_delegation=False,
-    llm="gpt-4o",
-)
-
-task1 = Task(
-    description="""Create a blog title and content on a given topic. Make sure the content is under 200 words.""",
-    expected_output="A compelling blog title and well-written content.",
-    agent=blog_agent,
-    output_pydantic=Blog,
-)
-
-# Instantiate your crew with a sequential process
-crew = Crew(
-    agents=[blog_agent],
-    tasks=[task1],
-    verbose=True,
-    process=Process.sequential,
-)
-
-result = crew.kickoff()
-
-# Option 1: Accessing Properties Using Dictionary-Style Indexing
-print("Accessing Properties - Option 1")
-title = result["title"]
-content = result["content"]
-print("Title:", title)
-print("Content:", content)
-
-# Option 2: Accessing Properties Directly from the Pydantic Model
-print("Accessing Properties - Option 2")
-title = result.pydantic.title
-content = result.pydantic.content
-print("Title:", title)
-print("Content:", content)
-
-# Option 3: Accessing Properties Using the to_dict() Method
-print("Accessing Properties - Option 3")
-output_dict = result.to_dict()
-title = output_dict["title"]
-content = output_dict["content"]
-print("Title:", title)
-print("Content:", content)
-
-# Option 4: Printing the Entire Blog Object
-print("Accessing Properties - Option 5")
-print("Blog:", result)
-
-```
-In this example:
-* A Pydantic model Blog is defined with title and content fields.
-* The task task1 uses the output_pydantic property to specify that its output should conform to the Blog model.
-* After executing the crew, you can access the structured output in multiple ways as shown.
-
-#### Explanation of Accessing the Output
-1. Dictionary-Style Indexing: You can directly access the fields using result["field_name"]. This works because the CrewOutput class implements the __getitem__ method.
-2. Directly from Pydantic Model: Access the attributes directly from the result.pydantic object.
-3. Using to_dict() Method: Convert the output to a dictionary and access the fields.
-4. Printing the Entire Object: Simply print the result object to see the structured output.
-
-### Using `output_json`
-The `output_json` property allows you to define the expected output in JSON format. This ensures that the task's output is a valid JSON structure that can be easily parsed and used in your application.
-
-Here’s an example demonstrating how to use `output_json`:
-
-```python Code
-import json
-
-from crewai import Agent, Crew, Process, Task
-from pydantic import BaseModel
-
-
-# Define the Pydantic model for the blog
-class Blog(BaseModel):
-    title: str
-    content: str
-
-
-# Define the agent
-blog_agent = Agent(
-    role="Blog Content Generator Agent",
-    goal="Generate a blog title and content",
-    backstory="""You are an expert content creator, skilled in crafting engaging and informative blog posts.""",
-    verbose=False,
-    allow_delegation=False,
-    llm="gpt-4o",
-)
-
-# Define the task with output_json set to the Blog model
-task1 = Task(
-    description="""Create a blog title and content on a given topic. Make sure the content is under 200 words.""",
-    expected_output="A JSON object with 'title' and 'content' fields.",
-    agent=blog_agent,
-    output_json=Blog,
-)
-
-# Instantiate the crew with a sequential process
-crew = Crew(
-    agents=[blog_agent],
-    tasks=[task1],
-    verbose=True,
-    process=Process.sequential,
-)
-
-# Kickoff the crew to execute the task
-result = crew.kickoff()
-
-# Option 1: Accessing Properties Using Dictionary-Style Indexing
-print("Accessing Properties - Option 1")
-title = result["title"]
-content = result["content"]
-print("Title:", title)
-print("Content:", content)
-
-# Option 2: Printing the Entire Blog Object
-print("Accessing Properties - Option 2")
-print("Blog:", result)
-```
-
-In this example:
-* A Pydantic model Blog is defined with title and content fields, which is used to specify the structure of the JSON output.
-* The task task1 uses the output_json property to indicate that it expects a JSON output conforming to the Blog model.
-* After executing the crew, you can access the structured JSON output in two ways as shown.
-
-#### Explanation of Accessing the Output
-
-1. Accessing Properties Using Dictionary-Style Indexing: You can access the fields directly using result["field_name"]. This is possible because the CrewOutput class implements the __getitem__ method, allowing you to treat the output like a dictionary. In this option, we're retrieving the title and content from the result.
-2. Printing the Entire Blog Object: By printing result, you get the string representation of the CrewOutput object. Since the __str__ method is implemented to return the JSON output, this will display the entire output as a formatted string representing the Blog object.
-
---
-
-By using output_pydantic or output_json, you ensure that your tasks produce outputs in a consistent and structured format, making it easier to process and utilize the data within your application or across multiple tasks.
-
 ## Integrating Tools with Tasks

 Leverage tools from the [CrewAI Toolkit](https://github.com/joaomdmoura/crewai-tools) and [LangChain Tools](https://python.langchain.com/docs/integrations/tools) for enhanced task performance and agent interaction.
@@ -479,16 +167,16 @@ This is useful when you have a task that depends on the output of another task t
 # ...

 research_ai_task = Task(
-    description="Research the latest developments in AI",
-    expected_output="A list of recent AI developments",
+    description='Find and summarize the latest AI news',
+    expected_output='A bullet list summary of the top 5 most important AI news',
    async_execution=True,
    agent=research_agent,
    tools=[search_tool]
 )

 research_ops_task = Task(
-    description="Research the latest developments in AI Ops",
-    expected_output="A list of recent AI Ops developments",
+    description='Find and summarize the latest AI Ops news',
+    expected_output='A bullet list summary of the top 5 most important AI Ops news',
    async_execution=True,
    agent=research_agent,
    tools=[search_tool]
@@ -496,7 +184,7 @@ research_ops_task = Task(

 write_blog_task = Task(
    description="Write a full blog post about the importance of AI and its latest news",
-    expected_output="Full blog post that is 4 paragraphs long",
+    expected_output='Full blog post that is 4 paragraphs long',
    agent=writer_agent,
    context=[research_ai_task, research_ops_task]
 )
@@ -632,4 +320,4 @@ save_output_task = Task(
 Tasks are the driving force behind the actions of agents in CrewAI. 
 By properly defining tasks and their outcomes, you set the stage for your AI agents to work effectively, either independently or as a collaborative unit. 
 Equipping tasks with appropriate tools, understanding the execution process, and following robust validation practices are crucial for maximizing CrewAI's potential, 
-ensuring agents are effectively prepared for their assignments and that tasks are executed as intended.
+ensuring agents are effectively prepared for their assignments and that tasks are executed as intended.
--- a/docs/how-to/llm-connections.mdx
+++ b/docs/how-to/llm-connections.mdx
@@ -125,10 +125,10 @@ You can connect to OpenAI-compatible LLMs using either environment variables or
    </Tab>
    <Tab title="Using LLM Class Attributes">
        <CodeGroup>
-            ```python Code
-            llm = LLM(
-                model="custom-model-name",
-                api_key="your-api-key",
+        ```python Code
+        llm = LLM(
+            model="custom-model-name",
+            api_key="your-api-key",
                base_url="https://api.your-provider.com/v1"
            )
            agent = Agent(llm=llm, ...)
@@ -179,4 +179,4 @@ This is particularly useful when working with OpenAI-compatible APIs or when you

 ## Conclusion

-By leveraging LiteLLM, CrewAI offers seamless integration with a vast array of LLMs. This flexibility allows you to choose the most suitable model for your specific needs, whether you prioritize performance, cost-efficiency, or local deployment. Remember to consult the [LiteLLM documentation](https://docs.litellm.ai/docs/) for the most up-to-date information on supported models and configuration options.
+By leveraging LiteLLM, CrewAI offers seamless integration with a vast array of LLMs. This flexibility allows you to choose the most suitable model for your specific needs, whether you prioritize performance, cost-efficiency, or local deployment. Remember to consult the [LiteLLM documentation](https://docs.litellm.ai/docs/) for the most up-to-date information on supported models and configuration options.
--- a/docs/how-to/openlit-observability.mdx
+++ b/docs/how-to/openlit-observability.mdx
@@ -1,181 +0,0 @@
---
-title: Agent Monitoring with OpenLIT
-description: Quickly start monitoring your Agents in just a single line of code with OpenTelemetry.
-icon: magnifying-glass-chart
---
-
-# OpenLIT Overview
-
-[OpenLIT](https://github.com/openlit/openlit?src=crewai-docs) is an open-source tool that makes it simple to monitor the performance of AI agents, LLMs, VectorDBs, and GPUs with just **one** line of code. 
-
-It provides OpenTelemetry-native tracing and metrics to track important parameters like cost, latency, interactions and task sequences. 
-This setup enables you to track hyperparameters and monitor for performance issues, helping you find ways to enhance and fine-tune your agents over time.
-
-<Frame caption="OpenLIT Dashboard">
-  <img src="/images/openlit1.png" alt="Overview Agent usage including cost and tokens" />
-  <img src="/images/openlit2.png" alt="Overview of agent otel traces and metrics" />
-  <img src="/images/openlit3.png" alt="Overview of agent traces in details" />
-</Frame>
-
-### Features
-
- **Analytics Dashboard**: Monitor your Agents health and performance with detailed dashboards that track metrics, costs, and user interactions.
- **OpenTelemetry-native Observability SDK**: Vendor-neutral SDKs to send traces and metrics to your existing observability tools like Grafana, DataDog and more.
- **Cost Tracking for Custom and Fine-Tuned Models**: Tailor cost estimations for specific models using custom pricing files for precise budgeting.
- **Exceptions Monitoring Dashboard**: Quickly spot and resolve issues by tracking common exceptions and errors with a monitoring dashboard.
- **Compliance and Security**: Detect potential threats such as profanity and PII leaks.
- **Prompt Injection Detection**: Identify potential code injection and secret leaks.
- **API Keys and Secrets Management**: Securely handle your LLM API keys and secrets centrally, avoiding insecure practices.
- **Prompt Management**: Manage and version Agent prompts using PromptHub for consistent and easy access across Agents.
- **Model Playground** Test and compare different models for your CrewAI agents before deployment.
-
-## Setup Instructions
-
-<Steps>
-    <Step title="Deploy OpenLIT">
-      <Steps>
-        <Step title="Git Clone OpenLIT Repository">
-          ```shell
-          git clone git@github.com:openlit/openlit.git
-          ```
-        </Step>
-        <Step title="Start Docker Compose">
-          From the root directory of the [OpenLIT Repo](https://github.com/openlit/openlit), Run the below command:
-          ```shell
-          docker compose up -d
-          ```
-        </Step>
-      </Steps>
-    </Step>
-    <Step title="Install OpenLIT SDK">
-      ```shell
-      pip install openlit
-      ```
-    </Step>
-    <Step title="Initialize OpenLIT in Your Application">
-      Add the following two lines to your application code:
-      <Tabs>
-        <Tab title="Setup using function arguments">
-          ```python
-          import openlit
-          openlit.init(otlp_endpoint="http://127.0.0.1:4318")
-          ```
-          
-          Example Usage for monitoring a CrewAI Agent:
-    
-          ```python
-          from crewai import Agent, Task, Crew, Process
-          import openlit
-
-          openlit.init(disable_metrics=True)
-          # Define your agents
-          researcher = Agent(
-              role="Researcher",
-              goal="Conduct thorough research and analysis on AI and AI agents",
-              backstory="You're an expert researcher, specialized in technology, software engineering, AI, and startups. You work as a freelancer and are currently researching for a new client.",
-              allow_delegation=False,
-              llm='command-r'
-          )
-
-
-          # Define your task
-          task = Task(
-              description="Generate a list of 5 interesting ideas for an article, then write one captivating paragraph for each idea that showcases the potential of a full article on this topic. Return the list of ideas with their paragraphs and your notes.",
-              expected_output="5 bullet points, each with a paragraph and accompanying notes.",
-          )
-
-          # Define the manager agent
-          manager = Agent(
-              role="Project Manager",
-              goal="Efficiently manage the crew and ensure high-quality task completion",
-              backstory="You're an experienced project manager, skilled in overseeing complex projects and guiding teams to success. Your role is to coordinate the efforts of the crew members, ensuring that each task is completed on time and to the highest standard.",
-              allow_delegation=True,
-              llm='command-r'
-          )
-
-          # Instantiate your crew with a custom manager
-          crew = Crew(
-              agents=[researcher],
-              tasks=[task],
-              manager_agent=manager,
-              process=Process.hierarchical,
-          )
-
-          # Start the crew's work
-          result = crew.kickoff()
-
-          print(result)
-          ```
-        </Tab>
-        <Tab title="Setup using Environment Variables">
-
-          Add the following two lines to your application code:
-          ```python
-          import openlit
-
-          openlit.init()
-          ```
-
-          Run the following command to configure the OTEL export endpoint:
-          ```shell
-          export OTEL_EXPORTER_OTLP_ENDPOINT = "http://127.0.0.1:4318"
-          ```
-
-          Example Usage for monitoring a CrewAI Async Agent:
-
-          ```python
-          import asyncio
-          from crewai import Crew, Agent, Task
-          import openlit
-
-          openlit.init(otlp_endpoint="http://127.0.0.1:4318")
-
-          # Create an agent with code execution enabled
-          coding_agent = Agent(
-            role="Python Data Analyst",
-            goal="Analyze data and provide insights using Python",
-            backstory="You are an experienced data analyst with strong Python skills.",
-            allow_code_execution=True,
-            llm="command-r"
-          )
-
-          # Create a task that requires code execution
-          data_analysis_task = Task(
-            description="Analyze the given dataset and calculate the average age of participants. Ages: {ages}",
-            agent=coding_agent,
-            expected_output="5 bullet points, each with a paragraph and accompanying notes.",
-          )
-
-          # Create a crew and add the task
-          analysis_crew = Crew(
-            agents=[coding_agent],
-            tasks=[data_analysis_task]
-          )
-
-          # Async function to kickoff the crew asynchronously
-          async def async_crew_execution():
-              result = await analysis_crew.kickoff_async(inputs={"ages": [25, 30, 35, 40, 45]})
-              print("Crew Result:", result)
-
-          # Run the async function
-          asyncio.run(async_crew_execution())
-          ```
-        </Tab>
-      </Tabs>
-      Refer to OpenLIT [Python SDK repository](https://github.com/openlit/openlit/tree/main/sdk/python) for more advanced configurations and use cases.
-    </Step>
-    <Step title="Visualize and Analyze">
-      With the Agent Observability data now being collected and sent to OpenLIT, the next step is to visualize and analyze this data to get insights into your Agent's performance, behavior, and identify areas of improvement.
-
-      Just head over to OpenLIT at `127.0.0.1:3000` on your browser to start exploring. You can login using the default credentials
-      - **Email**: `user@openlit.io`
-      - **Password**: `openlituser`
-      
-      <Frame caption="OpenLIT Dashboard">
-        <img src="/images/openlit1.png" alt="Overview Agent usage including cost and tokens" />
-        <img src="/images/openlit2.png" alt="Overview of agent otel traces and metrics" />
-      </Frame>
-
-    </Step>
-</Steps> 
-
--- a/docs/images/openlit1.png
+++ b/docs/images/openlit1.png
--- a/docs/images/openlit2.png
+++ b/docs/images/openlit2.png
--- a/docs/images/openlit3.png
+++ b/docs/images/openlit3.png
--- a/docs/installation.mdx
+++ b/docs/installation.mdx
@@ -1,145 +1,128 @@
 ---
 title: Installation
-description: Get started with CrewAI - Install, configure, and build your first AI crew
+description: 
 icon: wrench
 ---

-<Note>
-  **Python Version Requirements**
-  
-  CrewAI requires `Python >=3.10 and <=3.13`. Here's how to check your version:
-  ```bash
-  python3 --version
-  ```
-  
-  If you need to update Python, visit [python.org/downloads](https://python.org/downloads)
-</Note>
-
-# Installing CrewAI
-
+This guide will walk you through the installation process for CrewAI and its dependencies. 
 CrewAI is a flexible and powerful AI framework that enables you to create and manage AI agents, tools, and tasks efficiently. 
-Let's get you set up! 🚀
+Let's get started! 🚀
+
+<Tip>
+    Make sure you have `Python >=3.10 <=3.13` installed on your system before you proceed.
+</Tip>

 <Steps>
    <Step title="Install CrewAI">
-        Install CrewAI with all recommended tools using either method:
-        ```shell Terminal
-        pip install 'crewai[tools]'
-        ```
-        or
-        ```shell Terminal
-        pip install crewai crewai-tools
-        ```
-
-        <Note>
-          Both methods install the core package and additional tools needed for most use cases.
-        </Note>
+    Install the main CrewAI package with the following command:
+    <CodeGroup>
+    ```shell Terminal
+    pip install crewai
+    ```
+    </CodeGroup>
+    You can also install the main CrewAI package and the tools package that include a series of helpful tools for your agents:
+    <CodeGroup>
+    ```shell Terminal
+    pip install 'crewai[tools]'
+    ```
+    </CodeGroup>
+    Alternatively, you can also use:
+    <CodeGroup>
+    ```shell Terminal
+    pip install crewai crewai-tools
+    ```
+    </CodeGroup>
    </Step>
+    <Step title="Upgrade CrewAI">
+    To upgrade CrewAI and CrewAI Tools to the latest version, run the following command
+    <CodeGroup>
+    ```shell Terminal
+    pip install --upgrade crewai crewai-tools
+    ```
+    </CodeGroup>
+    <Note>
+    1. If you're using an older version of CrewAI, you may receive a warning about using `Poetry` for dependency management. 
+      ![Error from older versions](./images/crewai-run-poetry-error.png)

-    <Step title="Upgrade CrewAI (Existing Installations Only)">
-        If you have an older version of CrewAI installed, you can upgrade it:
+    2. In this case, you'll need to run the command below to update your project. 
+      This command will migrate your project to use [UV](https://github.com/astral-sh/uv) and update the necessary files.
        ```shell Terminal
-        pip install --upgrade crewai crewai-tools
+        crewai update
        ```
+    3. After running the command above, you should see the following output:
+      ![Successfully migrated to UV](./images/crewai-update.png)

-        <Warning>
-            If you see a Poetry-related warning, you'll need to migrate to our new dependency manager:
-            ```shell Terminal
-            crewai update
-            ```
-            This will update your project to use [UV](https://github.com/astral-sh/uv), our new faster dependency manager.
-        </Warning>
-
-        <Note>
-            Skip this step if you're doing a fresh installation.
-        </Note>
+    4. You're all set! You can now proceed to the next step! 🎉
+    </Note>
    </Step>
-
-    <Step title="Verify Installation">
-        Check your installed versions:
-        ```shell Terminal
-        pip freeze | grep crewai
-        ```
-
-        You should see something like:
-        ```markdown Output
-        crewai==X.X.X
-        crewai-tools==X.X.X
-        ```
-        <Check>Installation successful! You're ready to create your first crew.</Check>
+    <Step title="Verify the installation">
+    To verify that `crewai` and `crewai-tools` are installed correctly, run the following command
+    <CodeGroup>
+    ```shell Terminal
+    pip freeze | grep crewai
+    ```
+    </CodeGroup>
+    You should see the version number of `crewai` and `crewai-tools`.
+    <CodeGroup>
+    ```markdown Version
+    crewai==X.X.X
+    crewai-tools==X.X.X
+    ```
+    </CodeGroup>
+    If you see the version number, then the installation was successful! 🎉
    </Step>
 </Steps>

-# Creating a New Project
+## Create a new CrewAI project

-<Info>
-  We recommend using the YAML Template scaffolding for a structured approach to defining agents and tasks.
-</Info>
+The next step is to create a new CrewAI project. 
+We recommend using the YAML Template scaffolding to get started as it provides a structured approach to defining agents and tasks.

 <Steps>
-  <Step title="Generate Project Structure">
-    Run the CrewAI CLI command:
-    ```shell Terminal
-    crewai create crew <project_name>
-    ```
+  <Step title="Create a new CrewAI project using the YAML Template Configuration">
+  To create a new CrewAI project, run the following CLI (Command Line Interface) command:
+  <CodeGroup>
+      ```shell Terminal
+      crewai create crew <project_name>
+      ```
+    </CodeGroup>
+  This command creates a new project folder with the following structure:
+    | File/Directory          | Description                                      |
+    |:------------------------|:-------------------------------------------------|
+    | `my_project/`           | Root directory of the project                    |
+    | ├── `.gitignore`        | Specifies files and directories to ignore in Git |
+    | ├── `pyproject.toml`    | Project configuration and dependencies           |
+    | ├── `README.md`         | Project documentation                            |
+    | ├── `.env`              | Environment variables                            |
+    | └── `src/`              | Source code directory                            |
+    | &nbsp;&nbsp;&nbsp;&nbsp;└── `my_project/` | Main application package                      |
+    | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── `__init__.py` | Marks the directory as a Python package     |
+    | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── `main.py`     | Main application script                    |
+    | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── `crew.py`     | Crew-related functionalities                |
+    | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── `tools/`      | Custom tools directory                      |
+    | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;│   ├── `custom_tool.py` | Custom tool implementation              |
+    | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;│   └── `__init__.py`    | Marks tools directory as a package       |
+    | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;└── `config/`     | Configuration files directory               |
+    | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;├── `agents.yaml`  | Agent configurations                    |
+    | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;└── `tasks.yaml`   | Task configurations                      |

-    This creates a new project with the following structure:
-    <Frame>
-    ```
-    my_project/
-    ├── .gitignore
-    ├── pyproject.toml
-    ├── README.md
-    ├── .env
-    └── src/
-        └── my_project/
-            ├── __init__.py
-            ├── main.py
-            ├── crew.py
-            ├── tools/
-            │   ├── custom_tool.py
-            │   └── __init__.py
-            └── config/
-                ├── agents.yaml
-                └── tasks.yaml
-    ```
-    </Frame>
+  You can now start developing your crew by editing the files in the `src/my_project` folder. 
+  The `main.py` file is the entry point of the project, the `crew.py` file is where you define your crew, the `agents.yaml` file is where you define your agents, 
+  and the `tasks.yaml` file is where you define your tasks.
  </Step>   
-
-  <Step title="Customize Your Project">
-    Your project will contain these essential files:
-
-    | File | Purpose |
-    | --- | --- |
-    | `agents.yaml` | Define your AI agents and their roles |
-    | `tasks.yaml` | Set up agent tasks and workflows |
-    | `.env` | Store API keys and environment variables |
-    | `main.py` | Project entry point and execution flow |
-    | `crew.py` | Crew orchestration and coordination |
-    | `tools/` | Directory for custom agent tools |
-
-    <Tip>
-      Start by editing `agents.yaml` and `tasks.yaml` to define your crew's behavior.
-      Keep sensitive information like API keys in `.env`.
-    </Tip>
+  <Step title="Customize your project">
+  To customize your project, you can:
+    - Modify `src/my_project/config/agents.yaml` to define your agents.
+    - Modify `src/my_project/config/tasks.yaml` to define your tasks.
+    - Modify `src/my_project/crew.py` to add your own logic, tools, and specific arguments.
+    - Modify `src/my_project/main.py` to add custom inputs for your agents and tasks.
+    - Add your environment variables into the `.env` file.
  </Step>
 </Steps>

-## Next Steps
+## Next steps

-<CardGroup cols={2}>
-  <Card
-    title="Build Your First Agent"
-    icon="code"
-    href="/quickstart"
-  >
-    Follow our quickstart guide to create your first CrewAI agent and get hands-on experience.
-  </Card>
-  <Card
-    title="Join the Community"
-    icon="comments"
-    href="https://community.crewai.com"
-  >
-    Connect with other developers, get help, and share your CrewAI experiences.
-  </Card>
-</CardGroup>
+Now that you have installed `crewai` and `crewai-tools`, you're ready to spin up your first crew!
+
+- 👨‍💻 Build your first agent with CrewAI by following the [Quickstart](/quickstart) guide.
+- 💬 Join the [Community](https://community.crewai.com) to get help and share your feedback.
--- a/docs/introduction.mdx
+++ b/docs/introduction.mdx
@@ -1,85 +1,49 @@
 ---
 title: Introduction
-description: Build AI agent teams that work together to tackle complex tasks
+description: Welcome to CrewAI docs!
 icon: handshake
 ---

 # What is CrewAI?

-**CrewAI is a cutting-edge framework for orchestrating autonomous AI agents.** 
+**CrewAI is a cutting-edge Python framework for orchestrating role-playing, autonomous AI agents.**

-CrewAI enables you to create AI teams where each agent has specific roles, tools, and goals, working together to accomplish complex tasks.
+By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.

-Think of it as assembling your dream team - each member (agent) brings unique skills and expertise, collaborating seamlessly to achieve your objectives.
+<Frame caption="CrewAI Mindmap">
+  <img src="crewAI-mindmap.png" alt="CrewAI Mindmap" />
+</Frame>  

-## How CrewAI Works
+## Why CrewAI?
+- 🤼‍♀️ **Role-Playing Agents**: Agents can take on different roles and personas to better understand and interact with complex systems.
+- 🤖 **Autonomous Decision Making**: Agents can make decisions autonomously based on the given context and available tools.
+- 🤝 **Seamless Collaboration**: Agents can work together seamlessly, sharing information and resources to achieve common goals.
+- 🧠 **Complex Task Tackling**: CrewAI is designed to tackle complex tasks, such as multi-step workflows, decision making, and problem solving.

-<Note>
-  Just like a company has departments (Sales, Engineering, Marketing) working together under leadership to achieve business goals, CrewAI helps you create an organization of AI agents with specialized roles collaborating to accomplish complex tasks.
-</Note>
-
-<Frame caption="CrewAI Framework Overview">
-  <img src="crewAI-mindmap.png" alt="CrewAI Framework Overview" />
-</Frame>
-
-| Component | Description | Key Features |
-|:----------|:-----------:|:------------|
-| **Crew** | The top-level organization | • Manages AI agent teams<br/>• Oversees workflows<br/>• Ensures collaboration<br/>• Delivers outcomes |
-| **AI Agents** | Specialized team members | • Have specific roles (researcher, writer)<br/>• Use designated tools<br/>• Can delegate tasks<br/>• Make autonomous decisions |
-| **Process** | Workflow management system | • Defines collaboration patterns<br/>• Controls task assignments<br/>• Manages interactions<br/>• Ensures efficient execution |
-| **Tasks** | Individual assignments | • Have clear objectives<br/>• Use specific tools<br/>• Feed into larger process<br/>• Produce actionable results |
-
-### How It All Works Together
-
-1. The **Crew** organizes the overall operation
-2. **AI Agents** work on their specialized tasks
-3. The **Process** ensures smooth collaboration
-4. **Tasks** get completed to achieve the goal
-
-## Key Features
+# Get Started with CrewAI

 <CardGroup cols={2}>
-  <Card title="Role-Based Agents" icon="users">
-    Create specialized agents with defined roles, expertise, and goals - from researchers to analysts to writers
-  </Card>
-  <Card title="Flexible Tools" icon="screwdriver-wrench">
-    Equip agents with custom tools and APIs to interact with external services and data sources
-  </Card>
-  <Card title="Intelligent Collaboration" icon="people-arrows">
-    Agents work together, sharing insights and coordinating tasks to achieve complex objectives
-  </Card>
-  <Card title="Task Management" icon="list-check">
-    Define sequential or parallel workflows, with agents automatically handling task dependencies
-  </Card>
-</CardGroup>
-
-## Why Choose CrewAI?
-
- 🧠 **Autonomous Operation**: Agents make intelligent decisions based on their roles and available tools
- 📝 **Natural Interaction**: Agents communicate and collaborate like human team members
- 🛠️ **Extensible Design**: Easy to add new tools, roles, and capabilities
- 🚀 **Production Ready**: Built for reliability and scalability in real-world applications
-
-<CardGroup cols={3}>
  <Card
-    title="Install CrewAI"
-    icon="wrench"
-    href="/installation"
+  title="Quickstart"
+  color="#F3A78B"
+  href="quickstart"
+  icon="terminal"
+    iconType="solid"
  >
-    Get started with CrewAI in your development environment.
-  </Card>
-  <Card
-    title="Quick Start"
-    icon="bolt"
-    href="/quickstart"
-  >
-    Follow our quickstart guide to create your first CrewAI agent and get hands-on experience.
+    Getting started with CrewAI 
  </Card>
  <Card
    title="Join the Community"
-    icon="comments"
+    color="#F3A78B"
    href="https://community.crewai.com"
-  >
-    Connect with other developers, get help, and share your CrewAI experiences.
-  </Card>
-</CardGroup>
+    icon="comment-question"
+      iconType="duotone"
+    >
+      Join the CrewAI community and get help with your project!
+    </Card>
+</CardGroup>
+
+## Next Step
+
+- [Install CrewAI](/installation) to get started with your first agent.
+
--- a/docs/mint.json
+++ b/docs/mint.json
@@ -99,8 +99,7 @@
        "how-to/replay-tasks-from-latest-crew-kickoff",
        "how-to/conditional-tasks",
        "how-to/agentops-observability",
-        "how-to/langtrace-observability",
-        "how-to/openlit-observability"
+        "how-to/langtrace-observability"
      ]
    },
    {
--- a/docs/quickstart.mdx
+++ b/docs/quickstart.mdx
@@ -349,28 +349,11 @@ Replace `<task_id>` with the ID of the task you want to replay.
 If you need to reset the memory of your crew before running it again, you can do so by calling the reset memory feature:

 ```shell
-crewai reset-memories --all
+crewai reset-memory
 ```

 This will clear the crew's memory, allowing for a fresh start.

 ## Deploying Your Project

-The easiest way to deploy your crew is through CrewAI Enterprise, where you can deploy your crew in a few clicks.
-
-<CardGroup cols={2}>
-  <Card
-    title="Deploy on Enterprise"
-    icon="rocket"
-    href="http://app.crewai.com"
-  >
-    Get started with CrewAI Enterprise and deploy your crew in a production environment with just a few clicks.
-  </Card>
-  <Card
-    title="Join the Community"
-    icon="comments"
-    href="https://community.crewai.com"
-  >
-    Join our open source community to discuss ideas, share your projects, and connect with other CrewAI developers.
-  </Card>
-</CardGroup>
+The easiest way to deploy your crew is through [CrewAI Enterprise](http://app.crewai.com/), where you can deploy your crew in a few clicks.
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -152,7 +152,6 @@ nav:
    - Conditional Tasks: 'how-to/Conditional-Tasks.md'
    - Agent Monitoring with AgentOps: 'how-to/AgentOps-Observability.md'
    - Agent Monitoring with LangTrace: 'how-to/Langtrace-Observability.md'
-    - Agent Monitoring with OpenLIT: 'how-to/openlit-Observability.md'
  - Tools Docs:
    - Browserbase Web Loader: 'tools/BrowserbaseLoadTool.md'
    - Code Docs RAG Search: 'tools/CodeDocsSearchTool.md'
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "crewai"
-version = "0.85.0"
+version = "0.83.0"
 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"
--- a/src/crewai/init.py
+++ b/src/crewai/init.py
@@ -16,7 +16,7 @@ warnings.filterwarnings(
    category=UserWarning,
    module="pydantic.main",
 )
-__version__ = "0.85.0"
+__version__ = "0.83.0"
 __all__ = [
    "Agent",
    "Crew",
--- a/src/crewai/agent.py
+++ b/src/crewai/agent.py
@@ -1,7 +1,7 @@
 import os
 import shutil
 import subprocess
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import Any, List, Literal, Optional, Union, Dict

 from pydantic import Field, InstanceOf, PrivateAttr, model_validator

@@ -9,10 +9,9 @@ from crewai.agents import CacheHandler
 from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.agents.crew_agent_executor import CrewAgentExecutor
 from crewai.cli.constants import ENV_VARS
+from crewai.llm import LLM
 from crewai.knowledge.knowledge import Knowledge
 from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
-from crewai.knowledge.utils.knowledge_utils import extract_knowledge_context
-from crewai.llm import LLM
 from crewai.memory.contextual.contextual_memory import ContextualMemory
 from crewai.task import Task
 from crewai.tools import BaseTool
@@ -22,6 +21,7 @@ from crewai.utilities.constants import TRAINED_AGENTS_DATA_FILE, TRAINING_DATA_F
 from crewai.utilities.converter import generate_model_description
 from crewai.utilities.token_counter_callback import TokenCalcHandler
 from crewai.utilities.training_handler import CrewTrainingHandler
+from crewai.knowledge.utils.knowledge_utils import extract_knowledge_context


 def mock_agent_ops_provider():
--- a/src/crewai/agents/crew_agent_executor.py
+++ b/src/crewai/agents/crew_agent_executor.py
@@ -1,6 +1,5 @@
 import json
 import re
-from dataclasses import dataclass
 from typing import Any, Dict, List, Union

 from crewai.agents.agent_builder.base_agent import BaseAgent
@@ -13,7 +12,6 @@ from crewai.agents.parser import (
    OutputParserException,
 )
 from crewai.agents.tools_handler import ToolsHandler
-from crewai.tools.base_tool import BaseTool
 from crewai.tools.tool_usage import ToolUsage, ToolUsageErrorException
 from crewai.utilities import I18N, Printer
 from crewai.utilities.constants import TRAINING_DATA_FILE
@@ -24,12 +22,6 @@ from crewai.utilities.logger import Logger
 from crewai.utilities.training_handler import CrewTrainingHandler


-@dataclass
-class ToolResult:
-    result: Any
-    result_as_answer: bool
-
-
 class CrewAgentExecutor(CrewAgentExecutorMixin):
    _logger: Logger = Logger()

@@ -41,7 +33,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
        agent: BaseAgent,
        prompt: dict[str, str],
        max_iter: int,
-        tools: List[BaseTool],
+        tools: List[Any],
        tools_names: str,
        stop_words: List[str],
        tools_description: str,
@@ -78,9 +70,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
        self.iterations = 0
        self.log_error_after = 3
        self.have_forced_answer = False
-        self.tool_name_to_tool_map: Dict[str, BaseTool] = {
-            tool.name: tool for tool in self.tools
-        }
+        self.name_to_tool_map = {tool.name: tool for tool in self.tools}
        if self.llm.stop:
            self.llm.stop = list(set(self.llm.stop + self.stop))
        else:
@@ -150,17 +140,9 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                    formatted_answer = self._format_answer(answer)

                    if isinstance(formatted_answer, AgentAction):
-                        tool_result = self._execute_tool_and_check_finality(
-                            formatted_answer
-                        )
-                        formatted_answer.text += f"\nObservation: {tool_result.result}"
-                        formatted_answer.result = tool_result.result
-                        if tool_result.result_as_answer:
-                            return AgentFinish(
-                                thought="",
-                                output=tool_result.result,
-                                text=formatted_answer.text,
-                            )
+                        action_result = self._use_tool(formatted_answer)
+                        formatted_answer.text += f"\nObservation: {action_result}"
+                        formatted_answer.result = action_result
                        self._show_logs(formatted_answer)

                    if self.step_callback:
@@ -257,7 +239,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                    content=f"\033[95m## Final Answer:\033[00m \033[92m\n{formatted_answer.output}\033[00m\n\n"
                )

-    def _execute_tool_and_check_finality(self, agent_action: AgentAction) -> ToolResult:
+    def _use_tool(self, agent_action: AgentAction) -> Any:
        tool_usage = ToolUsage(
            tools_handler=self.tools_handler,
            tools=self.tools,
@@ -273,25 +255,19 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):

        if isinstance(tool_calling, ToolUsageErrorException):
            tool_result = tool_calling.message
-            return ToolResult(result=tool_result, result_as_answer=False)
        else:
            if tool_calling.tool_name.casefold().strip() in [
-                name.casefold().strip() for name in self.tool_name_to_tool_map
+                name.casefold().strip() for name in self.name_to_tool_map
            ] or tool_calling.tool_name.casefold().replace("_", " ") in [
-                name.casefold().strip() for name in self.tool_name_to_tool_map
+                name.casefold().strip() for name in self.name_to_tool_map
            ]:
                tool_result = tool_usage.use(tool_calling, agent_action.text)
-                tool = self.tool_name_to_tool_map.get(tool_calling.tool_name)
-                if tool:
-                    return ToolResult(
-                        result=tool_result, result_as_answer=tool.result_as_answer
-                    )
            else:
                tool_result = self._i18n.errors("wrong_tool_name").format(
                    tool=tool_calling.tool_name,
                    tools=", ".join([tool.name.casefold() for tool in self.tools]),
                )
-        return ToolResult(result=tool_result, result_as_answer=False)
+        return tool_result

    def _summarize_messages(self) -> None:
        messages_groups = []
@@ -357,9 +333,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(
--- a/src/crewai/cli/create_crew.py
+++ b/src/crewai/cli/create_crew.py
@@ -39,7 +39,6 @@ def create_folder_structure(name, parent_folder=None):

    folder_path.mkdir(parents=True)
    (folder_path / "tests").mkdir(exist_ok=True)
-    (folder_path / "knowledge").mkdir(exist_ok=True)
    if not parent_folder:
        (folder_path / "src" / folder_name).mkdir(parents=True)
        (folder_path / "src" / folder_name / "tools").mkdir(parents=True)
@@ -53,14 +52,7 @@ def copy_template_files(folder_path, name, class_name, parent_folder):
    templates_dir = package_dir / "templates" / "crew"

    root_template_files = (
-        [
-            ".gitignore",
-            "pyproject.toml",
-            "README.md",
-            "knowledge/user_preference.txt",
-        ]
-        if not parent_folder
-        else []
+        [".gitignore", "pyproject.toml", "README.md"] if not parent_folder else []
    )
    tools_template_files = ["tools/custom_tool.py", "tools/__init__.py"]
    config_template_files = ["config/agents.yaml", "config/tasks.yaml"]
@@ -176,9 +168,7 @@ def create_crew(name, provider=None, skip_provider=False, parent_folder=None):
    templates_dir = package_dir / "templates" / "crew"

    root_template_files = (
-        [".gitignore", "pyproject.toml", "README.md", "knowledge/user_preference.txt"]
-        if not parent_folder
-        else []
+        [".gitignore", "pyproject.toml", "README.md"] if not parent_folder else []
    )
    tools_template_files = ["tools/custom_tool.py", "tools/__init__.py"]
    config_template_files = ["config/agents.yaml", "config/tasks.yaml"]
--- a/src/crewai/cli/templates/crew/crew.py
+++ b/src/crewai/cli/templates/crew/crew.py
@@ -1,9 +1,8 @@
 from crewai import Agent, Crew, Process, Task
 from crewai.project import CrewBase, agent, crew, task, before_kickoff, after_kickoff
+
 # Uncomment the following line to use an example of a custom tool
 # from {{folder_name}}.tools.custom_tool import MyCustomTool
-# Uncomment the following line to use an example of a knowledge source
-# from crewai.knowledge.source.text_file_knowledge_source import TextFileKnowledgeSource

 # Check our tools documentations for more information on how to use them
 # from crewai_tools import SerperDevTool
@@ -58,20 +57,10 @@ class {{crew_name}}():
 	@crew
 	def crew(self) -> Crew:
 		"""Creates the {{crew_name}} crew"""
-		# You can add knowledge sources here
-		# knowledge_path = "user_preference.txt"
-		# sources = [
-		# 	TextFileKnowledgeSource(
-		# 		file_path="knowledge/user_preference.txt",
-		# 		metadata={"preference": "personal"}
-		# 	),
-		# ]
-
 		return Crew(
 			agents=self.agents, # Automatically created by the @agent decorator
 			tasks=self.tasks, # Automatically created by the @task decorator
 			process=Process.sequential,
 			verbose=True,
 			# process=Process.hierarchical, # In case you wanna use that instead https://docs.crewai.com/how-to/Hierarchical/
-			# knowledge_sources=sources, # In the case you want to add knowledge sources
 		)
--- a/src/crewai/cli/templates/crew/knowledge/user_preference.txt
+++ b/src/crewai/cli/templates/crew/knowledge/user_preference.txt
@@ -1,4 +0,0 @@
-User name is John Doe.
-User is an AI Engineer.
-User is interested in AI Agents.
-User is based in San Francisco, California.
--- a/src/crewai/cli/templates/crew/pyproject.toml
+++ b/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.85.0,<1.0.0"
+    "crewai[tools]>=0.83.0,<1.0.0"
 ]

 [project.scripts]
--- a/src/crewai/cli/templates/flow/pyproject.toml
+++ b/src/crewai/cli/templates/flow/pyproject.toml
@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<=3.13"
 dependencies = [
-    "crewai[tools]>=0.85.0,<1.0.0",
+    "crewai[tools]>=0.83.0,<1.0.0",
 ]

 [project.scripts]
--- a/src/crewai/cli/templates/pipeline/pyproject.toml
+++ b/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.85.0,<1.0.0" }
+crewai = { extras = ["tools"], version = ">=0.83.0,<1.0.0" }
 asyncio = "*"

 [tool.poetry.scripts]
--- a/src/crewai/cli/templates/pipeline_router/pyproject.toml
+++ b/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.85.0,<1.0.0"
+    "crewai[tools]>=0.83.0,<1.0.0"
 ]

 [project.scripts]
--- a/src/crewai/cli/templates/tool/pyproject.toml
+++ b/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.85.0"
+    "crewai[tools]>=0.83.0"
 ]

--- a/src/crewai/knowledge/source/base_file_knowledge_source.py
+++ b/src/crewai/knowledge/source/base_file_knowledge_source.py
@@ -1,72 +1,36 @@
-from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Union, List, Dict, Any
+from typing import Union, List

 from pydantic import Field

 from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
-from crewai.utilities.logger import Logger
+from typing import Dict, Any
 from crewai.knowledge.storage.knowledge_storage import KnowledgeStorage
-from crewai.utilities.constants import KNOWLEDGE_DIRECTORY


-class BaseFileKnowledgeSource(BaseKnowledgeSource, ABC):
+class BaseFileKnowledgeSource(BaseKnowledgeSource):
    """Base class for knowledge sources that load content from files."""

-    _logger: Logger = Logger(verbose=True)
-    file_path: Union[Path, List[Path], str, List[str]] = Field(
-        ..., description="The path to the file"
-    )
+    file_path: Union[Path, List[Path]] = Field(...)
    content: Dict[Path, str] = Field(init=False, default_factory=dict)
    storage: KnowledgeStorage = Field(default_factory=KnowledgeStorage)
-    safe_file_paths: List[Path] = Field(default_factory=list)

    def model_post_init(self, _):
        """Post-initialization method to load content."""
-        self.safe_file_paths = self._process_file_paths()
-        self.validate_paths()
        self.content = self.load_content()

-    @abstractmethod
    def load_content(self) -> Dict[Path, str]:
-        """Load and preprocess file content. Should be overridden by subclasses. Assume that the file path is relative to the project root in the knowledge directory."""
-        pass
+        """Load and preprocess file content. Should be overridden by subclasses."""
+        paths = [self.file_path] if isinstance(self.file_path, Path) else self.file_path

-    def validate_paths(self):
-        """Validate the paths."""
-        for path in self.safe_file_paths:
+        for path in paths:
            if not path.exists():
-                self._logger.log(
-                    "error",
-                    f"File not found: {path}. Try adding sources to the knowledge directory. If its inside the knowledge directory, use the relative path.",
-                    color="red",
-                )
                raise FileNotFoundError(f"File not found: {path}")
            if not path.is_file():
-                self._logger.log(
-                    "error",
-                    f"Path is not a file: {path}",
-                    color="red",
-                )
+                raise ValueError(f"Path is not a file: {path}")
+        return {}

    def save_documents(self, metadata: Dict[str, Any]):
        """Save the documents to the storage."""
        chunk_metadatas = [metadata.copy() for _ in self.chunks]
        self.storage.save(self.chunks, chunk_metadatas)
-
-    def convert_to_path(self, path: Union[Path, str]) -> Path:
-        """Convert a path to a Path object."""
-        return Path(KNOWLEDGE_DIRECTORY + "/" + path) if isinstance(path, str) else path
-
-    def _process_file_paths(self) -> List[Path]:
-        """Convert file_path to a list of Path objects."""
-        paths = (
-            [self.file_path]
-            if isinstance(self.file_path, (str, Path))
-            else self.file_path
-        )
-
-        if not isinstance(paths, list):
-            raise ValueError("file_path must be a Path, str, or a list of these types")
-
-        return [self.convert_to_path(path) for path in paths]
--- a/src/crewai/knowledge/source/csv_knowledge_source.py
+++ b/src/crewai/knowledge/source/csv_knowledge_source.py
@@ -10,15 +10,19 @@ class CSVKnowledgeSource(BaseFileKnowledgeSource):

    def load_content(self) -> Dict[Path, str]:
        """Load and preprocess CSV file content."""
-        content_dict = {}
-        for file_path in self.safe_file_paths:
-            with open(file_path, "r", encoding="utf-8") as csvfile:
-                reader = csv.reader(csvfile)
-                content = ""
-                for row in reader:
-                    content += " ".join(row) + "\n"
-                content_dict[file_path] = content
-        return content_dict
+        super().load_content()  # Validate the file path
+
+        file_path = (
+            self.file_path[0] if isinstance(self.file_path, list) else self.file_path
+        )
+        file_path = Path(file_path) if isinstance(file_path, str) else file_path
+
+        with open(file_path, "r", encoding="utf-8") as csvfile:
+            reader = csv.reader(csvfile)
+            content = ""
+            for row in reader:
+                content += " ".join(row) + "\n"
+        return {file_path: content}

    def add(self) -> None:
        """
--- a/src/crewai/knowledge/source/excel_knowledge_source.py
+++ b/src/crewai/knowledge/source/excel_knowledge_source.py
@@ -8,15 +8,17 @@ class ExcelKnowledgeSource(BaseFileKnowledgeSource):

    def load_content(self) -> Dict[Path, str]:
        """Load and preprocess Excel file content."""
+        super().load_content()  # Validate the file path
        pd = self._import_dependencies()

-        content_dict = {}
-        for file_path in self.safe_file_paths:
-            file_path = self.convert_to_path(file_path)
-            df = pd.read_excel(file_path)
-            content = df.to_csv(index=False)
-            content_dict[file_path] = content
-        return content_dict
+        if isinstance(self.file_path, list):
+            file_path = self.file_path[0]
+        else:
+            file_path = self.file_path
+
+        df = pd.read_excel(file_path)
+        content = df.to_csv(index=False)
+        return {file_path: content}

    def _import_dependencies(self):
        """Dynamically import dependencies."""
--- a/src/crewai/knowledge/source/json_knowledge_source.py
+++ b/src/crewai/knowledge/source/json_knowledge_source.py
@@ -10,9 +10,11 @@ class JSONKnowledgeSource(BaseFileKnowledgeSource):

    def load_content(self) -> Dict[Path, str]:
        """Load and preprocess JSON file content."""
+        super().load_content()  # Validate the file path
+        paths = [self.file_path] if isinstance(self.file_path, Path) else self.file_path
+
        content: Dict[Path, str] = {}
-        for path in self.safe_file_paths:
-            path = self.convert_to_path(path)
+        for path in paths:
            with open(path, "r", encoding="utf-8") as json_file:
                data = json.load(json_file)
            content[path] = self._json_to_text(data)
--- a/src/crewai/knowledge/source/pdf_knowledge_source.py
+++ b/src/crewai/knowledge/source/pdf_knowledge_source.py
@@ -9,13 +9,14 @@ class PDFKnowledgeSource(BaseFileKnowledgeSource):

    def load_content(self) -> Dict[Path, str]:
        """Load and preprocess PDF file content."""
+        super().load_content()  # Validate the file paths
        pdfplumber = self._import_pdfplumber()

+        paths = [self.file_path] if isinstance(self.file_path, Path) else self.file_path
        content = {}

-        for path in self.safe_file_paths:
+        for path in paths:
            text = ""
-            path = self.convert_to_path(path)
            with pdfplumber.open(path) as pdf:
                for page in pdf.pages:
                    page_text = page.extract_text()
--- a/src/crewai/knowledge/source/text_file_knowledge_source.py
+++ b/src/crewai/knowledge/source/text_file_knowledge_source.py
@@ -9,11 +9,12 @@ class TextFileKnowledgeSource(BaseFileKnowledgeSource):

    def load_content(self) -> Dict[Path, str]:
        """Load and preprocess text file content."""
+        super().load_content()
+        paths = [self.file_path] if isinstance(self.file_path, Path) else self.file_path
        content = {}
-        for path in self.safe_file_paths:
-            path = self.convert_to_path(path)
-            with open(path, "r", encoding="utf-8") as f:
-                content[path] = f.read()
+        for path in paths:
+            with path.open("r", encoding="utf-8") as f:
+                content[path] = f.read()  # type: ignore
        return content

    def add(self) -> None:
--- a/src/crewai/memory/entity/entity_memory.py
+++ b/src/crewai/memory/entity/entity_memory.py
@@ -10,7 +10,7 @@ class EntityMemory(Memory):
    Inherits from the Memory class.
    """

-    def __init__(self, crew=None, embedder_config=None, storage=None, path=None):
+    def __init__(self, crew=None, embedder_config=None, storage=None):
        if hasattr(crew, "memory_config") and crew.memory_config is not None:
            self.memory_provider = crew.memory_config.get("provider")
        else:
@@ -33,7 +33,6 @@ class EntityMemory(Memory):
                    allow_reset=True,
                    embedder_config=embedder_config,
                    crew=crew,
-                    path=path,
                )
            )
        super().__init__(storage)
--- a/src/crewai/memory/long_term/long_term_memory.py
+++ b/src/crewai/memory/long_term/long_term_memory.py
@@ -14,9 +14,8 @@ class LongTermMemory(Memory):
    LongTermMemoryItem instances.
    """

-    def __init__(self, storage=None, path=None):
-        if not storage:
-            storage = LTMSQLiteStorage(db_path=path) if path else LTMSQLiteStorage()
+    def __init__(self, storage=None):
+        storage = storage if storage else LTMSQLiteStorage()
        super().__init__(storage)

    def save(self, item: LongTermMemoryItem) -> None:  # type: ignore # BUG?: Signature of "save" incompatible with supertype "Memory"
--- a/src/crewai/memory/short_term/short_term_memory.py
+++ b/src/crewai/memory/short_term/short_term_memory.py
@@ -13,7 +13,7 @@ class ShortTermMemory(Memory):
    MemoryItem instances.
    """

-    def __init__(self, crew=None, embedder_config=None, storage=None, path=None):
+    def __init__(self, crew=None, embedder_config=None, storage=None):
        if hasattr(crew, "memory_config") and crew.memory_config is not None:
            self.memory_provider = crew.memory_config.get("provider")
        else:
@@ -32,7 +32,7 @@ class ShortTermMemory(Memory):
                storage
                if storage
                else RAGStorage(
-                    type="short_term", embedder_config=embedder_config, crew=crew, path=path
+                    type="short_term", embedder_config=embedder_config, crew=crew
                )
            )
        super().__init__(storage)
--- a/src/crewai/memory/storage/rag_storage.py
+++ b/src/crewai/memory/storage/rag_storage.py
@@ -37,7 +37,7 @@ class RAGStorage(BaseRAGStorage):

    app: ClientAPI | None = None

-    def __init__(self, type, allow_reset=True, embedder_config=None, crew=None, path=None):
+    def __init__(self, type, allow_reset=True, embedder_config=None, crew=None):
        super().__init__(type, allow_reset, embedder_config, crew)
        agents = crew.agents if crew else []
        agents = [self._sanitize_role(agent.role) for agent in agents]
@@ -47,7 +47,6 @@ class RAGStorage(BaseRAGStorage):
        self.type = type

        self.allow_reset = allow_reset
-        self.path = path
        self._initialize_app()

    def _set_embedder_config(self):
@@ -60,7 +59,7 @@ class RAGStorage(BaseRAGStorage):

        self._set_embedder_config()
        chroma_client = chromadb.PersistentClient(
-            path=self.path if self.path else f"{db_storage_path()}/{self.type}/{self.agents}",
+            path=f"{db_storage_path()}/{self.type}/{self.agents}",
            settings=Settings(allow_reset=self.allow_reset),
        )

--- a/src/crewai/tools/base_tool.py
+++ b/src/crewai/tools/base_tool.py
@@ -73,7 +73,6 @@ class BaseTool(BaseModel, ABC):
            description=self.description,
            args_schema=self.args_schema,
            func=self._run,
-            result_as_answer=self.result_as_answer,
        )

    @classmethod
--- a/src/crewai/tools/structured_tool.py
+++ b/src/crewai/tools/structured_tool.py
@@ -22,7 +22,6 @@ class CrewStructuredTool:
        description: str,
        args_schema: type[BaseModel],
        func: Callable[..., Any],
-        result_as_answer: bool = False,
    ) -> None:
        """Initialize the structured tool.

@@ -31,14 +30,12 @@ class CrewStructuredTool:
            description: A description of what the tool does
            args_schema: The pydantic model for the tool's arguments
            func: The function to run when the tool is called
-            result_as_answer: Whether to return the output directly
        """
        self.name = name
        self.description = description
        self.args_schema = args_schema
        self.func = func
        self._logger = Logger()
-        self.result_as_answer = result_as_answer

        # Validate the function signature matches the schema
        self._validate_function_signature()
@@ -101,7 +98,6 @@ class CrewStructuredTool:
            description=description,
            args_schema=schema,
            func=func,
-            result_as_answer=return_direct,
        )

    @staticmethod
--- a/src/crewai/utilities/constants.py
+++ b/src/crewai/utilities/constants.py
@@ -1,4 +1,3 @@
 TRAINING_DATA_FILE = "training_data.pkl"
 TRAINED_AGENTS_DATA_FILE = "trained_agents_data.pkl"
 DEFAULT_SCORE_THRESHOLD = 0.35
-KNOWLEDGE_DIRECTORY = "knowledge"
--- a/uv.lock
+++ b/uv.lock
@@ -608,7 +608,7 @@ wheels = [

 [[package]]
 name = "crewai"
-version = "0.85.0"
+version = "0.83.0"
 source = { editable = "." }
 dependencies = [
    { name = "appdirs" },
Author	SHA1	Message	Date
Lorenze Jay	ea6d04a9d9	linted	2024-11-27 11:30:56 -08:00
Lorenze Jay	a81200a020	rm unused	2024-11-27 11:30:21 -08:00
Lorenze Jay	61fe1c69d9	fix test	2024-11-27 11:27:27 -08:00
Lorenze Jay	3eb52dad9f	rm cassette for knowledge_sources test as its a mock and update agent doc string	2024-11-27 10:50:48 -08:00
Lorenze Jay	87e9a0c91a	fix test	2024-11-27 10:47:03 -08:00
Lorenze Jay	24d2d9cd55	Merge branch 'main' of github.com:crewAIInc/crewAI into add/agent-specific-knowledge	2024-11-27 10:40:55 -08:00
Lorenze Jay	85b8d2af6f	fix docs	2024-11-27 10:39:05 -08:00
Lorenze Jay	5b03d6c8bc	fixes from discussion	2024-11-27 10:38:20 -08:00
Lorenze Jay	3f87bf3ada	added test	2024-11-26 12:06:48 -08:00
Lorenze Jay	b3deac2a2b	Merge branch 'main' of github.com:crewAIInc/crewAI into add/agent-specific-knowledge	2024-11-26 12:01:00 -08:00
Lorenze Jay	95f2e9eded	Merge branch 'main' of github.com:crewAIInc/crewAI into add/agent-specific-knowledge	2024-11-26 11:57:15 -08:00
Lorenze Jay	707c50b833	added from suggestions	2024-11-26 11:52:57 -08:00
Lorenze Jay	a21feda2cc	added doc	2024-11-25 16:20:51 -08:00
Lorenze Jay	15d549e157	linted	2024-11-25 15:32:40 -08:00
Lorenze Jay	74d681f3af	Merge branch 'main' of github.com:crewAIInc/crewAI into add/agent-specific-knowledge	2024-11-25 15:29:53 -08:00
Lorenze Jay	6c6c60318c	added knowledge to agent level	2024-11-25 15:28:42 -08:00