drop record new episodes

* Suppressed userWarnings from litellm pydantic issues

* change litellm version

* Fix failling ollama tasks

.editorconfig

@@ -0,0 +1,14 @@
+# .editorconfig
+root = true
+
+# All files
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+# Python files
+[*.py]
+indent_style = space
+indent_size = 2

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,115 @@
+name: Bug report
+description: Create a report to help us improve CrewAI
+title: "[BUG]"
+labels: ["bug"]
+assignees: []
+body:
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: Provide a clear and concise description of what the bug is.
+    validations:
+      required: true
+  - type: textarea
+    id: steps-to-reproduce
+    attributes:
+      label: Steps to Reproduce
+      description: Provide a step-by-step process to reproduce the behavior.
+      placeholder: |
+        1. Go to '...'
+        2. Click on '....'
+        3. Scroll down to '....'
+        4. See error
+    validations:
+      required: true
+  - type: textarea
+    id: expected-behavior
+    attributes:
+      label: Expected behavior
+      description: A clear and concise description of what you expected to happen.
+    validations:
+      required: true
+  - type: textarea
+    id: screenshots-code
+    attributes:
+      label: Screenshots/Code snippets
+      description: If applicable, add screenshots or code snippets to help explain your problem.
+    validations:
+      required: true
+  - type: dropdown
+    id: os
+    attributes:
+      label: Operating System
+      description: Select the operating system you're using
+      options:
+        - Ubuntu 20.04
+        - Ubuntu 22.04
+        - Ubuntu 24.04
+        - macOS Catalina
+        - macOS Big Sur
+        - macOS Monterey
+        - macOS Ventura
+        - macOS Sonoma
+        - Windows 10
+        - Windows 11
+        - Other (specify in additional context)
+    validations:
+      required: true
+  - type: dropdown
+    id: python-version
+    attributes:
+      label: Python Version
+      description: Version of Python your Crew is running on
+      options:
+        - '3.10'
+        - '3.11'
+        - '3.12'
+    validations:
+      required: true
+  - type: input
+    id: crewai-version
+    attributes:
+      label: crewAI Version
+      description: What version of CrewAI are you using
+    validations:
+      required: true
+  - type: input
+    id: crewai-tools-version
+    attributes:
+      label: crewAI Tools Version
+      description: What version of CrewAI Tools are you using 
+    validations:
+      required: true
+  - type: dropdown
+    id: virtual-environment
+    attributes:
+      label: Virtual Environment
+      description: What Virtual Environment are you running your crew in.
+      options:
+        - Venv
+        - Conda
+        - Poetry
+    validations:
+      required: true
+  - type: textarea
+    id: evidence
+    attributes:
+      label: Evidence
+      description: Include relevant information, logs or error messages. These can be screenshots.
+    validations:
+      required: true
+  - type: textarea
+    id: possible-solution
+    attributes:
+      label: Possible Solution
+      description: Have a solution in mind? Please suggest it here, or write "None".
+    validations:
+      required: true
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional context
+      description: Add any other context about the problem here.
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,65 @@
+name: Feature request
+description: Suggest a new feature for CrewAI
+title: "[FEATURE]"
+labels: ["feature-request"]
+assignees: []
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this feature request!
+  - type: dropdown
+    id: feature-area
+    attributes:
+      label: Feature Area
+      description: Which area of CrewAI does this feature primarily relate to?
+      options:
+        - Core functionality
+        - Agent capabilities
+        - Task management
+        - Integration with external tools
+        - Performance optimization
+        - Documentation
+        - Other (please specify in additional context)
+    validations:
+      required: true
+  - type: textarea
+    id: problem
+    attributes:
+      label: Is your feature request related to a an existing bug? Please link it here.
+      description: A link to the bug or NA if not related to an existing bug.
+    validations:
+      required: true
+  - type: textarea
+    id: solution
+    attributes:
+      label: Describe the solution you'd like
+      description: A clear and concise description of what you want to happen.
+    validations:
+      required: true
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: Describe alternatives you've considered
+      description: A clear and concise description of any alternative solutions or features you've considered.
+    validations:
+      required: false
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context
+      description: Add any other context, screenshots, or examples about the feature request here.
+    validations:
+      required: false
+  - type: dropdown
+    id: willingness-to-contribute
+    attributes:
+      label: Willingness to Contribute
+      description: Would you be willing to contribute to the implementation of this feature?
+      options:
+        - Yes, I'd be happy to submit a pull request
+        - I could provide more detailed specifications
+        - I can test the feature once it's implemented
+        - No, I'm just suggesting the idea
+    validations:
+      required: true

.github/security.md

@@ -0,0 +1,19 @@
+CrewAI takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organization.
+If you believe you have found a security vulnerability in any CrewAI product or service, please report it to us as described below.
+
+ ## Reporting a Vulnerability
+ Please do not report security vulnerabilities through public GitHub issues.
+ To report a vulnerability, please email us at security@crewai.com.
+ Please include the requested information listed below so that we can triage your report more quickly
+
+ - Type of issue (e.g. SQL injection, cross-site scripting, etc.)
+ - Full paths of source file(s) related to the manifestation of the issue
+ - The location of the affected source code (tag/branch/commit or direct URL)
+ - Any special configuration required to reproduce the issue
+ - Step-by-step instructions to reproduce the issue (please include screenshots if needed)
+ - Proof-of-concept or exploit code (if possible)
+ - Impact of the issue, including how an attacker might exploit the issue
+
+ Once we have received your report, we will respond to you at the email address you provide. If the issue is confirmed, we will release a patch as soon as possible depending on the complexity of the issue.
+
+ At this time, we are not offering a bug bounty program. Any rewards will be at our discretion.

.github/workflows/linter.yml

@@ -0,0 +1,16 @@
+name: Lint
+
+on: [pull_request]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Requirements
+        run: |
+          pip install ruff
+
+      - name: Run Ruff Linter
+        run: ruff check

.github/workflows/mkdocs.yml

@@ -0,0 +1,45 @@
+name: Deploy MkDocs
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: write
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+
+      - name: Calculate requirements hash
+        id: req-hash
+        run: echo "::set-output name=hash::$(sha256sum requirements-doc.txt | awk '{print $1}')"
+
+      - name: Setup cache
+        uses: actions/cache@v4
+        with:
+          key: mkdocs-material-${{ steps.req-hash.outputs.hash }}
+          path: .cache
+          restore-keys: |
+            mkdocs-material-
+
+      - name: Install Requirements
+        run: |
+          sudo apt-get update &&
+          sudo apt-get install pngquant &&
+          pip install mkdocs-material mkdocs-material-extensions pillow cairosvg
+
+        env:
+          GH_TOKEN: ${{ secrets.GH_TOKEN }}
+
+      - name: Build and deploy MkDocs
+        run: mkdocs gh-deploy --force

.github/workflows/security-checker.yml

@@ -0,0 +1,23 @@
+name: Security Checker
+
+on: [pull_request]
+
+jobs:
+  security-check:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11.9"
+
+      - name: Install dependencies
+        run: pip install bandit
+
+      - name: Run Bandit
+        run: bandit -c pyproject.toml -r src/ -ll
+

.github/workflows/stale.yml

@@ -0,0 +1,29 @@
+name: Mark stale issues and pull requests
+
+permissions:
+  contents: write
+  issues: write
+  pull-requests: write
+
+on:
+  schedule:
+    - cron: '10 12 * * *'
+  workflow_dispatch:
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/stale@v9
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        stale-issue-label: 'no-issue-activity'
+        stale-issue-message: 'This issue is stale because it has been open for 30 days with no activity. Remove stale label or comment or this will be closed in 5 days.'
+        close-issue-message: 'This issue was closed because it has been stalled for 5 days with no activity.'
+        days-before-issue-stale: 30
+        days-before-issue-close: 5
+        stale-pr-label: 'no-pr-activity'
+        stale-pr-message: 'This PR is stale because it has been open for 45 days with no activity.'
+        days-before-pr-stale: 45
+        days-before-pr-close: -1
+        operations-per-run: 1200

.github/workflows/tests.yml

@@ -0,0 +1,32 @@
+name: Run Tests
+
+on: [pull_request]
+
+permissions:
+  contents: write
+
+env:
+  OPENAI_API_KEY: fake-api-key
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
+
+
+      - name: Set up Python
+        run: uv python install 3.12.8
+
+      - name: Install the project
+        run: uv sync --dev --all-extras
+
+      - name: Run tests
+        run: uv run pytest tests -vv

.github/workflows/type-checker.yml

@@ -0,0 +1,26 @@
+name: Run Type Checks
+
+on: [pull_request]
+
+permissions:
+  contents: write
+
+jobs:
+  type-checker:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11.9"
+
+      - name: Install Requirements
+        run: |
+          pip install mypy
+
+      - name: Run type checks
+        run: mypy src

.gitignore

@@ -2,5 +2,22 @@
 .pytest_cache
 __pycache__
 dist/
-*/**/cassettes/*
-.env
+lib/
+.env
+assets/*
+.idea
+test/
+docs_crew/
+chroma.sqlite3
+old_en.json
+db/
+test.py
+rc-tests/*
+*.pkl
+temp/*
+.vscode/*
+crew_tasks_output.json
+.codesight
+.mypy_cache
+.ruff_cache
+.venv

.pre-commit-config.yaml

@@ -0,0 +1,7 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.8.2
+    hooks:
+      - id: ruff
+        args: ["--fix"]
+      - id: ruff-format

.ruff.toml

@@ -0,0 +1,9 @@
+exclude = [
+    "templates",
+    "__init__.py",
+]
+
+[lint]
+select = [
+    "I", # isort rules
+]

README.md

@@ -1,78 +1,472 @@
-# CrewAI
+<div align="center">
 
-🤖 Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.
+![Logo of CrewAI, two people rowing on a boat](./docs/crewai_logo.png)
+
+# **CrewAI**
+
+🤖 **CrewAI**: Production-grade framework for orchestrating sophisticated AI agent systems. From simple automations to complex real-world applications, CrewAI provides precise control and deep customization. By fostering collaborative intelligence through flexible, production-ready architecture, CrewAI empowers agents to work together seamlessly, tackling complex business challenges with predictable, consistent results.
+
+<h3>
+
+[Homepage](https://www.crewai.com/) | [Documentation](https://docs.crewai.com/) | [Chat with Docs](https://chatg.pt/DWjSBZn) | [Examples](https://github.com/crewAIInc/crewAI-examples) | [Discourse](https://community.crewai.com)
+
+</h3>
+
+[![GitHub Repo stars](https://img.shields.io/github/stars/joaomdmoura/crewAI)](https://github.com/crewAIInc/crewAI)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+
+</div>
+
+## Table of contents
+
+- [Why CrewAI?](#why-crewai)
+- [Getting Started](#getting-started)
+- [Key Features](#key-features)
+- [Understanding Flows and Crews](#understanding-flows-and-crews)
+- [CrewAI vs LangGraph](#how-crewai-compares)
+- [Examples](#examples)
+  - [Quick Tutorial](#quick-tutorial)
+  - [Write Job Descriptions](#write-job-descriptions)
+  - [Trip Planner](#trip-planner)
+  - [Stock Analysis](#stock-analysis)
+  - [Using Crews and Flows Together](#using-crews-and-flows-together)
+- [Connecting Your Crew to a Model](#connecting-your-crew-to-a-model)
+- [How CrewAI Compares](#how-crewai-compares)
+- [Frequently Asked Questions (FAQ)](#frequently-asked-questions-faq)
+- [Contribution](#contribution)
+- [Telemetry](#telemetry)
+- [License](#license)
 
 ## Why CrewAI?
 
 The power of AI collaboration has too much to offer.
-CrewAI is designed to enable AI agents to assume roles, share goals, and operate in a cohesive unit - much like a well-oiled crew. Whether you're building a smart assistant platform, an automated customer service ensemble, or a multi-agent research team, CrewAI provides the backbone for sophisticated multi-agent interactions.
-
-[Documention Wiki](https://github.com/joaomdmoura/CrewAI/wiki)
+CrewAI is a standalone framework, built from the ground up without dependencies on Langchain or other agent frameworks. It's designed to enable AI agents to assume roles, share goals, and operate in a cohesive unit - much like a well-oiled crew. Whether you're building a smart assistant platform, an automated customer service ensemble, or a multi-agent research team, CrewAI provides the backbone for sophisticated multi-agent interactions.
 
 ## Getting Started
 
+### Learning Resources
+
+Learn CrewAI through our comprehensive courses:
+- [Multi AI Agent Systems with CrewAI](https://www.deeplearning.ai/short-courses/multi-ai-agent-systems-with-crewai/) - Master the fundamentals of multi-agent systems
+- [Practical Multi AI Agents and Advanced Use Cases](https://www.deeplearning.ai/short-courses/practical-multi-ai-agents-and-advanced-use-cases-with-crewai/) - Deep dive into advanced implementations
+
+### Understanding Flows and Crews
+
+CrewAI offers two powerful, complementary approaches that work seamlessly together to build sophisticated AI applications:
+
+1. **Crews**: Teams of AI agents with true autonomy and agency, working together to accomplish complex tasks through role-based collaboration. Crews enable:
+   - Natural, autonomous decision-making between agents
+   - Dynamic task delegation and collaboration
+   - Specialized roles with defined goals and expertise
+   - Flexible problem-solving approaches
+
+2. **Flows**: Production-ready, event-driven workflows that deliver precise control over complex automations. Flows provide:
+   - Fine-grained control over execution paths for real-world scenarios
+   - Secure, consistent state management between tasks
+   - Clean integration of AI agents with production Python code
+   - Conditional branching for complex business logic
+
+The true power of CrewAI emerges when combining Crews and Flows. This synergy allows you to:
+- Build complex, production-grade applications
+- Balance autonomy with precise control
+- Handle sophisticated real-world scenarios
+- Maintain clean, maintainable code structure
+
+### Getting Started with Installation
+
 To get started with CrewAI, follow these simple steps:
 
-1. **Installation**:
+### 1. Installation
+
+Ensure you have Python >=3.10 <3.13 installed on your system. CrewAI uses [UV](https://docs.astral.sh/uv/) for dependency management and package handling, offering a seamless setup and execution experience.
+
+First, install CrewAI:
 
 ```shell
 pip install crewai
 ```
+If you want to install the 'crewai' package along with its optional features that include additional tools for agents, you can do so by using the following command:
 
-2. **Setting Up Your Crew**:
+```shell
+pip install 'crewai[tools]'
+```
+The command above installs the basic package and also adds extra components which require more dependencies to function.
 
-```python
-from crewai import Agent, Task, Crew, Process
+### Troubleshooting Dependencies
 
-# Define your agents with roles and goals
-researcher = Agent(
-  role='Researcher',
-  goal='Discover new insights',
-  backstory="You're a world class researcher working on a amjor data science company",
-  verbose=True
-)
-writer = Agent(
-  role='Writer',
-  goal='Create engaging content',
-  backstory="You're a famous technical writer, specialized on writing data related content"
-  verbose=True
-)
+If you encounter issues during installation or usage, here are some common solutions:
 
-# Create tasks for your agents
-task1 = Task(description='Investigate the latest AI trends', agent=researcher)
-task2 = Task(description='Write a blog post on AI advancements', agent=writer)
+#### Common Issues
 
-# Instantiate your crew with a sequential process
-crew = Crew(
-  agents=[researcher, writer],
-  tasks=[task1, task2],
-  process=Process.sequential # Sequential process will have tasks executed one after the other and the outcome of the previous one is passed as extra content into this next.
-)
+1. **ModuleNotFoundError: No module named 'tiktoken'**
+   - Install tiktoken explicitly: `pip install 'crewai[embeddings]'`
+   - If using embedchain or other tools: `pip install 'crewai[tools]'`
 
-# Get your crew to work!
-crew.kickoff()
+2. **Failed building wheel for tiktoken**
+   - Ensure Rust compiler is installed (see installation steps above)
+   - For Windows: Verify Visual C++ Build Tools are installed
+   - Try upgrading pip: `pip install --upgrade pip`
+   - If issues persist, use a pre-built wheel: `pip install tiktoken --prefer-binary`
+
+### 2. Setting Up Your Crew with the YAML Configuration
+
+To create a new CrewAI project, run the following CLI (Command Line Interface) command:
+
+```shell
+crewai create crew <project_name>
 ```
 
-Currently the only supported process is `Process.sequential`, where one task is executed after the other and the outcome of one is passed as extra content into this next.
+This command creates a new project folder with the following structure:
+
+```
+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
+```
+
+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.
+
+#### 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.
+
+#### Example of a simple crew with a sequential process:
+
+Instantiate your crew:
+
+```shell
+crewai create crew latest-ai-development
+```
+
+Modify the files as needed to fit your use case:
+
+**agents.yaml**
+
+```yaml
+# src/my_project/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.
+```
+
+**tasks.yaml**
+
+```yaml
+# src/my_project/config/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
+```
+
+**crew.py**
+
+```python
+# src/my_project/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'],
+			output_file='report.md'
+		)
+
+	@crew
+	def crew(self) -> Crew:
+		"""Creates the LatestAiDevelopment crew"""
+		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,
+		)
+```
+
+**main.py**
+
+```python
+#!/usr/bin/env python
+# src/my_project/main.py
+import sys
+from latest_ai_development.crew import LatestAiDevelopmentCrew
+
+def run():
+    """
+    Run the crew.
+    """
+    inputs = {
+        'topic': 'AI Agents'
+    }
+    LatestAiDevelopmentCrew().crew().kickoff(inputs=inputs)
+```
+
+### 3. Running Your Crew
+
+Before running your crew, make sure you have the following keys set as environment variables in your `.env` file:
+
+- An [OpenAI API key](https://platform.openai.com/account/api-keys) (or other LLM API key): `OPENAI_API_KEY=sk-...`
+- A [Serper.dev](https://serper.dev/) API key: `SERPER_API_KEY=YOUR_KEY_HERE`
+
+Lock the dependencies and install them by using the CLI command but first, navigate to your project directory:
+
+```shell
+cd my_project
+crewai install (Optional)
+```
+
+To run your crew, execute the following command in the root of your project:
+
+```bash
+crewai run
+```
+
+or
+
+```bash
+python src/my_project/main.py
+```
+
+If an error happens due to the usage of poetry, please run the following command to update your crewai package:
+
+```bash
+crewai update
+```
+
+You should see the output in the console and the `report.md` file should be created in the root of your project with the full final report.
+
+In addition to the sequential process, you can use the hierarchical process, which automatically assigns a manager to the defined crew to properly coordinate the planning and execution of tasks through delegation and validation of results. [See more about the processes here](https://docs.crewai.com/core-concepts/Processes/).
 
 ## Key Features
 
-- **Role-Based Agent Design**: Customize agents with specific roles, goals, and tools.
-- **Autonomous Inter-Agent Delegation**: Agents can autonomously delegate tasks and inquire amongst themselves, enhancing problem-solving efficiency.
-- **Flexible Task Management**: Define tasks with customizable tools and assign them to agents dynamically.
-- **Processes Driven**: Currently only supports `sequential` task execution but more complex processes like consensual and hierarchical being worked on.
+**Note**: CrewAI is a standalone framework built from the ground up, without dependencies on Langchain or other agent frameworks.
 
-![CrewAI Mind Map](/crewAI-mindmap.png "CrewAI Mind Map")
+- **Deep Customization**: Build sophisticated agents with full control over the system - from overriding inner prompts to accessing low-level APIs. Customize roles, goals, tools, and behaviors while maintaining clean abstractions.
+- **Autonomous Inter-Agent Delegation**: Agents can autonomously delegate tasks and inquire amongst themselves, enabling complex problem-solving in real-world scenarios.
+- **Flexible Task Management**: Define and customize tasks with granular control, from simple operations to complex multi-step processes.
+- **Production-Grade Architecture**: Support for both high-level abstractions and low-level customization, with robust error handling and state management.
+- **Predictable Results**: Ensure consistent, accurate outputs through programmatic guardrails, agent training capabilities, and flow-based execution control. See our [documentation on guardrails](https://docs.crewai.com/how-to/guardrails/) for implementation details.
+- **Model Flexibility**: Run your crew using OpenAI or open source models with production-ready integrations. See [Connect CrewAI to LLMs](https://docs.crewai.com/how-to/LLM-Connections/) for detailed configuration options.
+- **Event-Driven Flows**: Build complex, real-world workflows with precise control over execution paths, state management, and conditional logic.
+- **Process Orchestration**: Achieve any workflow pattern through flows - from simple sequential and hierarchical processes to complex, custom orchestration patterns with conditional branching and parallel execution.
 
+![CrewAI Mind Map](./docs/crewAI-mindmap.png "CrewAI Mind Map")
+
+## Examples
+
+You can test different real life examples of AI crews in the [CrewAI-examples repo](https://github.com/crewAIInc/crewAI-examples?tab=readme-ov-file):
+
+- [Landing Page Generator](https://github.com/crewAIInc/crewAI-examples/tree/main/landing_page_generator)
+- [Having Human input on the execution](https://docs.crewai.com/how-to/Human-Input-on-Execution)
+- [Trip Planner](https://github.com/crewAIInc/crewAI-examples/tree/main/trip_planner)
+- [Stock Analysis](https://github.com/crewAIInc/crewAI-examples/tree/main/stock_analysis)
+
+### Quick Tutorial
+
+[![CrewAI Tutorial](https://img.youtube.com/vi/tnejrr-0a94/maxresdefault.jpg)](https://www.youtube.com/watch?v=tnejrr-0a94 "CrewAI Tutorial")
+
+### Write Job Descriptions
+
+[Check out code for this example](https://github.com/crewAIInc/crewAI-examples/tree/main/job-posting) or watch a video below:
+
+[![Jobs postings](https://img.youtube.com/vi/u98wEMz-9to/maxresdefault.jpg)](https://www.youtube.com/watch?v=u98wEMz-9to "Jobs postings")
+
+### Trip Planner
+
+[Check out code for this example](https://github.com/crewAIInc/crewAI-examples/tree/main/trip_planner) or watch a video below:
+
+[![Trip Planner](https://img.youtube.com/vi/xis7rWp-hjs/maxresdefault.jpg)](https://www.youtube.com/watch?v=xis7rWp-hjs "Trip Planner")
+
+### Stock Analysis
+
+[Check out code for this example](https://github.com/crewAIInc/crewAI-examples/tree/main/stock_analysis) or watch a video below:
+
+[![Stock Analysis](https://img.youtube.com/vi/e0Uj4yWdaAg/maxresdefault.jpg)](https://www.youtube.com/watch?v=e0Uj4yWdaAg "Stock Analysis")
+
+### Using Crews and Flows Together
+
+CrewAI's power truly shines when combining Crews with Flows to create sophisticated automation pipelines. Here's how you can orchestrate multiple Crews within a Flow:
+
+```python
+from crewai.flow.flow import Flow, listen, start, router
+from crewai import Crew, Agent, Task
+from pydantic import BaseModel
+
+# Define structured state for precise control
+class MarketState(BaseModel):
+    sentiment: str = "neutral"
+    confidence: float = 0.0
+    recommendations: list = []
+
+class AdvancedAnalysisFlow(Flow[MarketState]):
+    @start()
+    def fetch_market_data(self):
+        # Demonstrate low-level control with structured state
+        self.state.sentiment = "analyzing"
+        return {"sector": "tech", "timeframe": "1W"}  # These parameters match the task description template
+
+    @listen(fetch_market_data)
+    def analyze_with_crew(self, market_data):
+        # Show crew agency through specialized roles
+        analyst = Agent(
+            role="Senior Market Analyst",
+            goal="Conduct deep market analysis with expert insight",
+            backstory="You're a veteran analyst known for identifying subtle market patterns"
+        )
+        researcher = Agent(
+            role="Data Researcher",
+            goal="Gather and validate supporting market data",
+            backstory="You excel at finding and correlating multiple data sources"
+        )
+        
+        analysis_task = Task(
+            description="Analyze {sector} sector data for the past {timeframe}",
+            expected_output="Detailed market analysis with confidence score",
+            agent=analyst
+        )
+        research_task = Task(
+            description="Find supporting data to validate the analysis",
+            expected_output="Corroborating evidence and potential contradictions",
+            agent=researcher
+        )
+        
+        # Demonstrate crew autonomy
+        analysis_crew = Crew(
+            agents=[analyst, researcher],
+            tasks=[analysis_task, research_task],
+            process=Process.sequential,
+            verbose=True
+        )
+        return analysis_crew.kickoff(inputs=market_data)  # Pass market_data as named inputs
+
+    @router(analyze_with_crew)
+    def determine_next_steps(self):
+        # Show flow control with conditional routing
+        if self.state.confidence > 0.8:
+            return "high_confidence"
+        elif self.state.confidence > 0.5:
+            return "medium_confidence"
+        return "low_confidence"
+
+    @listen("high_confidence")
+    def execute_strategy(self):
+        # Demonstrate complex decision making
+        strategy_crew = Crew(
+            agents=[
+                Agent(role="Strategy Expert",
+                      goal="Develop optimal market strategy")
+            ],
+            tasks=[
+                Task(description="Create detailed strategy based on analysis",
+                     expected_output="Step-by-step action plan")
+            ]
+        )
+        return strategy_crew.kickoff()
+
+    @listen("medium_confidence", "low_confidence")
+    def request_additional_analysis(self):
+        self.state.recommendations.append("Gather more data")
+        return "Additional analysis required"
+```
+
+This example demonstrates how to:
+1. Use Python code for basic data operations
+2. Create and execute Crews as steps in your workflow
+3. Use Flow decorators to manage the sequence of operations
+4. Implement conditional branching based on Crew results
+
+## Connecting Your Crew to a Model
+
+CrewAI supports using various LLMs through a variety of connection options. By default your agents will use the OpenAI API when querying the model. However, there are several other ways to allow your agents to connect to models. For example, you can configure your agents to use a local model via the Ollama tool.
+
+Please refer to the [Connect CrewAI to LLMs](https://docs.crewai.com/how-to/LLM-Connections/) page for details on configuring you agents' connections to models.
 
 ## How CrewAI Compares
 
-- **Autogen**: While Autogen excels in creating conversational agents capable of working together, it lacks an inherent concept of process. In Autogen, orchestrating agents' interactions requires additional programming, which can become complex and cumbersome as the scale of tasks grows.
+**CrewAI's Advantage**: CrewAI combines autonomous agent intelligence with precise workflow control through its unique Crews and Flows architecture. The framework excels at both high-level orchestration and low-level customization, enabling complex, production-grade systems with granular control.
+
+- **LangGraph**: While LangGraph provides a foundation for building agent workflows, its approach requires significant boilerplate code and complex state management patterns. The framework's tight coupling with LangChain can limit flexibility when implementing custom agent behaviors or integrating with external systems.
+
+*P.S. CrewAI demonstrates significant performance advantages over LangGraph, executing 5.76x faster in certain cases like this QA task example ([see comparison](https://github.com/crewAIInc/crewAI-examples/tree/main/Notebooks/CrewAI%20Flows%20%26%20Langgraph/QA%20Agent)) while achieving higher evaluation scores with faster completion times in certain coding tasks, like in this example ([detailed analysis](https://github.com/crewAIInc/crewAI-examples/blob/main/Notebooks/CrewAI%20Flows%20%26%20Langgraph/Coding%20Assistant/coding_assistant_eval.ipynb)).*
+
+- **Autogen**: While Autogen excels at creating conversational agents capable of working together, it lacks an inherent concept of process. In Autogen, orchestrating agents' interactions requires additional programming, which can become complex and cumbersome as the scale of tasks grows.
 
 - **ChatDev**: ChatDev introduced the idea of processes into the realm of AI agents, but its implementation is quite rigid. Customizations in ChatDev are limited and not geared towards production environments, which can hinder scalability and flexibility in real-world applications.
 
-**CrewAI's Advantage**: CrewAI is built with production in mind. It offers the flexibility of Autogen's conversational agents and the structured process approach of ChatDev, but without the rigidity. CrewAI's processes are designed to be dynamic and adaptable, fitting seamlessly into both development and production workflows.
-
 ## Contribution
 
 CrewAI is open-source and we welcome contributions. If you're looking to contribute, please:
@@ -84,32 +478,118 @@ CrewAI is open-source and we welcome contributions. If you're looking to contrib
 - We appreciate your input!
 
 ### Installing Dependencies
+
 ```bash
-poetry lock
-poetry install
+uv lock
+uv sync
 ```
 
 ### Virtual Env
+
 ```bash
-poetry shell
+uv venv
+```
+
+### Pre-commit hooks
+
+```bash
+pre-commit install
 ```
 
 ### Running Tests
+
 ```bash
-poetry run pytest
+uv run pytest .
+```
+
+### Running static type checks
+
+```bash
+uvx mypy src
 ```
 
 ### Packaging
+
 ```bash
-poetry build
+uv build
 ```
 
 ### Installing Locally
+
 ```bash
 pip install dist/*.tar.gz
 ```
 
+## Telemetry
+
+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.
+
+Data collected includes:
+
+- Version of CrewAI
+  - So we can understand how many users are using the latest version
+- Version of Python
+  - So we can decide on what versions to better support
+- General OS (e.g. number of CPUs, macOS/Windows/Linux)
+  - So we know what OS we should focus on and if we could build specific OS related features
+- Number of agents and tasks in a crew
+  - So we make sure we are testing internally with similar use cases and educate people on the best practices
+- Crew Process being used
+  - Understand where we should focus our efforts
+- If Agents are using memory or allowing delegation
+  - Understand if we improved the features or maybe even drop them
+- If Tasks are being executed in parallel or sequentially
+  - Understand if we should focus more on parallel execution
+- Language model being used
+  - Improved support on most used languages
+- Roles of agents in a crew
+  - Understand high level use cases so we can build better tools, integrations and examples about it
+- Tools names available
+  - Understand out of the publicly available tools, which ones are being used the most so we can improve them
+
+Users can opt-in to Further Telemetry, sharing the complete telemetry data by setting the `share_crew` attribute to `True` on their Crews. Enabling `share_crew` results in the collection of detailed crew and task execution data, including `goal`, `backstory`, `context`, and `output` of tasks. This enables a deeper insight into usage patterns while respecting the user's choice to share.
+
 ## License
-CrewAI is released under the MIT License
 
+CrewAI is released under the [MIT License](https://github.com/crewAIInc/crewAI/blob/main/LICENSE).
 
+## Frequently Asked Questions (FAQ)
+
+### Q: What is CrewAI?
+A: CrewAI is a cutting-edge framework for orchestrating role-playing, autonomous AI agents. It enables agents to work together seamlessly, tackling complex tasks through collaborative intelligence.
+
+### Q: How do I install CrewAI?
+A: You can install CrewAI using pip:
+```shell
+pip install crewai
+```
+For additional tools, use:
+```shell
+pip install 'crewai[tools]'
+```
+
+### Q: Can I use CrewAI with local models?
+A: Yes, CrewAI supports various LLMs, including local models. You can configure your agents to use local models via tools like Ollama & LM Studio. Check the [LLM Connections documentation](https://docs.crewai.com/how-to/LLM-Connections/) for more details.
+
+### Q: What are the key features of CrewAI?
+A: Key features include role-based agent design, autonomous inter-agent delegation, flexible task management, process-driven execution, output saving as files, and compatibility with both open-source and proprietary models.
+
+### Q: How does CrewAI compare to other AI orchestration tools?
+A: CrewAI is designed with production in mind, offering flexibility similar to Autogen's conversational agents and structured processes like ChatDev, but with more adaptability for real-world applications.
+
+### Q: Is CrewAI open-source?
+A: Yes, CrewAI is open-source and welcomes contributions from the community.
+
+### Q: Does CrewAI collect any data?
+A: CrewAI uses anonymous telemetry to collect usage data for improvement purposes. No sensitive data (like prompts, task descriptions, or API calls) is collected. Users can opt-in to share more detailed data by setting `share_crew=True` on their Crews.
+
+### Q: Where can I find examples of CrewAI in action?
+A: You can find various real-life examples in the [CrewAI-examples repository](https://github.com/crewAIInc/crewAI-examples), including trip planners, stock analysis tools, and more.
+
+### Q: What is the difference between Crews and Flows?
+A: Crews and Flows serve different but complementary purposes in CrewAI. Crews are teams of AI agents working together to accomplish specific tasks through role-based collaboration, delivering accurate and predictable results. Flows, on the other hand, are event-driven workflows that can orchestrate both Crews and regular Python code, allowing you to build complex automation pipelines with secure state management and conditional execution paths.
+
+### Q: How can I contribute to CrewAI?
+A: Contributions are welcome! You can fork the repository, create a new branch for your feature, add your improvement, and send a pull request. Check the Contribution section in the README for more details.

crewAI.excalidraw

@@ -1463,11 +1463,11 @@
       "locked": false,
       "fontSize": 20,
       "fontFamily": 3,
-      "text": "Agents have the inert ability of\nreach out to another to delegate\nwork or ask questions.",
+      "text": "Agents have the innate ability of\nreach out to another to delegate\nwork or ask questions.",
       "textAlign": "right",
       "verticalAlign": "top",
       "containerId": null,
-      "originalText": "Agents have the inert ability of\nreach out to another to delegate\nwork or ask questions.",
+      "originalText": "Agents have the innate ability of\nreach out to another to delegate\nwork or ask questions.",
       "lineHeight": 1.2,
       "baseline": 68
     },
@@ -1734,4 +1734,4 @@
     "viewBackgroundColor": "#ffffff"
   },
   "files": {}
-}
+}

crewai/__init__.py

@@ -1,4 +0,0 @@
-from .task import Task
-from .crew import Crew
-from .agent import Agent
-from .process import Process

crewai/agent.py

@@ -1,99 +0,0 @@
-"""Generic agent."""
-
-from typing import List, Any, Optional
-from pydantic.v1 import BaseModel, Field, root_validator
-
-from langchain.agents import AgentExecutor
-from langchain.chat_models import ChatOpenAI as OpenAI
-from langchain.tools.render import render_text_description
-from langchain.agents.format_scratchpad import format_log_to_str
-from langchain.agents.output_parsers import ReActSingleInputOutputParser
-from langchain.memory import ConversationSummaryMemory
-
-from .prompts import Prompts
-
-class Agent(BaseModel):
-	"""Generic agent implementation."""
-	agent_executor: AgentExecutor = None
-	role: str = Field(description="Role of the agent")
-	goal: str = Field(description="Objective of the agent")
-	backstory: str = Field(description="Backstory of the agent")
-	llm: Optional[OpenAI] = Field(description="LLM that will run the agent")
-	verbose: bool = Field(
-		description="Verbose mode for the Agent Execution",
-		default=False
-	)
-	allow_delegation: bool = Field(
-		description="Allow delegation of tasks to agents",
-		default=True
-	)
-	tools: List[Any] = Field(
-		description="Tools at agents disposal",
-		default=[]
-	)
-
-	@root_validator(pre=True)
-	def check_llm(_cls, values):
-		if not values.get('llm'):
-			values['llm'] = OpenAI(
-				temperature=0.7,
-				model_name="gpt-4"
-			)
-		return values
-
-	def __init__(self, **data):
-		super().__init__(**data)
-		execution_prompt = Prompts.TASK_EXECUTION_PROMPT.partial(
-			goal=self.goal,
-			role=self.role,
-			backstory=self.backstory,
-		)
-
-		llm_with_bind = self.llm.bind(stop=["\nObservation"])
-		inner_agent = {
-			"input": lambda x: x["input"],
-			"tools": lambda x: x["tools"],
-			"tool_names": lambda x: x["tool_names"],
-			"chat_history": lambda x: x["chat_history"],
-			"agent_scratchpad": lambda x: format_log_to_str(x['intermediate_steps']),
-		} | execution_prompt | llm_with_bind | ReActSingleInputOutputParser()
-
-		summary_memory = ConversationSummaryMemory(
-			llm=self.llm,
-			memory_key='chat_history',
-			input_key="input"
-		)
-
-		self.agent_executor = AgentExecutor(
-			agent=inner_agent,
-			tools=self.tools,
-			memory=summary_memory,
-			verbose=self.verbose,
-			handle_parsing_errors=True,
-		)
-
-	def execute_task(self, task: str, context: str = None, tools: List[Any] = None) -> str:
-		"""
-		Execute a task with the agent.
-			Parameters:
-				task (str): Task to execute
-			Returns:
-				output (str): Output of the agent
-		"""
-		if context:
-			task = "\n".join([
-				task,
-				"\nThis is the context you are working with:",
-				context
-			])
-
-		tools = tools or self.tools
-		self.agent_executor.tools = tools
-		return self.agent_executor.invoke({
-			"input": task,
-			"tool_names": self.__tools_names(tools),
-			"tools": render_text_description(tools),
-		})['output']
-
-	def __tools_names(self, tools) -> str:
-		return ", ".join([t.name for t in tools])

crewai/agents/agent_vote.py

@@ -1,5 +0,0 @@
-from pydantic.v1 import BaseModel, Field
-
-class AgentVote(BaseModel):
-    task: str = Field(description="Task to be executed by the agent")
-    agent_vote: str = Field(description="Agent that will execute the task")

crewai/crew.py

@@ -1,73 +0,0 @@
-import json
-from typing import List, Optional
-from pydantic.v1 import BaseModel, Field, Json, root_validator
-
-from .process import Process
-from .agent import Agent
-from .task import Task
-from .tools.agent_tools import AgentTools
-
-class Crew(BaseModel):
-	"""
-	Class that represents a group of agents, how they should work together and
-	their tasks.
-	"""
-	config: Optional[Json] = Field(description="Configuration of the crew.")
-	tasks: Optional[List[Task]] = Field(description="List of tasks")
-	agents: Optional[List[Agent]] = Field(description="List of agents in this crew.")
-	process: Process = Field(
-		description="Process that the crew will follow.",
-		default=Process.sequential
-	)
-
-	@root_validator(pre=True)
-	def check_config(_cls, values):
-		if (
-			not values.get('config') 
-			and (
-				not values.get('agents') and not values.get('tasks')
-			)
-		):
-			raise ValueError('Either agents and task need to be set or config.')
-		
-		if values.get('config'):
-			config = json.loads(values.get('config'))
-			if not config.get('agents') or not config.get('tasks'):
-				raise ValueError('Config should have agents and tasks.')
-			
-			values['agents'] = [Agent(**agent) for agent in config['agents']]
-			
-			tasks = []
-			for task in config['tasks']:
-				task_agent = [agt for agt in values['agents'] if agt.role == task['agent']][0]
-				del task['agent']
-				tasks.append(Task(**task, agent=task_agent))
-			
-			values['tasks'] = tasks
-		return values
-
-	def kickoff(self) -> str:
-		"""
-		Kickoff the crew to work on it's tasks.
-			Returns:
-				output (List[str]): Output of the crew for each task.
-		"""
-		if self.process == Process.sequential:
-			return self.__sequential_loop()
-		return "Crew is executing task"
-
-	def __sequential_loop(self) -> str:
-		"""
-		Loop that executes the sequential process.
-			Returns:
-				output (str): Output of the crew.
-		"""
-		task_outcome = None
-		for task in self.tasks:
-			# Add delegation tools to the task if the agent allows it
-			if task.agent.allow_delegation:
-				tools = AgentTools(agents=self.agents).tools()
-				task.tools += tools
-			task_outcome = task.execute(task_outcome)
-		
-		return task_outcome

crewai/process.py

@@ -1,9 +0,0 @@
-from enum import Enum
-
-class Process(str, Enum):
-	"""
-	Class representing the different processes that can be used to tackle tasks
-	"""
-	sequential = 'sequential'
-	# TODO: consensual = 'consensual'
-	# TODO: hierarchical = 'hierarchical'

crewai/prompts.py

@@ -1,71 +0,0 @@
-"""Prompts for generic agent."""
-
-from textwrap import dedent
-from typing import ClassVar
-from pydantic.v1 import BaseModel
-from langchain.prompts import PromptTemplate
-
-class Prompts(BaseModel):
-	"""Prompts for generic agent."""
-
-	TASK_SLICE: ClassVar[str] = dedent("""\
-		Begin! This is VERY important to you, your job depends on it!
-
-		Current Task: {input}
-		{agent_scratchpad}
-	""")
-
-	MEMORY_SLICE: ClassVar[str] = dedent("""\
-		This is the summary of your work so far:
-        {chat_history}
-	""")
-
-	ROLE_PLAYING_SLICE: ClassVar[str] = dedent("""\
-		You are {role}.
-		{backstory}
-
-		Your personal goal is: {goal}
-	""")
-
-	TOOLS_SLICE: ClassVar[str] = dedent("""\
-		TOOLS:
-		------
-
-		You have access to the following tools:
-
-		{tools}
-
-		To use a tool, please use the following format:
-
-		```
-		Thought: Do I need to use a tool? Yes
-		Action: the action to take, should be one of [{tool_names}]
-		Action Input: the input to the action
-		Observation: the result of the action
-		```
-
-		When you have a response for your task, or if you do not need to use a tool, you MUST use the format:
-
-		```
-		Thought: Do I need to use a tool? No
-		Final Answer: [your response here]
-		```
-	""")
-
-	VOTING_SLICE: ClassVar[str] = dedent("""\
-		You are working on a crew with your co-workers and need to decide who will execute the task.
-
-		These are tyour format instructions:
-		{format_instructions}
-
-		These are your co-workers and their roles:
-		{coworkers}
-	""")
-
-	TASK_EXECUTION_PROMPT: ClassVar[str] = PromptTemplate.from_template(
-		ROLE_PLAYING_SLICE + TOOLS_SLICE + MEMORY_SLICE + TASK_SLICE
-	)
-	
-	CONSENSUNS_VOTING_PROMPT: ClassVar[str] = PromptTemplate.from_template(
-		ROLE_PLAYING_SLICE + VOTING_SLICE + TASK_SLICE
-	)

crewai/task.py

@@ -1,42 +0,0 @@
-from typing import List, Optional
-from pydantic.v1 import BaseModel, Field, root_validator
-
-from langchain.tools import Tool
-
-from .agent import Agent
-
-class Task(BaseModel):
-	"""
-	Class that represent a task to be executed.
-	"""
-	
-	description: str = Field(description="Description of the actual task.")
-	agent: Optional[Agent] = Field(
-		description="Agent responsible for the task.",
-		default=None
-	)
-	tools: Optional[List[Tool]] = Field(
-		description="Tools the agent are limited to use for this task.",
-		default=[]
-	)
-
-	@root_validator(pre=False)
-	def _set_tools(_cls, values):
-		if (values.get('agent')) and not (values.get('tools')):
-			values['tools'] = values.get('agent').tools
-		return values
-
-	def execute(self, context: str = None) -> str:
-		"""
-		Execute the task.
-			Returns:
-				output (str): Output of the task.
-		"""
-		if self.agent:
-			return self.agent.execute_task(
-				task = self.description, 
-				context = context,
-				tools = self.tools
-			)
-		else:
-			raise Exception(f"The task '{self.description}' has no agent assigned, therefore it can't be executed directly and should be executed in a Crew using a specific process that support that, either consensual or hierarchical.")

crewai/tools/agent_tools.py

@@ -1,57 +0,0 @@
-from typing import List, Any
-from pydantic.v1 import BaseModel, Field
-from textwrap import dedent
-from langchain.tools import Tool
-
-from ..agent import Agent
-
-class AgentTools(BaseModel):
-	"""Tools for generic agent."""
-	agents: List[Agent] = Field(description="List of agents in this crew.")
-
-	def tools(self):
-		return [
-			Tool.from_function(
-				func=self.delegate_work,
-				name="Delegate Work to Co-Worker",
-				description=dedent(f"""Useful to delegate a specific task to one of the 
-				following co-workers: [{', '.join([agent.role for agent in self.agents])}].
-				The input to this tool should be a pipe (|) separated text of length
-				three, representing the role you want to delegate it to,  the task and 
-				information necessary. For example, `coworker|task|information`.
-				""")
-			),
-			Tool.from_function(
-				func=self.ask_question,
-				name="Ask Question to Co-Worker",
-				description=dedent(f"""Useful to ask a question, opinion or take from on
-				of the following co-workers: [{', '.join([agent.role for agent in self.agents])}]. 
-				The input to this tool should be a pipe (|) separated text of length 
-				three, representing the role you want to ask it to,  the question and 
-				information necessary. For example, `coworker|question|information`.
-				""")
-			),
-		]
-
-	def delegate_work(self, command):
-		"""Useful to delegate a specific task to a coworker."""
-		return self.__execute(command)
-
-	def ask_question(self, command):
-		"""Useful to ask a question, opinion or take from a coworker."""
-		return self.__execute(command)
-
-	def __execute(self, command):
-		"""Execute the command."""
-		agent, task, information = command.split("|")
-		if not agent or not task or not information:
-			return "Error executing tool."
-		
-		agent = [available_agent for available_agent in self.agents if available_agent.role == agent]
-		
-		if len(agent) == 0:
-			return "Error executing tool."
-
-		agent = agent[0]
-		result = agent.execute_task(task, information)	
-		return result

docs/concepts/agents.mdx

@@ -0,0 +1,343 @@
+---
+title: Agents
+description: Detailed guide on creating and managing agents within the CrewAI framework.
+icon: robot
+---
+
+## Overview of 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
+
+<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.
+</Tip>
+
+## 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.                                                 |
+
+## 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.
+
+<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 agents using YAML:
+
+```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
+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
+)
+```
+
+Let's break down some key parameter combinations for common use cases:
+
+#### 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
+)
+```
+
+#### 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|>
+                        {{ .System }}<|eot_id|>""",
+    prompt_template="""<|start_header_id|>user<|end_header_id|>
+                        {{ .Prompt }}<|eot_id|>""",
+    response_template="""<|start_header_id|>assistant<|end_header_id|>
+                        {{ .Response }}<|eot_id|>""",
+)
+```
+
+### Parameter Details
+
+#### 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)
+
+#### 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>
+
+## Agent Tools
+
+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)
+
+Here's how to add tools to an agent:
+
+```python Code
+from crewai import Agent
+from crewai_tools import SerperDevTool, WikipediaTools
+
+# 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
+)
+```
+
+## Agent Memory and Context
+
+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.

docs/concepts/cli.mdx

@@ -0,0 +1,178 @@
+---
+title: CLI
+description: Learn how to use the CrewAI CLI to interact with CrewAI.
+icon: terminal
+---
+
+# CrewAI CLI Documentation
+
+The CrewAI CLI provides a set of commands to interact with CrewAI, allowing you to create, train, run, and manage crews & flows.
+
+## Installation
+
+To use the CrewAI CLI, make sure you have CrewAI installed:
+
+```shell
+pip install crewai
+```
+
+## Basic Usage
+
+The basic structure of a CrewAI CLI command is:
+
+```shell
+crewai [COMMAND] [OPTIONS] [ARGUMENTS]
+```
+
+## Available Commands
+
+### 1. Create
+
+Create a new crew or flow.
+
+```shell
+crewai create [OPTIONS] TYPE NAME
+```
+
+- `TYPE`: Choose between "crew" or "flow"
+- `NAME`: Name of the crew or flow
+
+Example:
+```shell
+crewai create crew my_new_crew
+crewai create flow my_new_flow
+```
+
+### 2. Version
+
+Show the installed version of CrewAI.
+
+```shell
+crewai version [OPTIONS]
+```
+
+- `--tools`: (Optional) Show the installed version of CrewAI tools
+
+Example:
+```shell
+crewai version
+crewai version --tools
+```
+
+### 3. Train
+
+Train the crew for a specified number of iterations.
+
+```shell
+crewai train [OPTIONS]
+```
+
+- `-n, --n_iterations INTEGER`: Number of iterations to train the crew (default: 5)
+- `-f, --filename TEXT`: Path to a custom file for training (default: "trained_agents_data.pkl")
+
+Example:
+```shell
+crewai train -n 10 -f my_training_data.pkl
+```
+
+### 4. Replay
+
+Replay the crew execution from a specific task.
+
+```shell
+crewai replay [OPTIONS]
+```
+
+- `-t, --task_id TEXT`: Replay the crew from this task ID, including all subsequent tasks
+
+Example:
+```shell    
+crewai replay -t task_123456
+```
+
+### 5. Log-tasks-outputs
+
+Retrieve your latest crew.kickoff() task outputs.
+
+```shell
+crewai log-tasks-outputs
+```
+
+### 6. Reset-memories
+
+Reset the crew memories (long, short, entity, latest_crew_kickoff_outputs).
+
+```shell
+crewai reset-memories [OPTIONS]
+```
+
+- `-l, --long`: Reset LONG TERM memory
+- `-s, --short`: Reset SHORT TERM memory
+- `-e, --entities`: Reset ENTITIES memory
+- `-k, --kickoff-outputs`: Reset LATEST KICKOFF TASK OUTPUTS
+- `-a, --all`: Reset ALL memories
+
+Example:
+```shell
+crewai reset-memories --long --short
+crewai reset-memories --all
+```
+
+### 7. Test
+
+Test the crew and evaluate the results.
+
+```shell
+crewai test [OPTIONS]
+```
+
+- `-n, --n_iterations INTEGER`: Number of iterations to test the crew (default: 3)
+- `-m, --model TEXT`: LLM Model to run the tests on the Crew (default: "gpt-4o-mini")
+
+Example:
+```shell
+crewai test -n 5 -m gpt-3.5-turbo
+```
+
+### 8. Run
+
+Run the crew.
+
+```shell
+crewai run
+```
+<Note>
+Make sure to run these commands from the directory where your CrewAI project is set up. 
+Some commands may require additional configuration or setup within your project structure.
+</Note>
+
+
+### 9. API Keys
+
+When running ```crewai create crew``` command, the CLI will first show you the top 5 most common LLM providers and ask you to select one.
+
+Once you've selected an LLM provider, you will be prompted for API keys.
+
+#### Initial API key providers
+
+The CLI will initially prompt for API keys for the following services:
+
+* OpenAI
+* Groq
+* Anthropic
+* Google Gemini
+
+When you select a provider, the CLI will prompt you to enter your API key.
+
+#### Other Options
+
+If you select option 6, you will be able to select from a list of LiteLLM supported providers.
+
+When you select a provider, the CLI will prompt you to enter the Key name and the API key.
+
+See the following link for each provider's key name:
+
+* [LiteLLM Providers](https://docs.litellm.ai/docs/providers)
+
+
+

docs/concepts/collaboration.mdx

@@ -0,0 +1,52 @@
+---
+title: Collaboration
+description: Exploring the dynamics of agent collaboration within the CrewAI framework, focusing on the newly integrated features for enhanced functionality.
+icon: screen-users
+---
+
+## Collaboration Fundamentals      
+
+Collaboration in CrewAI is fundamental, enabling agents to combine their skills, share information, and assist each other in task execution, embodying a truly cooperative ecosystem.
+
+- **Information Sharing**: Ensures all agents are well-informed and can contribute effectively by sharing data and findings.
+- **Task Assistance**: Allows agents to seek help from peers with the required expertise for specific tasks.
+- **Resource Allocation**: Optimizes task execution through the efficient distribution and sharing of resources among agents.
+
+## Enhanced Attributes for Improved Collaboration
+
+The `Crew` class has been enriched with several attributes to support advanced functionalities:
+
+| Feature                                    | Description                                                                                                                                                                                                                  |
+|:-------------------------------------------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Language Model Management** (`manager_llm`, `function_calling_llm`) | Manages language models for executing tasks and tools. `manager_llm` is required for hierarchical processes, while `function_calling_llm` is optional with a default value for streamlined interactions.                    |
+| **Custom Manager Agent** (`manager_agent`) | Specifies a custom agent as the manager, replacing the default CrewAI manager.                                                                                                                                                |
+| **Process Flow** (`process`)           | Defines execution logic (e.g., sequential, hierarchical) for task distribution.                                                                                                                                                |
+| **Verbose Logging** (`verbose`)        | Provides detailed logging for monitoring and debugging. Accepts integer and boolean values to control verbosity level.                                                                                                       |
+| **Rate Limiting** (`max_rpm`)          | Limits requests per minute to optimize resource usage. Setting guidelines depend on task complexity and load.                                                                                                                 |
+| **Internationalization / Customization** (`language`, `prompt_file`) | Supports prompt customization for global usability. [Example of file](https://github.com/joaomdmoura/crewAI/blob/main/src/crewai/translations/en.json)                                                                                      |
+| **Execution and Output Handling** (`full_output`) | Controls output granularity, distinguishing between full and final outputs.                                                                                                                                                  |
+| **Callback and Telemetry** (`step_callback`, `task_callback`) | Enables step-wise and task-level execution monitoring and telemetry for performance analytics.                                                                                                                               |
+| **Crew Sharing** (`share_crew`)        | Allows sharing crew data with CrewAI for model improvement. Privacy implications and benefits should be considered.                                                                                                          |
+| **Usage Metrics** (`usage_metrics`)    | Logs all LLM usage metrics during task execution for performance insights.                                                                                                                           |
+| **Memory Usage** (`memory`)            | Enables memory for storing execution history, aiding in agent learning and task efficiency.                                                                                                                                  |
+| **Embedder Configuration** (`embedder`) | Configures the embedder for language understanding and generation, with support for provider customization.                                                                                                                   |
+| **Cache Management** (`cache`)         | Specifies whether to cache tool execution results, enhancing performance.                                                                                                                                                   |
+| **Output Logging** (`output_log_file`) | Defines the file path for logging crew execution output.                                                                                                                                                                      |
+| **Planning Mode** (`planning`)         | Enables action planning before task execution. Set `planning=True` to activate.                                                                                                                                              |
+| **Replay Feature** (`replay`)         | Provides CLI for listing tasks from the last run and replaying from specific tasks, aiding in task management and troubleshooting.                                                                                           |
+
+## Delegation (Dividing to Conquer)
+
+Delegation enhances functionality by allowing agents to intelligently assign tasks or seek help, thereby amplifying the crew's overall capability.
+
+## Implementing Collaboration and Delegation
+
+Setting up a crew involves defining the roles and capabilities of each agent. CrewAI seamlessly manages their interactions, ensuring efficient collaboration and delegation, with enhanced customization and monitoring features to adapt to various operational needs.
+
+## Example Scenario
+
+Consider a crew with a researcher agent tasked with data gathering and a writer agent responsible for compiling reports. The integration of advanced language model management and process flow attributes allows for more sophisticated interactions, such as the writer delegating complex research tasks to the researcher or querying specific information, thereby facilitating a seamless workflow.
+
+## Conclusion
+
+The integration of advanced attributes and functionalities into the CrewAI framework significantly enriches the agent collaboration ecosystem. These enhancements not only simplify interactions but also offer unprecedented flexibility and control, paving the way for sophisticated AI-driven solutions capable of tackling complex tasks through intelligent collaboration and delegation.

docs/concepts/crews.mdx

@@ -0,0 +1,339 @@
+---
+title: Crews
+description: Understanding and utilizing crews in the crewAI framework with comprehensive attributes and functionalities.
+icon: people-group
+---
+
+## What is a Crew?
+
+A crew in crewAI represents a collaborative group of agents working together to achieve a set of tasks. Each crew defines the strategy for task execution, agent collaboration, and the overall workflow.
+
+## Crew Attributes
+
+| Attribute                             | Parameters             | Description                                                                                                                                                                                                                                               |
+| :------------------------------------ | :--------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Tasks**                             | `tasks`                | A list of tasks assigned to the crew.                                                                                                                                                                                                                     |
+| **Agents**                            | `agents`               | A list of agents that are part of the crew.                                                                                                                                                                                                               |
+| **Process** _(optional)_              | `process`              | The process flow (e.g., sequential, hierarchical) the crew follows. Default is `sequential`.                                                                                                                                                              |
+| **Verbose** _(optional)_              | `verbose`              | The verbosity level for logging during execution. Defaults to `False`.                                                                                                                                                                                    |
+| **Manager LLM** _(optional)_          | `manager_llm`          | The language model used by the manager agent in a hierarchical process. **Required when using a hierarchical process.**                                                                                                                                   |
+| **Function Calling LLM** _(optional)_ | `function_calling_llm` | If passed, the crew will use this LLM to do function calling for tools for all agents in the crew. Each agent can have its own LLM, which overrides the crew's LLM for function calling.                                                                  |
+| **Config** _(optional)_               | `config`               | Optional configuration settings for the crew, in `Json` or `Dict[str, Any]` format.                                                                                                                                                                       |
+| **Max RPM** _(optional)_              | `max_rpm`              | Maximum requests per minute the crew adheres to during execution. Defaults to `None`.                                                                                                                                                                     |
+| **Language** _(optional)_             | `language`             | Language used for the crew, defaults to English.                                                                                                                                                                                                          |
+| **Language File** _(optional)_        | `language_file`        | Path to the language file to be used for the crew.                                                                                                                                                                                                        |
+| **Memory** _(optional)_               | `memory`               | Utilized for storing execution memories (short-term, long-term, entity memory).                                                                                                                                                                           |
+| **Memory Config** _(optional)_        | `memory_config`        | Configuration for the memory provider to be used by the crew.                                                                                                                                                                                          |
+| **Cache** _(optional)_                | `cache`                | Specifies whether to use a cache for storing the results of tools' execution. Defaults to `True`.                                                                                                                                                          |
+| **Embedder** _(optional)_             | `embedder`             | Configuration for the embedder to be used by the crew. Mostly used by memory for now. Default is `{"provider": "openai"}`.                                                                                                                                                                     |
+| **Full Output** _(optional)_          | `full_output`          | Whether the crew should return the full output with all tasks outputs or just the final output. Defaults to `False`.                                                                                                                                       |
+| **Step Callback** _(optional)_        | `step_callback`        | A function that is called after each step of every agent. This can be used to log the agent's actions or to perform other operations; it won't override the agent-specific `step_callback`.                                                               |
+| **Task Callback** _(optional)_        | `task_callback`        | A function that is called after the completion of each task. Useful for monitoring or additional operations post-task execution.                                                                                                                          |
+| **Share Crew** _(optional)_           | `share_crew`           | Whether you want to share the complete crew information and execution with the crewAI team to make the library better, and allow us to train models.                                                                                                      |
+| **Output Log File** _(optional)_      | `output_log_file`      | Whether you want to have a file with the complete crew output and execution. You can set it using True and it will default to the folder you are currently in and it will be called logs.txt or passing a string with the full path and name of the file. |
+| **Manager Agent** _(optional)_        | `manager_agent`        | `manager` sets a custom agent that will be used as a manager.                                                                                                                                                                                             |
+| **Prompt File** _(optional)_          | `prompt_file`          | Path to the prompt JSON file to be used for the crew.                                                                                                                                                                                                     |
+| **Planning** *(optional)*             | `planning`             | Adds planning ability to the Crew. When activated before each Crew iteration, all Crew data is sent to an AgentPlanner that will plan the tasks and this plan will be added to each task description.                                                     |
+| **Planning LLM** *(optional)*         | `planning_llm`         | The language model used by the AgentPlanner in a planning process.                                                                                                                                                                                        |
+
+<Tip>
+**Crew Max RPM**: The `max_rpm` attribute sets the maximum number of requests per minute the crew can perform to avoid rate limits and will override individual agents' `max_rpm` settings if you set it.
+</Tip>
+
+## Creating Crews
+
+There are two ways to create crews 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 crews and is consistent with how agents and tasks are defined in CrewAI projects.
+
+After creating your CrewAI project as outlined in the [Installation](/installation) section, you can define your crew in a class that inherits from `CrewBase` and uses decorators to define agents, tasks, and the crew itself.
+
+#### Example Crew Class with Decorators
+
+```python code
+from crewai import Agent, Crew, Task, Process
+from crewai.project import CrewBase, agent, task, crew, before_kickoff, after_kickoff
+
+
+@CrewBase
+class YourCrewName:
+    """Description of your crew"""
+
+    # Paths to your YAML configuration files
+    # To see an example agent and task defined in YAML, checkout the following:
+    # - Task: https://docs.crewai.com/concepts/tasks#yaml-configuration-recommended
+    # - Agents: https://docs.crewai.com/concepts/agents#yaml-configuration-recommended
+    agents_config = 'config/agents.yaml' 
+    tasks_config = 'config/tasks.yaml' 
+
+    @before_kickoff
+    def prepare_inputs(self, inputs):
+        # Modify inputs before the crew starts
+        inputs['additional_data'] = "Some extra information"
+        return inputs
+
+    @after_kickoff
+    def process_output(self, output):
+        # Modify output after the crew finishes
+        output.raw += "\nProcessed after kickoff."
+        return output
+
+    @agent
+    def agent_one(self) -> Agent:
+        return Agent(
+            config=self.agents_config['agent_one'],
+            verbose=True
+        )
+
+    @agent
+    def agent_two(self) -> Agent:
+        return Agent(
+            config=self.agents_config['agent_two'],
+            verbose=True
+        )
+
+    @task
+    def task_one(self) -> Task:
+        return Task(
+            config=self.tasks_config['task_one']
+        )
+
+    @task
+    def task_two(self) -> Task:
+        return Task(
+            config=self.tasks_config['task_two']
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        return Crew(
+            agents=self.agents,  # Automatically collected by the @agent decorator
+            tasks=self.tasks,    # Automatically collected by the @task decorator. 
+            process=Process.sequential,
+            verbose=True,
+        )
+```
+
+<Note>
+Tasks will be executed in the order they are defined.
+</Note>
+
+The `CrewBase` class, along with these decorators, automates the collection of agents and tasks, reducing the need for manual management.
+
+#### Decorators overview from `annotations.py`
+
+CrewAI provides several decorators in the `annotations.py` file that are used to mark methods within your crew class for special handling:
+
+- `@CrewBase`: Marks the class as a crew base class.
+- `@agent`: Denotes a method that returns an `Agent` object.
+- `@task`: Denotes a method that returns a `Task` object.
+- `@crew`: Denotes the method that returns the `Crew` object.
+- `@before_kickoff`: (Optional) Marks a method to be executed before the crew starts.
+- `@after_kickoff`: (Optional) Marks a method to be executed after the crew finishes.
+
+These decorators help in organizing your crew's structure and automatically collecting agents and tasks without manually listing them.
+
+### Direct Code Definition (Alternative)
+
+Alternatively, you can define the crew directly in code without using YAML configuration files.
+
+```python code
+from crewai import Agent, Crew, Task, Process
+from crewai_tools import YourCustomTool
+
+class YourCrewName:
+    def agent_one(self) -> Agent:
+        return Agent(
+            role="Data Analyst",
+            goal="Analyze data trends in the market",
+            backstory="An experienced data analyst with a background in economics",
+            verbose=True,
+            tools=[YourCustomTool()]
+        )
+
+    def agent_two(self) -> Agent:
+        return Agent(
+            role="Market Researcher",
+            goal="Gather information on market dynamics",
+            backstory="A diligent researcher with a keen eye for detail",
+            verbose=True
+        )
+
+    def task_one(self) -> Task:
+        return Task(
+            description="Collect recent market data and identify trends.",
+            expected_output="A report summarizing key trends in the market.",
+            agent=self.agent_one()
+        )
+
+    def task_two(self) -> Task:
+        return Task(
+            description="Research factors affecting market dynamics.",
+            expected_output="An analysis of factors influencing the market.",
+            agent=self.agent_two()
+        )
+
+    def crew(self) -> Crew:
+        return Crew(
+            agents=[self.agent_one(), self.agent_two()],
+            tasks=[self.task_one(), self.task_two()],
+            process=Process.sequential,
+            verbose=True
+        )
+```
+
+In this example:
+
+- Agents and tasks are defined directly within the class without decorators.
+- We manually create and manage the list of agents and tasks.
+- This approach provides more control but can be less maintainable for larger projects.
+
+## Crew Output
+
+The output of a crew in the CrewAI framework is encapsulated within the `CrewOutput` class.
+This class provides a structured way to access results of the crew's execution, including various formats such as raw strings, JSON, and Pydantic models.
+The `CrewOutput` includes the results from the final task output, token usage, and individual task outputs.
+
+### Crew Output Attributes
+
+| Attribute        | Parameters     | Type                       | Description                                                                                          |
+| :--------------- | :------------- | :------------------------- | :--------------------------------------------------------------------------------------------------- |
+| **Raw**          | `raw`          | `str`                      | The raw output of the crew. This is the default format for the output.                               |
+| **Pydantic**     | `pydantic`     | `Optional[BaseModel]`      | A Pydantic model object representing the structured output of the crew.                              |
+| **JSON Dict**    | `json_dict`    | `Optional[Dict[str, Any]]` | A dictionary representing the JSON output of the crew.                                               |
+| **Tasks Output** | `tasks_output` | `List[TaskOutput]`         | A list of `TaskOutput` objects, each representing the output of a task in the crew.                  |
+| **Token Usage**  | `token_usage`  | `Dict[str, Any]`           | A summary of token usage, providing insights into the language model's performance during execution. |
+
+### Crew Output Methods and Properties
+
+| Method/Property | Description                                                                                       |
+| :-------------- | :------------------------------------------------------------------------------------------------ |
+| **json**        | Returns the JSON string representation of the crew output if the output format is JSON.           |
+| **to_dict**     | Converts the JSON and Pydantic outputs to a dictionary.                                           |
+| \***\*str\*\*** | Returns the string representation of the crew output, prioritizing Pydantic, then JSON, then raw. |
+
+### Accessing Crew Outputs
+
+Once a crew has been executed, its output can be accessed through the `output` attribute of the `Crew` object. The `CrewOutput` class provides various ways to interact with and present this output.
+
+#### Example
+
+```python Code
+# Example crew execution
+crew = Crew(
+    agents=[research_agent, writer_agent],
+    tasks=[research_task, write_article_task],
+    verbose=True
+)
+
+crew_output = crew.kickoff()
+
+# Accessing the crew output
+print(f"Raw Output: {crew_output.raw}")
+if crew_output.json_dict:
+    print(f"JSON Output: {json.dumps(crew_output.json_dict, indent=2)}")
+if crew_output.pydantic:
+    print(f"Pydantic Output: {crew_output.pydantic}")
+print(f"Tasks Output: {crew_output.tasks_output}")
+print(f"Token Usage: {crew_output.token_usage}")
+```
+
+## Memory Utilization
+
+Crews can utilize memory (short-term, long-term, and entity memory) to enhance their execution and learning over time. This feature allows crews to store and recall execution memories, aiding in decision-making and task execution strategies.
+
+## Cache Utilization
+
+Caches can be employed to store the results of tools' execution, making the process more efficient by reducing the need to re-execute identical tasks.
+
+## Crew Usage Metrics
+
+After the crew execution, you can access the `usage_metrics` attribute to view the language model (LLM) usage metrics for all tasks executed by the crew. This provides insights into operational efficiency and areas for improvement.
+
+```python Code
+# Access the crew's usage metrics
+crew = Crew(agents=[agent1, agent2], tasks=[task1, task2])
+crew.kickoff()
+print(crew.usage_metrics)
+```
+
+## Crew Execution Process
+
+- **Sequential Process**: Tasks are executed one after another, allowing for a linear flow of work.
+- **Hierarchical Process**: A manager agent coordinates the crew, delegating tasks and validating outcomes before proceeding. **Note**: A `manager_llm` or `manager_agent` is required for this process and it's essential for validating the process flow.
+
+### Kicking Off a Crew
+
+Once your crew is assembled, initiate the workflow with the `kickoff()` method. This starts the execution process according to the defined process flow.
+
+```python Code
+# Start the crew's task execution
+result = my_crew.kickoff()
+print(result)
+```
+
+### Different Ways to Kick Off a Crew
+
+Once your crew is assembled, initiate the workflow with the appropriate kickoff method. CrewAI provides several methods for better control over the kickoff process: `kickoff()`, `kickoff_for_each()`, `kickoff_async()`, and `kickoff_for_each_async()`.
+
+- `kickoff()`: Starts the execution process according to the defined process flow.
+- `kickoff_for_each()`: Executes tasks for each agent individually.
+- `kickoff_async()`: Initiates the workflow asynchronously.
+- `kickoff_for_each_async()`: Executes tasks for each agent individually in an asynchronous manner.
+
+```python Code
+# Start the crew's task execution
+result = my_crew.kickoff()
+print(result)
+
+# Example of using kickoff_for_each
+inputs_array = [{'topic': 'AI in healthcare'}, {'topic': 'AI in finance'}]
+results = my_crew.kickoff_for_each(inputs=inputs_array)
+for result in results:
+    print(result)
+
+# Example of using kickoff_async
+inputs = {'topic': 'AI in healthcare'}
+async_result = my_crew.kickoff_async(inputs=inputs)
+print(async_result)
+
+# Example of using kickoff_for_each_async
+inputs_array = [{'topic': 'AI in healthcare'}, {'topic': 'AI in finance'}]
+async_results = my_crew.kickoff_for_each_async(inputs=inputs_array)
+for async_result in async_results:
+    print(async_result)
+```
+
+These methods provide flexibility in how you manage and execute tasks within your crew, allowing for both synchronous and asynchronous workflows tailored to your needs.
+
+### Replaying from a Specific Task
+
+You can now replay from a specific task using our CLI command `replay`.
+
+The replay feature in CrewAI allows you to replay from a specific task using the command-line interface (CLI). By running the command `crewai replay -t <task_id>`, you can specify the `task_id` for the replay process.
+
+Kickoffs will now save the latest kickoffs returned task outputs locally for you to be able to replay from.
+
+### Replaying from a Specific Task Using the CLI
+
+To use the replay feature, follow these steps:
+
+1. Open your terminal or command prompt.
+2. Navigate to the directory where your CrewAI project is located.
+3. Run the following command:
+
+To view the latest kickoff task IDs, use:
+
+```shell
+crewai log-tasks-outputs
+```
+
+Then, to replay from a specific task, use:
+
+```shell
+crewai replay -t <task_id>
+```
+
+These commands let you replay from your latest kickoff tasks, still retaining context from previously executed tasks.

docs/concepts/flows.mdx

@@ -0,0 +1,631 @@
+---
+title: Flows
+description: Learn how to create and manage AI workflows using CrewAI Flows.
+icon: arrow-progress
+---
+
+## Introduction
+
+CrewAI Flows is a powerful feature designed to streamline the creation and management of AI workflows. Flows allow developers to combine and coordinate coding tasks and Crews efficiently, providing a robust framework for building sophisticated AI automations.
+
+Flows allow you to create structured, event-driven workflows. They provide a seamless way to connect multiple tasks, manage state, and control the flow of execution in your AI applications. With Flows, you can easily design and implement multi-step processes that leverage the full potential of CrewAI's capabilities.
+
+1. **Simplified Workflow Creation**: Easily chain together multiple Crews and tasks to create complex AI workflows.
+
+2. **State Management**: Flows make it super easy to manage and share state between different tasks in your workflow.
+
+3. **Event-Driven Architecture**: Built on an event-driven model, allowing for dynamic and responsive workflows.
+
+4. **Flexible Control Flow**: Implement conditional logic, loops, and branching within your workflows.
+
+## 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
+
+from crewai.flow.flow import Flow, listen, start
+from dotenv import load_dotenv
+from litellm import completion
+
+
+class ExampleFlow(Flow):
+    model = "gpt-4o-mini"
+
+    @start()
+    def generate_city(self):
+        print("Starting flow")
+
+        response = completion(
+            model=self.model,
+            messages=[
+                {
+                    "role": "user",
+                    "content": "Return the name of a random city in the world.",
+                },
+            ],
+        )
+
+        random_city = response["choices"][0]["message"]["content"]
+        print(f"Random City: {random_city}")
+
+        return random_city
+
+    @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}",
+                },
+            ],
+        )
+
+        fun_fact = response["choices"][0]["message"]["content"]
+        return fun_fact
+
+
+
+flow = ExampleFlow()
+result = flow.kickoff()
+
+print(f"Generated fun fact: {result}")
+```
+
+In the above example, we have created a simple Flow that generates a random city using OpenAI and then generates a fun fact about that city. The Flow consists of two tasks: `generate_city` and `generate_fun_fact`. The `generate_city` task is the starting point of the Flow, and the `generate_fun_fact` task listens for the output of the `generate_city` task.
+
+When you run the Flow, it will generate a random city and then generate a fun fact about that city. The output will be printed to the console.
+
+**Note:** Ensure you have set up your `.env` file to store your `OPENAI_API_KEY`. This key is necessary for authenticating requests to the OpenAI API.
+
+### @start()
+
+The `@start()` decorator is used to mark a method as the starting point of a Flow. When a Flow is started, all the methods decorated with `@start()` are executed in parallel. You can have multiple start methods in a Flow, and they will all be executed when the Flow is started.
+
+### @listen()
+
+The `@listen()` decorator is used to mark a method as a listener for the output of another task in the Flow. The method decorated with `@listen()` will be executed when the specified task emits an output. The method can access the output of the task it is listening to as an argument.
+
+#### Usage
+
+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
+   @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
+   @listen(generate_city)
+   def generate_fun_fact(self, random_city):
+       # Implementation
+   ```
+
+### Flow Output
+
+Accessing and handling the output of a Flow is essential for integrating your AI workflows into larger applications or systems. CrewAI Flows provide straightforward mechanisms to retrieve the final output, access intermediate results, and manage the overall state of your Flow.
+
+#### Retrieving the Final Output
+
+When you run a Flow, the final output is determined by the last method that completes. The `kickoff()` method returns the output of this final method.
+
+Here's how you can access the final output:
+
+<CodeGroup>
+```python Code
+from crewai.flow.flow import Flow, listen, start
+
+class OutputExampleFlow(Flow):
+    @start()
+    def first_method(self):
+        return "Output from first_method"
+
+    @listen(first_method)
+    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
+---- Final Output ----
+Second method received: Output from first_method
+````
+
+</CodeGroup>
+
+In this example, the `second_method` is the last method to complete, so its output will be the final output of the Flow.
+The `kickoff()` method will return the final output, which is then printed to the console.
+
+#### Accessing and Updating State
+
+In addition to retrieving the final output, you can also access and update the state within your Flow. The state can be used to store and share data between different methods in the Flow. After the Flow has run, you can access the state to retrieve any information that was added or updated during the execution.
+
+Here's an example of how to update and access the state:
+
+<CodeGroup>
+
+```python Code
+from crewai.flow.flow import Flow, listen, start
+from pydantic import BaseModel
+
+class ExampleState(BaseModel):
+    counter: int = 0
+    message: str = ""
+
+class StateExampleFlow(Flow[ExampleState]):
+
+    @start()
+    def first_method(self):
+        self.state.message = "Hello from first_method"
+        self.state.counter += 1
+
+    @listen(first_method)
+    def second_method(self):
+        self.state.message += " - updated by second_method"
+        self.state.counter += 1
+        return self.state.message
+
+flow = StateExampleFlow()
+final_output = flow.kickoff()
+print(f"Final Output: {final_output}")
+print("Final State:")
+print(flow.state)
+```
+
+```text Output
+Final Output: Hello from first_method - updated by second_method
+Final State:
+counter=2 message='Hello from first_method - updated by second_method'
+```
+
+</CodeGroup>
+
+In this example, the state is updated by both `first_method` and `second_method`.
+After the Flow has run, you can access the final state to see the updates made by these methods.
+
+By ensuring that the final method's output is returned and providing access to the state, CrewAI Flows make it easy to integrate the results of your AI workflows into larger applications or systems,
+while also maintaining and accessing the state throughout the Flow's execution.
+
+## Flow State Management
+
+Managing state effectively is crucial for building reliable and maintainable AI workflows. CrewAI Flows provides robust mechanisms for both unstructured and structured state management,
+allowing developers to choose the approach that best fits their application's needs.
+
+### Unstructured State Management
+
+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
+from crewai.flow.flow import Flow, listen, start
+
+class UntructuredExampleFlow(Flow):
+
+    @start()
+    def first_method(self):
+        self.state.message = "Hello from structured flow"
+        self.state.counter = 0
+
+    @listen(first_method)
+    def second_method(self):
+        self.state.counter += 1
+        self.state.message += " - updated"
+
+    @listen(second_method)
+    def third_method(self):
+        self.state.counter += 1
+        self.state.message += " - updated again"
+
+        print(f"State after third_method: {self.state}")
+
+
+flow = UntructuredExampleFlow()
+flow.kickoff()
+```
+
+**Key Points:**
+
+- **Flexibility:** You can dynamically add attributes to `self.state` without predefined constraints.
+- **Simplicity:** Ideal for straightforward workflows where state structure is minimal or varies significantly.
+
+### Structured State Management
+
+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
+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()
+    def first_method(self):
+        self.state.message = "Hello from structured flow"
+
+    @listen(first_method)
+    def second_method(self):
+        self.state.counter += 1
+        self.state.message += " - updated"
+
+    @listen(second_method)
+    def third_method(self):
+        self.state.counter += 1
+        self.state.message += " - updated again"
+
+        print(f"State after third_method: {self.state}")
+
+
+flow = StructuredExampleFlow()
+flow.kickoff()
+```
+
+**Key Points:**
+
+- **Defined Schema:** `ExampleState` clearly outlines the state structure, enhancing code readability and maintainability.
+- **Type Safety:** Leveraging Pydantic ensures that state attributes adhere to the specified types, reducing runtime errors.
+- **Auto-Completion:** IDEs can provide better auto-completion and error checking based on the defined state model.
+
+### Choosing Between Unstructured and Structured State Management
+
+- **Use Unstructured State Management when:**
+
+  - The workflow's state is simple or highly dynamic.
+  - Flexibility is prioritized over strict state definitions.
+  - Rapid prototyping is required without the overhead of defining schemas.
+
+- **Use Structured State Management when:**
+  - The workflow requires a well-defined and consistent state structure.
+  - Type safety and validation are important for your application's reliability.
+  - You want to leverage IDE features like auto-completion and type checking for better developer experience.
+
+By providing both unstructured and structured state management options, CrewAI Flows empowers developers to build AI workflows that are both flexible and robust, catering to a wide range of application requirements.
+
+## Flow Control
+
+### Conditional Logic: `or`
+
+The `or_` function in Flows allows you to listen to multiple methods and trigger the listener method when any of the specified methods emit an output.
+
+<CodeGroup>
+
+```python Code
+from crewai.flow.flow import Flow, listen, or_, start
+
+class OrExampleFlow(Flow):
+
+    @start()
+    def start_method(self):
+        return "Hello from the start method"
+
+    @listen(start_method)
+    def second_method(self):
+        return "Hello from the second method"
+
+    @listen(or_(start_method, second_method))
+    def logger(self, result):
+        print(f"Logger: {result}")
+
+
+
+flow = OrExampleFlow()
+flow.kickoff()
+```
+
+```text Output
+Logger: Hello from the start method
+Logger: Hello from the second method
+```
+
+</CodeGroup>
+
+When you run this Flow, the `logger` method will be triggered by the output of either the `start_method` or the `second_method`.
+The `or_` function is used to listen to multiple methods and trigger the listener method when any of the specified methods emit an output.
+
+### Conditional Logic: `and`
+
+The `and_` function in Flows allows you to listen to multiple methods and trigger the listener method only when all the specified methods emit an output.
+
+<CodeGroup>
+
+```python Code
+from crewai.flow.flow import Flow, and_, listen, start
+
+class AndExampleFlow(Flow):
+
+    @start()
+    def start_method(self):
+        self.state["greeting"] = "Hello from the start method"
+
+    @listen(start_method)
+    def second_method(self):
+        self.state["joke"] = "What do computers eat? Microchips."
+
+    @listen(and_(start_method, second_method))
+    def logger(self):
+        print("---- Logger ----")
+        print(self.state)
+
+flow = AndExampleFlow()
+flow.kickoff()
+```
+
+```text Output
+---- Logger ----
+{'greeting': 'Hello from the start method', 'joke': 'What do computers eat? Microchips.'}
+```
+
+</CodeGroup>
+
+When you run this Flow, the `logger` method will be triggered only when both the `start_method` and the `second_method` emit an output.
+The `and_` function is used to listen to multiple methods and trigger the listener method only when all the specified methods emit an output.
+
+### Router
+
+The `@router()` decorator in Flows allows you to define conditional routing logic based on the output of a method.
+You can specify different routes based on the output of the method, allowing you to control the flow of execution dynamically.
+
+<CodeGroup>
+
+```python Code
+import random
+from crewai.flow.flow import Flow, listen, router, start
+from pydantic import BaseModel
+
+class ExampleState(BaseModel):
+    success_flag: bool = False
+
+class RouterFlow(Flow[ExampleState]):
+
+    @start()
+    def start_method(self):
+        print("Starting the structured flow")
+        random_boolean = random.choice([True, False])
+        self.state.success_flag = random_boolean
+
+    @router(start_method)
+    def second_method(self):
+        if self.state.success_flag:
+            return "success"
+        else:
+            return "failed"
+
+    @listen("success")
+    def third_method(self):
+        print("Third method running")
+
+    @listen("failed")
+    def fourth_method(self):
+        print("Fourth method running")
+
+
+flow = RouterFlow()
+flow.kickoff()
+```
+
+```text Output
+Starting the structured flow
+Third method running
+Fourth method running
+```
+
+</CodeGroup>
+
+In the above example, the `start_method` generates a random boolean value and sets it in the state.
+The `second_method` uses the `@router()` decorator to define conditional routing logic based on the value of the boolean.
+If the boolean is `True`, the method returns `"success"`, and if it is `False`, the method returns `"failed"`.
+The `third_method` and `fourth_method` listen to the output of the `second_method` and execute based on the returned value.
+
+When you run this Flow, the output will change based on the random boolean value generated by the `start_method`.
+
+## Adding Crews to Flows
+
+Creating a flow with multiple crews in CrewAI is straightforward.
+
+You can generate a new CrewAI project that includes all the scaffolding needed to create a flow with multiple crews by running the following command:
+
+```bash
+crewai create flow name_of_flow
+```
+
+This command will generate a new CrewAI project with the necessary folder structure. The generated project includes a prebuilt crew called `poem_crew` that is already working. You can use this crew as a template by copying, pasting, and editing it to create other crews.
+
+### Folder Structure
+
+After running the `crewai create flow name_of_flow` command, you will see a folder structure similar to the following:
+
+| Directory/File         | Description                                                        |
+| :--------------------- | :----------------------------------------------------------------- |
+| `name_of_flow/`        | Root directory for the flow.                                       |
+| ├── `crews/`           | Contains directories for specific crews.                           |
+| │ └── `poem_crew/`     | Directory for the "poem_crew" with its configurations and scripts. |
+| │ ├── `config/`        | Configuration files directory for the "poem_crew".                 |
+| │ │ ├── `agents.yaml`  | YAML file defining the agents for "poem_crew".                     |
+| │ │ └── `tasks.yaml`   | YAML file defining the tasks for "poem_crew".                      |
+| │ ├── `poem_crew.py`   | Script for "poem_crew" functionality.                              |
+| ├── `tools/`           | Directory for additional tools used in the flow.                   |
+| │ └── `custom_tool.py` | Custom tool implementation.                                        |
+| ├── `main.py`          | Main script for running the flow.                                  |
+| ├── `README.md`        | Project description and instructions.                              |
+| ├── `pyproject.toml`   | Configuration file for project dependencies and settings.          |
+| └── `.gitignore`       | Specifies files and directories to ignore in version control.      |
+
+### Building Your Crews
+
+In the `crews` folder, you can define multiple crews. Each crew will have its own folder containing configuration files and the crew definition file. For example, the `poem_crew` folder contains:
+
+- `config/agents.yaml`: Defines the agents for the crew.
+- `config/tasks.yaml`: Defines the tasks for the crew.
+- `poem_crew.py`: Contains the crew definition, including agents, tasks, and the crew itself.
+
+You can copy, paste, and edit the `poem_crew` to create other crews.
+
+### Connecting Crews in `main.py`
+
+The `main.py` file is where you create your flow and connect the crews together. You can define your flow by using the `Flow` class and the decorators `@start` and `@listen` to specify the flow of execution.
+
+Here's an example of how you can connect the `poem_crew` in the `main.py` file:
+
+```python Code
+#!/usr/bin/env python
+from random import randint
+
+from pydantic import BaseModel
+from crewai.flow.flow import Flow, listen, start
+from .crews.poem_crew.poem_crew import PoemCrew
+
+class PoemState(BaseModel):
+    sentence_count: int = 1
+    poem: str = ""
+
+class PoemFlow(Flow[PoemState]):
+
+    @start()
+    def generate_sentence_count(self):
+        print("Generating sentence count")
+        self.state.sentence_count = randint(1, 5)
+
+    @listen(generate_sentence_count)
+    def generate_poem(self):
+        print("Generating poem")
+        result = PoemCrew().crew().kickoff(inputs={"sentence_count": self.state.sentence_count})
+
+        print("Poem generated", result.raw)
+        self.state.poem = result.raw
+
+    @listen(generate_poem)
+    def save_poem(self):
+        print("Saving poem")
+        with open("poem.txt", "w") as f:
+            f.write(self.state.poem)
+
+def kickoff():
+    poem_flow = PoemFlow()
+    poem_flow.kickoff()
+
+
+def plot():
+    poem_flow = PoemFlow()
+    poem_flow.plot()
+
+if __name__ == "__main__":
+    kickoff()
+```
+
+In this example, the `PoemFlow` class defines a flow that generates a sentence count, uses the `PoemCrew` to generate a poem, and then saves the poem to a file. The flow is kicked off by calling the `kickoff()` method.
+
+### Running the Flow
+
+(Optional) Before running the flow, you can install the dependencies by running:
+
+```bash
+crewai install
+```
+
+Once all of the dependencies are installed, you need to activate the virtual environment by running:
+
+```bash
+source .venv/bin/activate
+```
+
+After activating the virtual environment, you can run the flow by executing one of the following commands:
+
+```bash
+crewai flow kickoff
+```
+
+or
+
+```bash
+uv run kickoff
+```
+
+The flow will execute, and you should see the output in the console.
+
+## 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.
+
+### What are Plots?
+
+Plots in CrewAI are graphical representations of your AI workflows. They display the various tasks, their connections, and the flow of data between them. This visualization helps in understanding the sequence of operations, identifying bottlenecks, and ensuring that the workflow logic aligns with your expectations.
+
+### How to Generate a Plot
+
+CrewAI provides two convenient methods to generate plots of your flows:
+
+#### Option 1: Using the `plot()` Method
+
+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
+# Assuming you have a flow instance
+flow.plot("my_flow_plot")
+```
+
+This will generate a file named `my_flow_plot.html` in your current directory. You can open this file in a web browser to view the interactive plot.
+
+#### Option 2: Using the Command Line
+
+If you are working within a structured CrewAI project, you can generate a plot using the command line. This is particularly useful for larger projects where you want to visualize the entire flow setup.
+
+```bash
+crewai flow plot
+```
+
+This command will generate an HTML file with the plot of your flow, similar to the `plot()` method. The file will be saved in your project directory, and you can open it in a web browser to explore the flow.
+
+### Understanding the Plot
+
+The generated plot will display nodes representing the tasks in your flow, with directed edges indicating the flow of execution. The plot is interactive, allowing you to zoom in and out, and hover over nodes to see additional details.
+
+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.
+
+## 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:
+
+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)
+
+2. **Lead Score Flow**: This flow showcases adding human-in-the-loop feedback and handling different conditional branches using the router. It's an excellent example of how to incorporate dynamic decision-making and human oversight into your workflows. [View Example](https://github.com/crewAIInc/crewAI-examples/tree/main/lead-score-flow)
+
+3. **Write a Book Flow**: This example excels at chaining multiple crews together, where the output of one crew is used by another. Specifically, one crew outlines an entire book, and another crew generates chapters based on the outline. Eventually, everything is connected to produce a complete book. This flow is perfect for complex, multi-step processes that require coordination between different tasks. [View Example](https://github.com/crewAIInc/crewAI-examples/tree/main/write_a_book_with_flows)
+
+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)
+
+By exploring these examples, you can gain insights into how to leverage CrewAI Flows for various use cases, from automating repetitive tasks to managing complex, multi-step processes with dynamic decision-making and human feedback.
+
+Also, check out our YouTube video on how to use flows in CrewAI below!
+
+<iframe
+  width="560"
+  height="315"
+  src="https://www.youtube.com/embed/MTb5my6VOT8"
+  title="YouTube video player"
+  frameborder="0"
+  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+  referrerpolicy="strict-origin-when-cross-origin"
+  allowfullscreen
+></iframe>

docs/concepts/knowledge.mdx

@@ -0,0 +1,420 @@
+---
+title: Knowledge
+description: What is knowledge in CrewAI and how to use it.
+icon: book
+---
+
+# Using Knowledge in CrewAI
+
+## 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.
+
+<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>
+
+## Supported Knowledge Sources
+
+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 an example using string-based knowledge:
+
+```python Code
+from crewai import Agent, Task, Crew, Process, LLM
+from crewai.knowledge.source.string_knowledge_source import StringKnowledgeSource
+
+# Create a knowledge source
+content = "Users name is John. He is 30 years old and lives in San Francisco."
+string_source = StringKnowledgeSource(
+    content=content,
+)
+
+# Create an LLM with a temperature of 0 to ensure deterministic outputs
+llm = LLM(model="gpt-4o-mini", temperature=0)
+
+# 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,
+    allow_delegation=False,
+    llm=llm,
+)
+task = Task(
+    description="Answer the following questions about the user: {question}",
+    expected_output="An answer to the question.",
+    agent=agent,
+)
+
+crew = Crew(
+    agents=[agent],
+    tasks=[task],
+    verbose=True,
+    process=Process.sequential,
+    knowledge_sources=[string_source], # Enable knowledge by adding the sources here. You can also add more sources to the sources list.
+)
+
+result = crew.kickoff(inputs={"question": "What city does John live in and how old is he?"})
+```
+
+
+Here's another example with the `CrewDoclingSource`
+```python Code
+from crewai import LLM, Agent, Crew, Process, Task
+from crewai.knowledge.source.crew_docling_source import CrewDoclingSource
+
+# Create a knowledge source
+content_source = CrewDoclingSource(
+    file_paths=[
+        "https://lilianweng.github.io/posts/2024-11-28-reward-hacking",
+        "https://lilianweng.github.io/posts/2024-07-07-hallucination",
+    ],
+)
+
+# Create an LLM with a temperature of 0 to ensure deterministic outputs
+llm = LLM(model="gpt-4o-mini", temperature=0)
+
+# Create an agent with the knowledge store
+agent = Agent(
+    role="About papers",
+    goal="You know everything about the papers.",
+    backstory="""You are a master at understanding papers and their content.""",
+    verbose=True,
+    allow_delegation=False,
+    llm=llm,
+)
+task = Task(
+    description="Answer the following questions about the papers: {question}",
+    expected_output="An answer to the question.",
+    agent=agent,
+)
+
+crew = Crew(
+    agents=[agent],
+    tasks=[task],
+    verbose=True,
+    process=Process.sequential,
+    knowledge_sources=[
+        content_source
+    ],  # Enable knowledge by adding the sources here. You can also add more sources to the sources list.
+)
+
+result = crew.kickoff(
+    inputs={
+        "question": "What is the reward hacking paper about? Be sure to provide sources."
+    }
+)
+```
+
+## Knowledge Configuration
+
+### Chunking Configuration
+
+Control how content is split for processing by setting the chunk size and overlap.
+
+```python Code
+knowledge_source = StringKnowledgeSource(
+    content="Long content...",
+    chunk_size=4000,     # Characters per chunk (default)
+    chunk_overlap=200    # Overlap between chunks (default)
+)
+```
+
+## 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 Code
+...
+string_source = StringKnowledgeSource(
+    content="Users name is John. He is 30 years old and lives in San Francisco.",
+)
+crew = Crew(
+    ...
+    knowledge_sources=[string_source],
+    embedder={
+        "provider": "openai",
+        "config": {"model": "text-embedding-3-small"},
+    },
+)
+```
+
+## Clearing Knowledge
+
+If you need to clear the knowledge stored in CrewAI, you can use the `crewai reset-memories` command with the `--knowledge` option.
+
+```bash Command
+crewai reset-memories --knowledge
+```
+
+This is useful when you've updated your knowledge sources and want to ensure that the agents are using the most recent information.
+
+## Agent-Specific Knowledge
+
+While knowledge can be provided at the crew level using `crew.knowledge_sources`, individual agents can also have their own knowledge sources using the `knowledge_sources` parameter:
+
+```python Code
+from crewai import Agent, Task, Crew
+from crewai.knowledge.source.string_knowledge_source import StringKnowledgeSource
+
+# Create agent-specific knowledge about a product
+product_specs = StringKnowledgeSource(
+    content="""The XPS 13 laptop features:
+    - 13.4-inch 4K display
+    - Intel Core i7 processor
+    - 16GB RAM
+    - 512GB SSD storage
+    - 12-hour battery life""",
+    metadata={"category": "product_specs"}
+)
+
+# Create a support agent with product knowledge
+support_agent = Agent(
+    role="Technical Support Specialist",
+    goal="Provide accurate product information and support.",
+    backstory="You are an expert on our laptop products and specifications.",
+    knowledge_sources=[product_specs]  # Agent-specific knowledge
+)
+
+# Create a task that requires product knowledge
+support_task = Task(
+    description="Answer this customer question: {question}",
+    agent=support_agent
+)
+
+# Create and run the crew
+crew = Crew(
+    agents=[support_agent],
+    tasks=[support_task]
+)
+
+# Get answer about the laptop's specifications
+result = crew.kickoff(
+    inputs={"question": "What is the storage capacity of the XPS 13?"}
+)
+```
+
+<Info>
+  Benefits of agent-specific knowledge:
+  - Give agents specialized information for their roles
+  - Maintain separation of concerns between agents
+  - Combine with crew-level knowledge for layered information access
+</Info>
+
+## Custom Knowledge Sources
+
+CrewAI allows you to create custom knowledge sources for any type of data by extending the `BaseKnowledgeSource` class. Let's create a practical example that fetches and processes space news articles.
+
+#### Space News Knowledge Source Example
+
+<CodeGroup>
+
+```python Code
+from crewai import Agent, Task, Crew, Process, LLM
+from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
+import requests
+from datetime import datetime
+from typing import Dict, Any
+from pydantic import BaseModel, Field
+
+class SpaceNewsKnowledgeSource(BaseKnowledgeSource):
+    """Knowledge source that fetches data from Space News API."""
+
+    api_endpoint: str = Field(description="API endpoint URL")
+    limit: int = Field(default=10, description="Number of articles to fetch")
+
+    def load_content(self) -> Dict[Any, str]:
+        """Fetch and format space news articles."""
+        try:
+            response = requests.get(
+                f"{self.api_endpoint}?limit={self.limit}"
+            )
+            response.raise_for_status()
+
+            data = response.json()
+            articles = data.get('results', [])
+
+            formatted_data = self._format_articles(articles)
+            return {self.api_endpoint: formatted_data}
+        except Exception as e:
+            raise ValueError(f"Failed to fetch space news: {str(e)}")
+
+    def _format_articles(self, articles: list) -> str:
+        """Format articles into readable text."""
+        formatted = "Space News Articles:\n\n"
+        for article in articles:
+            formatted += f"""
+                Title: {article['title']}
+                Published: {article['published_at']}
+                Summary: {article['summary']}
+                News Site: {article['news_site']}
+                URL: {article['url']}
+                -------------------"""
+        return formatted
+
+    def add(self) -> None:
+        """Process and store the articles."""
+        content = self.load_content()
+        for _, text in content.items():
+            chunks = self._chunk_text(text)
+            self.chunks.extend(chunks)
+
+        self._save_documents()
+
+# Create knowledge source
+recent_news = SpaceNewsKnowledgeSource(
+    api_endpoint="https://api.spaceflightnewsapi.net/v4/articles",
+    limit=10,
+)
+
+# Create specialized agent
+space_analyst = Agent(
+    role="Space News Analyst",
+    goal="Answer questions about space news accurately and comprehensively",
+    backstory="""You are a space industry analyst with expertise in space exploration,
+    satellite technology, and space industry trends. You excel at answering questions
+    about space news and providing detailed, accurate information.""",
+    knowledge_sources=[recent_news],
+    llm=LLM(model="gpt-4", temperature=0.0)
+)
+
+# Create task that handles user questions
+analysis_task = Task(
+    description="Answer this question about space news: {user_question}",
+    expected_output="A detailed answer based on the recent space news articles",
+    agent=space_analyst
+)
+
+# Create and run the crew
+crew = Crew(
+    agents=[space_analyst],
+    tasks=[analysis_task],
+    verbose=True,
+    process=Process.sequential
+)
+
+# Example usage
+result = crew.kickoff(
+    inputs={"user_question": "What are the latest developments in space exploration?"}
+)
+```
+
+```output Output
+# Agent: Space News Analyst
+## Task: Answer this question about space news: What are the latest developments in space exploration?
+
+
+# Agent: Space News Analyst
+## Final Answer:
+The latest developments in space exploration, based on recent space news articles, include the following:
+
+1. SpaceX has received the final regulatory approvals to proceed with the second integrated Starship/Super Heavy launch, scheduled for as soon as the morning of Nov. 17, 2023. This is a significant step in SpaceX's ambitious plans for space exploration and colonization. [Source: SpaceNews](https://spacenews.com/starship-cleared-for-nov-17-launch/)
+
+2. SpaceX has also informed the US Federal Communications Commission (FCC) that it plans to begin launching its first next-generation Starlink Gen2 satellites. This represents a major upgrade to the Starlink satellite internet service, which aims to provide high-speed internet access worldwide. [Source: Teslarati](https://www.teslarati.com/spacex-first-starlink-gen2-satellite-launch-2022/)
+
+3. AI startup Synthetaic has raised $15 million in Series B funding. The company uses artificial intelligence to analyze data from space and air sensors, which could have significant applications in space exploration and satellite technology. [Source: SpaceNews](https://spacenews.com/ai-startup-synthetaic-raises-15-million-in-series-b-funding/)
+
+4. The Space Force has formally established a unit within the U.S. Indo-Pacific Command, marking a permanent presence in the Indo-Pacific region. This could have significant implications for space security and geopolitics. [Source: SpaceNews](https://spacenews.com/space-force-establishes-permanent-presence-in-indo-pacific-region/)
+
+5. Slingshot Aerospace, a space tracking and data analytics company, is expanding its network of ground-based optical telescopes to increase coverage of low Earth orbit. This could improve our ability to track and analyze objects in low Earth orbit, including satellites and space debris. [Source: SpaceNews](https://spacenews.com/slingshots-space-tracking-network-to-extend-coverage-of-low-earth-orbit/)
+
+6. The National Natural Science Foundation of China has outlined a five-year project for researchers to study the assembly of ultra-large spacecraft. This could lead to significant advancements in spacecraft technology and space exploration capabilities. [Source: SpaceNews](https://spacenews.com/china-researching-challenges-of-kilometer-scale-ultra-large-spacecraft/)
+
+7. The Center for AEroSpace Autonomy Research (CAESAR) at Stanford University is focusing on spacecraft autonomy. The center held a kickoff event on May 22, 2024, to highlight the industry, academia, and government collaboration it seeks to foster. This could lead to significant advancements in autonomous spacecraft technology. [Source: SpaceNews](https://spacenews.com/stanford-center-focuses-on-spacecraft-autonomy/)
+```
+
+</CodeGroup>
+#### Key Components Explained
+
+1. **Custom Knowledge Source (`SpaceNewsKnowledgeSource`)**:
+
+   - Extends `BaseKnowledgeSource` for integration with CrewAI
+   - Configurable API endpoint and article limit
+   - Implements three key methods:
+     - `load_content()`: Fetches articles from the API
+     - `_format_articles()`: Structures the articles into readable text
+     - `add()`: Processes and stores the content
+
+2. **Agent Configuration**:
+
+   - Specialized role as a Space News Analyst
+   - Uses the knowledge source to access space news
+
+3. **Task Setup**:
+
+   - Takes a user question as input through `{user_question}`
+   - Designed to provide detailed answers based on the knowledge source
+
+4. **Crew Orchestration**:
+   - Manages the workflow between agent and task
+   - Handles input/output through the kickoff method
+
+This example demonstrates how to:
+
+- Create a custom knowledge source that fetches real-time data
+- Process and format external data for AI consumption
+- Use the knowledge source to answer specific user questions
+- Integrate everything seamlessly with CrewAI's agent system
+
+#### About the Spaceflight News API
+
+The example uses the [Spaceflight News API](https://api.spaceflightnewsapi.net/v4/docs/), which:
+
+- Provides free access to space-related news articles
+- Requires no authentication
+- Returns structured data about space news
+- Supports pagination and filtering
+
+You can customize the API query by modifying the endpoint URL:
+
+```python
+# Fetch more articles
+recent_news = SpaceNewsKnowledgeSource(
+    api_endpoint="https://api.spaceflightnewsapi.net/v4/articles",
+    limit=20,  # Increase the number of articles
+)
+
+# Add search parameters
+recent_news = SpaceNewsKnowledgeSource(
+    api_endpoint="https://api.spaceflightnewsapi.net/v4/articles?search=NASA", # Search for NASA news
+    limit=10,
+)
+```
+
+## Best Practices
+
+<AccordionGroup>
+  <Accordion title="Content Organization">
+    - Keep chunk sizes appropriate for your content type
+    - Consider content overlap for context preservation
+    - Organize related information into separate knowledge sources
+  </Accordion>
+
+  <Accordion title="Performance Tips">
+    - Adjust chunk sizes based on content complexity 
+    - Configure appropriate embedding models
+    - Consider using local embedding providers for faster processing
+  </Accordion>
+</AccordionGroup>

docs/concepts/langchain-tools.mdx

@@ -0,0 +1,58 @@
+---
+title: Using LangChain Tools
+description: Learn how to integrate LangChain tools with CrewAI agents to enhance search-based queries and more.
+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.
+</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
+
+# Set up your SERPER_API_KEY key in an .env file, eg:
+# SERPER_API_KEY=<your api key>
+load_dotenv()
+
+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)
+
+    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
+)
+
+# rest of the code ...
+```
+
+## 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.

docs/concepts/llamaindex-tools.mdx

@@ -0,0 +1,71 @@
+---
+title: Using LlamaIndex Tools
+description: Learn how to integrate LlamaIndex tools with CrewAI agents to enhance search-based queries and more.
+icon: toolbox
+---
+
+## Using LlamaIndex Tools
+
+<Info>
+    CrewAI seamlessly integrates with LlamaIndex’s comprehensive toolkit for RAG (Retrieval-Augmented Generation) and agentic pipelines, enabling advanced search-based queries and more. 
+</Info>
+
+Here are the available built-in tools offered by LlamaIndex.
+
+```python Code
+from crewai import Agent
+from crewai_tools import LlamaIndexTool
+
+# Example 1: Initialize from FunctionTool
+from llama_index.core.tools import FunctionTool
+
+your_python_function = lambda ...: ...
+og_tool = FunctionTool.from_defaults(
+    your_python_function, 
+    name="<name>", 
+    description='<description>'
+)
+tool = LlamaIndexTool.from_tool(og_tool)
+
+# Example 2: Initialize from LlamaHub Tools
+from llama_index.tools.wolfram_alpha import WolframAlphaToolSpec
+wolfram_spec = WolframAlphaToolSpec(app_id="<app_id>")
+wolfram_tools = wolfram_spec.to_tool_list()
+tools = [LlamaIndexTool.from_tool(t) for t in wolfram_tools]
+
+# Example 3: Initialize Tool from a LlamaIndex Query Engine
+query_engine = index.as_query_engine()
+query_tool = LlamaIndexTool.from_query_engine(
+    query_engine,
+    name="Uber 2019 10K Query Tool",
+    description="Use this tool to lookup the 2019 Uber 10K Annual Report"
+)
+
+# Create and assign the tools to an agent
+agent = Agent(
+    role='Research Analyst',
+    goal='Provide up-to-date market analysis',
+    backstory='An expert analyst with a keen eye for market trends.',
+    tools=[tool, *tools, query_tool]
+)
+
+# rest of the code ...
+```
+
+## Steps to Get Started
+
+To effectively use the LlamaIndexTool, follow these steps:
+
+<Steps>
+    <Step title="Package Installation">
+    Make sure that `crewai[tools]` package is installed in your Python environment:
+    <CodeGroup>
+        ```shell Terminal
+        pip install 'crewai[tools]'
+        ```
+    </CodeGroup>
+    </Step>
+    <Step title="Install and Use LlamaIndex">
+    Follow the LlamaIndex documentation [LlamaIndex Documentation](https://docs.llamaindex.ai/) to set up a RAG/agent pipeline.
+    </Step>
+</Steps>

docs/concepts/llms.mdx

@@ -0,0 +1,730 @@
+---
+title: 'LLMs'
+description: 'A comprehensive guide to configuring and using Large Language Models (LLMs) in 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>
+
+## What are LLMs?
+
+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:
+
+<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>
+
+## Available Models and Their Capabilities
+
+Here's a detailed breakdown of supported models and their capabilities, you can compare performance at [lmarena.ai](https://lmarena.ai/?leaderboard) and [artificialanalysis.ai](https://artificialanalysis.ai/):
+
+<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 |
+
+    <Note>
+      1 token ≈ 4 characters in English. For example, 8,192 tokens ≈ 32,768 characters or about 6,000 words.
+    </Note>
+  </Tab>
+  <Tab title="Nvidia NIM">
+    | Model | Context Window | Best For |
+    |-------|---------------|-----------|
+    | nvidia/mistral-nemo-minitron-8b-8k-instruct | 8,192 tokens | State-of-the-art small language model delivering superior accuracy for chatbot, virtual assistants, and content generation. |
+    | nvidia/nemotron-4-mini-hindi-4b-instruct| 4,096 tokens | A bilingual Hindi-English SLM for on-device inference, tailored specifically for Hindi Language. |
+    | "nvidia/llama-3.1-nemotron-70b-instruct | 128k tokens | Llama-3.1-Nemotron-70B-Instruct is a large language model customized by NVIDIA in order to improve the helpfulness of LLM generated responses. |
+    | nvidia/llama3-chatqa-1.5-8b | 128k tokens | Advanced LLM to generate high-quality, context-aware responses for chatbots and search engines. |
+    | nvidia/llama3-chatqa-1.5-70b | 128k tokens | Advanced LLM to generate high-quality, context-aware responses for chatbots and search engines. |
+    | nvidia/vila | 128k tokens | Multi-modal vision-language model that understands text/img/video and creates informative responses |
+    | nvidia/neva-22| 4,096 tokens | Multi-modal vision-language model that understands text/images and generates informative responses |
+    | nvidia/nemotron-mini-4b-instruct | 8,192 tokens | General-purpose tasks |
+    | nvidia/usdcode-llama3-70b-instruct | 128k tokens | State-of-the-art LLM that answers OpenUSD knowledge queries and generates USD-Python code. |
+    | nvidia/nemotron-4-340b-instruct | 4,096 tokens | Creates diverse synthetic data that mimics the characteristics of real-world data. |
+    | meta/codellama-70b | 100k tokens | LLM capable of generating code from natural language and vice versa. |
+    | meta/llama2-70b | 4,096 tokens | Cutting-edge large language AI model capable of generating text and code in response to prompts. |
+    | meta/llama3-8b-instruct | 8,192 tokens | Advanced state-of-the-art LLM with language understanding, superior reasoning, and text generation. |
+    | meta/llama3-70b-instruct | 8,192 tokens | Powers complex conversations with superior contextual understanding, reasoning and text generation. |
+    | meta/llama-3.1-8b-instruct | 128k tokens | Advanced state-of-the-art model with language understanding, superior reasoning, and text generation. |
+    | meta/llama-3.1-70b-instruct | 128k tokens | Powers complex conversations with superior contextual understanding, reasoning and text generation. |
+    | meta/llama-3.1-405b-instruct | 128k tokens | Advanced LLM for synthetic data generation, distillation, and inference for chatbots, coding, and domain-specific tasks. |
+    | meta/llama-3.2-1b-instruct | 128k tokens | Advanced state-of-the-art small language model with language understanding, superior reasoning, and text generation. |
+    | meta/llama-3.2-3b-instruct | 128k tokens | Advanced state-of-the-art small language model with language understanding, superior reasoning, and text generation. |
+    | meta/llama-3.2-11b-vision-instruct | 128k tokens | Advanced state-of-the-art small language model with language understanding, superior reasoning, and text generation. |
+    | meta/llama-3.2-90b-vision-instruct | 128k tokens | Advanced state-of-the-art small language model with language understanding, superior reasoning, and text generation. |
+    | meta/llama-3.1-70b-instruct | 128k tokens | Powers complex conversations with superior contextual understanding, reasoning and text generation. |
+    | google/gemma-7b | 8,192 tokens | Cutting-edge text generation model text understanding, transformation, and code generation. |
+    | google/gemma-2b | 8,192 tokens | Cutting-edge text generation model text understanding, transformation, and code generation. |
+    | google/codegemma-7b | 8,192 tokens | Cutting-edge model built on Google's Gemma-7B specialized for code generation and code completion. |
+    | google/codegemma-1.1-7b | 8,192 tokens | Advanced programming model for code generation, completion, reasoning, and instruction following. |
+    | google/recurrentgemma-2b | 8,192 tokens | Novel recurrent architecture based language model for faster inference when generating long sequences. |
+    | google/gemma-2-9b-it | 8,192 tokens | Cutting-edge text generation model text understanding, transformation, and code generation. |
+    | google/gemma-2-27b-it | 8,192 tokens | Cutting-edge text generation model text understanding, transformation, and code generation. |
+    | google/gemma-2-2b-it | 8,192 tokens | Cutting-edge text generation model text understanding, transformation, and code generation. |
+    | google/deplot | 512 tokens | One-shot visual language understanding model that translates images of plots into tables. |
+    | google/paligemma | 8,192 tokens | Vision language model adept at comprehending text and visual inputs to produce informative responses. |
+    | mistralai/mistral-7b-instruct-v0.2 | 32k tokens | This LLM follows instructions, completes requests, and generates creative text. |
+    | mistralai/mixtral-8x7b-instruct-v0.1 | 8,192 tokens | An MOE LLM that follows instructions, completes requests, and generates creative text. |
+    | mistralai/mistral-large | 4,096 tokens | Creates diverse synthetic data that mimics the characteristics of real-world data. |
+    | mistralai/mixtral-8x22b-instruct-v0.1 | 8,192 tokens | Creates diverse synthetic data that mimics the characteristics of real-world data. |
+    | mistralai/mistral-7b-instruct-v0.3 | 32k tokens | This LLM follows instructions, completes requests, and generates creative text. |
+    | nv-mistralai/mistral-nemo-12b-instruct | 128k tokens | Most advanced language model for reasoning, code, multilingual tasks; runs on a single GPU. |
+    | mistralai/mamba-codestral-7b-v0.1 | 256k tokens | Model for writing and interacting with code across a wide range of programming languages and tasks. |
+    | microsoft/phi-3-mini-128k-instruct | 128K tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
+    | microsoft/phi-3-mini-4k-instruct | 4,096 tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
+    | microsoft/phi-3-small-8k-instruct | 8,192 tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
+    | microsoft/phi-3-small-128k-instruct | 128K tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
+    | microsoft/phi-3-medium-4k-instruct | 4,096 tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
+    | microsoft/phi-3-medium-128k-instruct | 128K tokens | Lightweight, state-of-the-art open LLM with strong math and logical reasoning skills. |
+    | microsoft/phi-3.5-mini-instruct | 128K tokens | Lightweight multilingual LLM powering AI applications in latency bound, memory/compute constrained environments |
+    | microsoft/phi-3.5-moe-instruct | 128K tokens | Advanced LLM based on Mixture of Experts architecure to deliver compute efficient content generation |
+    | microsoft/kosmos-2 | 1,024 tokens | Groundbreaking multimodal model designed to understand and reason about visual elements in images. |
+    | microsoft/phi-3-vision-128k-instruct | 128k tokens | Cutting-edge open multimodal model exceling in high-quality reasoning from images. |
+    | microsoft/phi-3.5-vision-instruct | 128k tokens | Cutting-edge open multimodal model exceling in high-quality reasoning from images. |
+    | databricks/dbrx-instruct | 12k tokens | A general-purpose LLM with state-of-the-art performance in language understanding, coding, and RAG. |
+    | snowflake/arctic | 1,024 tokens | Delivers high efficiency inference for enterprise applications focused on SQL generation and coding. |
+    | aisingapore/sea-lion-7b-instruct | 4,096 tokens | LLM to represent and serve the linguistic and cultural diversity of Southeast Asia |
+    | ibm/granite-8b-code-instruct | 4,096 tokens | Software programming LLM for code generation, completion, explanation, and multi-turn conversion. |
+    | ibm/granite-34b-code-instruct | 8,192 tokens | Software programming LLM for code generation, completion, explanation, and multi-turn conversion. |
+    | ibm/granite-3.0-8b-instruct | 4,096 tokens | Advanced Small Language Model supporting RAG, summarization, classification, code, and agentic AI |
+    | ibm/granite-3.0-3b-a800m-instruct | 4,096 tokens | Highly efficient Mixture of Experts model for RAG, summarization, entity extraction, and classification |
+    | mediatek/breeze-7b-instruct | 4,096 tokens | Creates diverse synthetic data that mimics the characteristics of real-world data. |
+    | upstage/solar-10.7b-instruct | 4,096 tokens | Excels in NLP tasks, particularly in instruction-following, reasoning, and mathematics. |
+    | writer/palmyra-med-70b-32k | 32k tokens | Leading LLM for accurate, contextually relevant responses in the medical domain. |
+    | writer/palmyra-med-70b | 32k tokens | Leading LLM for accurate, contextually relevant responses in the medical domain. |
+    | writer/palmyra-fin-70b-32k | 32k tokens | Specialized LLM for financial analysis, reporting, and data processing |
+    | 01-ai/yi-large | 32k tokens | Powerful model trained on English and Chinese for diverse tasks including chatbot and creative writing. |
+    | deepseek-ai/deepseek-coder-6.7b-instruct | 2k tokens | Powerful coding model offering advanced capabilities in code generation, completion, and infilling |
+    | rakuten/rakutenai-7b-instruct | 1,024 tokens | Advanced state-of-the-art LLM with language understanding, superior reasoning, and text generation. |
+    | rakuten/rakutenai-7b-chat | 1,024 tokens | Advanced state-of-the-art LLM with language understanding, superior reasoning, and text generation. |
+    | baichuan-inc/baichuan2-13b-chat | 4,096 tokens | Support Chinese and English chat, coding, math, instruction following, solving quizzes |
+
+    <Note>
+      NVIDIA's NIM support for models is expanding continuously! For the most up-to-date list of available models, please visit build.nvidia.com.
+    </Note>
+  </Tab>
+  <Tab title="Gemini">
+    | Model | Context Window | Best For |
+    |-------|---------------|-----------|
+    | gemini-2.0-flash-exp | 1M tokens | Higher quality at faster speed, multimodal model, good for most tasks |
+    | gemini-1.5-flash | 1M tokens | Balanced multimodal model, good for most tasks |
+    | gemini-1.5-flash-8B | 1M tokens | Fastest, most cost-efficient, good for high-frequency tasks |
+    | gemini-1.5-pro | 2M tokens | Best performing, wide variety of reasoning tasks including logical reasoning, coding, and creative collaboration |
+
+    <Tip>
+      Google's Gemini models are all multimodal, supporting audio, images, video and text, supporting context caching, json schema, function calling, etc.
+
+      These models are available via API_KEY from 
+      [The Gemini API](https://ai.google.dev/gemini-api/docs) and also from 
+      [Google Cloud Vertex](https://cloud.google.com/vertex-ai/generative-ai/docs/migrate/migrate-google-ai) as part of the
+      [Model Garden](https://cloud.google.com/vertex-ai/generative-ai/docs/model-garden/explore-models).
+    </Tip>
+  </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 |
+
+    <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 |
+    | Gemma Series | 8,192 tokens | Efficient, smaller-scale tasks |
+
+    <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>
+
+## Setting Up Your LLM
+
+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 - Strong reasoning, large cachable context window, multimodal
+        # llm: gemini/gemini-1.5-pro-latest
+        # llm: gemini/gemini-1.5-flash-latest
+        # llm: gemini/gemini-1.5-flash-8b-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:
+
+<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
+    )
+    ```
+
+    <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="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>
+
+      <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>
+
+    <Info>
+      Remember to regularly monitor your token usage and adjust your configuration as needed to optimize costs and performance.
+    </Info>
+  </Accordion>
+</AccordionGroup>
+
+## Provider Configuration Examples
+
+<AccordionGroup>
+  <Accordion title="OpenAI">
+    ```python Code
+    # Required
+    OPENAI_API_KEY=sk-...
+    
+    # Optional
+    OPENAI_API_BASE=<custom-base-url>
+    OPENAI_ORGANIZATION=<your-org-id>
+    ```
+
+    Example usage:
+    ```python Code
+    from crewai import LLM
+
+    llm = LLM(
+        model="gpt-4",
+        temperature=0.8,
+        max_tokens=150,
+        top_p=0.9,
+        frequency_penalty=0.1,
+        presence_penalty=0.1,
+        stop=["END"],
+        seed=42
+    )
+    ```
+  </Accordion>
+
+  <Accordion title="Anthropic">
+    ```python Code
+    ANTHROPIC_API_KEY=sk-ant-...
+    ```
+
+    Example usage:
+    ```python Code
+    llm = LLM(
+        model="anthropic/claude-3-sonnet-20240229-v1:0",
+        temperature=0.7
+    )
+    ```
+  </Accordion>
+
+  <Accordion title="Google">
+    ```python Code
+    # Option 1. Gemini accessed with an API key.
+    # https://ai.google.dev/gemini-api/docs/api-key
+    GEMINI_API_KEY=<your-api-key>
+
+    # Option 2. Vertex AI IAM credentials for Gemini, Anthropic, and anything in the Model Garden.
+    # https://cloud.google.com/vertex-ai/generative-ai/docs/overview
+    ```
+
+    Example usage:
+    ```python Code
+    llm = LLM(
+        model="gemini/gemini-1.5-pro-latest",
+        temperature=0.7
+    )
+    ```
+  </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>
+    ```
+
+    Example usage:
+    ```python Code
+    llm = LLM(
+        model="azure/gpt-4",
+        api_version="2023-05-15"
+    )
+    ```
+  </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>
+    ```
+
+    Example usage:
+    ```python Code
+    llm = LLM(
+        model="bedrock/anthropic.claude-3-sonnet-20240229-v1:0"
+    )
+    ```
+  </Accordion>
+
+  <Accordion title="Mistral">
+    ```python Code
+    MISTRAL_API_KEY=<your-api-key>
+    ```
+
+    Example usage:
+    ```python Code
+    llm = LLM(
+        model="mistral/mistral-large-latest",
+        temperature=0.7
+    )
+    ```
+  </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="Groq">
+    ```python Code
+    GROQ_API_KEY=<your-api-key>
+    ```
+
+    Example usage:
+    ```python Code
+    llm = LLM(
+        model="groq/llama-3.2-90b-text-preview",
+        temperature=0.7
+    )
+    ```
+  </Accordion>
+
+  <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:
+    ```python Code
+    llm = LLM(
+        model="watsonx/meta-llama/llama-3-1-70b-instruct",
+        base_url="https://api.watsonx.ai/v1"
+    )
+    ```
+  </Accordion>
+
+  <Accordion title="Ollama (Local LLMs)">
+    1. Install Ollama: [ollama.ai](https://ollama.ai/)
+    2. Run a model: `ollama run llama2`
+    3. Configure:
+
+    ```python Code
+    llm = LLM(
+        model="ollama/llama3:70b",
+        base_url="http://localhost:11434"
+    )
+    ```
+  </Accordion>
+
+  <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",
+        base_url="your_api_endpoint"
+    )
+    ```
+  </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>
+</AccordionGroup>
+
+## Common Issues and Solutions
+
+<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>
+
+## Getting Help
+
+If you need assistance, these resources are available:
+
+<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>
+
+<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>

docs/concepts/memory.mdx

@@ -0,0 +1,350 @@
+---
+title: Memory
+description: Leveraging memory systems in the CrewAI framework to enhance agent capabilities.
+icon: database
+---
+
+## Introduction to Memory Systems in CrewAI
+
+The crewAI framework introduces a sophisticated memory system designed to significantly enhance the capabilities of AI agents. 
+This system comprises `short-term memory`, `long-term memory`, `entity memory`, and `contextual memory`, each serving a unique purpose in aiding agents to remember, 
+reason, and learn from past interactions.
+
+## Memory System Components
+
+| Component            | Description                                                                                                             |
+| :------------------- | :---------------------------------------------------------------------------------------------------------------------- |
+| **Short-Term Memory**| Temporarily stores recent interactions and outcomes using `RAG`, enabling agents to recall and utilize information relevant to their current context during the current executions.|
+| **Long-Term Memory** | Preserves valuable insights and learnings from past executions, allowing agents to build and refine their knowledge over time. |
+| **Entity Memory**    | Captures and organizes information about entities (people, places, concepts) encountered during tasks, facilitating deeper understanding and relationship mapping. Uses `RAG` for storing entity information. |
+| **Contextual Memory**| Maintains the context of interactions by combining `ShortTermMemory`, `LongTermMemory`, and `EntityMemory`, aiding in the coherence and relevance of agent responses over a sequence of tasks or a conversation. |
+| **User Memory**      | Stores user-specific information and preferences, enhancing personalization and user experience. |
+
+## How Memory Systems Empower Agents
+
+1. **Contextual Awareness**: With short-term and contextual memory, agents gain the ability to maintain context over a conversation or task sequence, leading to more coherent and relevant responses.
+
+2. **Experience Accumulation**: Long-term memory allows agents to accumulate experiences, learning from past actions to improve future decision-making and problem-solving.
+
+3. **Entity Understanding**: By maintaining entity memory, agents can recognize and remember key entities, enhancing their ability to process and interact with complex information.
+
+## Implementing Memory in Your Crew
+
+When configuring a crew, you can enable and customize each memory component to suit the crew's objectives and the nature of tasks it will perform.
+By default, the memory system is disabled, and you can ensure it is active by setting `memory=True` in the crew configuration. 
+The memory will use OpenAI embeddings by default, but you can change it by setting `embedder` to a different model. 
+It's also possible to initialize the memory instance with your own instance.
+
+The 'embedder' only applies to **Short-Term Memory** which uses Chroma for RAG.
+The **Long-Term Memory** uses SQLite3 to store task results. Currently, there is no way to override these storage implementations.
+The data storage files are saved into a platform-specific location found using the appdirs package,
+and the name of the project can be overridden using the **CREWAI_STORAGE_DIR** environment variable.
+
+### Example: Configuring Memory for a Crew
+
+```python Code
+from crewai import Crew, Agent, Task, Process
+
+# Assemble your crew with memory capabilities
+my_crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process=Process.sequential,
+    memory=True,
+    verbose=True
+)
+```
+
+### Example: Use Custom Memory Instances e.g FAISS as the VectorDB
+
+```python Code
+from crewai import Crew, Agent, Task, Process
+
+# Assemble your crew with memory capabilities
+my_crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process="Process.sequential",
+    memory=True,
+    long_term_memory=EnhanceLongTermMemory(
+        storage=LTMSQLiteStorage(
+            db_path="/my_data_dir/my_crew1/long_term_memory_storage.db"
+        )
+    ),
+    short_term_memory=EnhanceShortTermMemory(
+        storage=CustomRAGStorage(
+            crew_name="my_crew",
+            storage_type="short_term",
+            data_dir="//my_data_dir",
+            model=embedder["model"],
+            dimension=embedder["dimension"],
+        ),
+    ),
+    entity_memory=EnhanceEntityMemory(
+        storage=CustomRAGStorage(
+            crew_name="my_crew",
+            storage_type="entities",
+            data_dir="//my_data_dir",
+            model=embedder["model"],
+            dimension=embedder["dimension"],
+        ),
+    ),
+    verbose=True,
+)
+```
+
+## Integrating Mem0 for Enhanced User Memory
+
+[Mem0](https://mem0.ai/) is a self-improving memory layer for LLM applications, enabling personalized AI experiences. 
+
+To include user-specific memory you can get your API key [here](https://app.mem0.ai/dashboard/api-keys) and refer the [docs](https://docs.mem0.ai/platform/quickstart#4-1-create-memories) for adding user preferences.
+
+
+```python Code
+import os
+from crewai import Crew, Process
+from mem0 import MemoryClient
+
+# Set environment variables for Mem0
+os.environ["MEM0_API_KEY"] = "m0-xx"
+
+# Step 1: Record preferences based on past conversation or user input
+client = MemoryClient()
+messages = [
+    {"role": "user", "content": "Hi there! I'm planning a vacation and could use some advice."},
+    {"role": "assistant", "content": "Hello! I'd be happy to help with your vacation planning. What kind of destination do you prefer?"},
+    {"role": "user", "content": "I am more of a beach person than a mountain person."},
+    {"role": "assistant", "content": "That's interesting. Do you like hotels or Airbnb?"},
+    {"role": "user", "content": "I like Airbnb more."},
+]
+client.add(messages, user_id="john")
+
+# Step 2: Create a Crew with User Memory
+
+crew = Crew(
+    agents=[...],
+    tasks=[...],
+    verbose=True,
+    process=Process.sequential,
+    memory=True,
+    memory_config={
+        "provider": "mem0",
+        "config": {"user_id": "john"},
+    },
+)
+```
+
+
+## Additional Embedding Providers
+
+### Using OpenAI embeddings (already default)
+```python Code
+from crewai import Crew, Agent, Task, Process
+
+my_crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process=Process.sequential,
+    memory=True,
+    verbose=True,
+    embedder={
+        "provider": "openai",
+        "config": {
+            "model": 'text-embedding-3-small'
+        }
+    }
+)
+```
+Alternatively, you can directly pass the OpenAIEmbeddingFunction to the embedder parameter.
+
+Example:
+```python Code
+from crewai import Crew, Agent, Task, Process
+from chromadb.utils.embedding_functions import OpenAIEmbeddingFunction
+
+my_crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process=Process.sequential,
+    memory=True,
+    verbose=True,
+    embedder=OpenAIEmbeddingFunction(api_key=os.getenv("OPENAI_API_KEY"), model_name="text-embedding-3-small"),
+)
+```
+
+### Using Ollama embeddings
+
+```python Code
+from crewai import Crew, Agent, Task, Process
+
+my_crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process=Process.sequential,
+    memory=True,
+    verbose=True,
+    embedder={
+        "provider": "ollama",
+        "config": {
+            "model": "mxbai-embed-large"
+        }
+    }
+)
+```
+
+### Using Google AI embeddings
+
+```python Code
+from crewai import Crew, Agent, Task, Process
+
+my_crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process=Process.sequential,
+    memory=True,
+    verbose=True,
+    embedder={
+        "provider": "google",
+        "config": {
+            "api_key": "<YOUR_API_KEY>",
+            "model_name": "<model_name>"
+        }
+    }
+)
+```
+
+### Using Azure OpenAI embeddings
+
+```python Code
+from chromadb.utils.embedding_functions import OpenAIEmbeddingFunction
+from crewai import Crew, Agent, Task, Process
+
+my_crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process=Process.sequential,
+    memory=True,
+    verbose=True,
+    embedder=OpenAIEmbeddingFunction(
+        api_key="YOUR_API_KEY",
+        api_base="YOUR_API_BASE_PATH",
+        api_type="azure",
+        api_version="YOUR_API_VERSION",
+        model_name="text-embedding-3-small"
+    )
+)
+```
+
+### Using Vertex AI embeddings
+
+```python Code
+from chromadb.utils.embedding_functions import GoogleVertexEmbeddingFunction
+from crewai import Crew, Agent, Task, Process
+
+my_crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process=Process.sequential,
+    memory=True,
+    verbose=True,
+    embedder=GoogleVertexEmbeddingFunction(
+        project_id="YOUR_PROJECT_ID",
+        region="YOUR_REGION",
+        api_key="YOUR_API_KEY",
+        model_name="textembedding-gecko"
+    )
+)
+```
+
+### Using Cohere embeddings
+
+```python Code
+from crewai import Crew, Agent, Task, Process
+
+my_crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process=Process.sequential,
+    memory=True,
+    verbose=True,
+    embedder={
+        "provider": "cohere",
+        "config": {
+            "api_key": "YOUR_API_KEY",
+            "model_name": "<model_name>"
+        }
+    }
+)
+```
+### Using HuggingFace embeddings
+
+```python Code
+from crewai import Crew, Agent, Task, Process
+
+my_crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process=Process.sequential,
+    memory=True,
+    verbose=True,
+    embedder={
+        "provider": "huggingface",
+        "config": {
+            "api_url": "<api_url>",
+        }
+    }
+)
+```
+
+### Using Watson embeddings
+
+```python Code
+from crewai import Crew, Agent, Task, Process
+
+# Note: Ensure you have installed and imported `ibm_watsonx_ai` for Watson embeddings to work.
+
+my_crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process=Process.sequential,
+    memory=True,
+    verbose=True,
+    embedder={
+        "provider": "watson",
+        "config": {
+            "model": "<model_name>",
+            "api_url": "<api_url>",
+            "api_key": "<YOUR_API_KEY>",
+            "project_id": "<YOUR_PROJECT_ID>",
+        }
+    }
+)
+```
+
+### Resetting Memory
+
+```shell
+crewai reset-memories [OPTIONS]
+```
+
+#### Resetting Memory Options
+
+| Option             | Description                      | Type           | Default |
+| :----------------- | :------------------------------- | :------------- | :------ |
+| `-l`, `--long`     | Reset LONG TERM memory.          | Flag (boolean) | False   |
+| `-s`, `--short`    | Reset SHORT TERM memory.         | Flag (boolean) | False   |
+| `-e`, `--entities` | Reset ENTITIES memory.           | Flag (boolean) | False   |
+| `-k`, `--kickoff-outputs` | Reset LATEST KICKOFF TASK OUTPUTS. | Flag (boolean) | False   |
+| `-a`, `--all`      | Reset ALL memories.              | Flag (boolean) | False   |
+
+
+## Benefits of Using CrewAI's Memory System
+
+- 🦾 **Adaptive Learning:** Crews become more efficient over time, adapting to new information and refining their approach to tasks.
+- 🫡 **Enhanced Personalization:** Memory enables agents to remember user preferences and historical interactions, leading to personalized experiences.
+- 🧠 **Improved Problem Solving:** Access to a rich memory store aids agents in making more informed decisions, drawing on past learnings and contextual insights.
+
+## Conclusion
+
+Integrating CrewAI's memory system into your projects is straightforward. By leveraging the provided memory components and configurations, 
+you can quickly empower your agents with the ability to remember, reason, and learn from their interactions, unlocking new levels of intelligence and capability.

docs/concepts/planning.mdx

@@ -0,0 +1,151 @@
+---
+title: Planning
+description: Learn how to add planning to your CrewAI Crew and improve their performance.
+icon: brain
+---
+
+## Introduction
+
+The planning feature in CrewAI allows you to add planning capability to your crew. When enabled, before each Crew iteration, 
+all Crew information is sent to an AgentPlanner that will plan the tasks step by step, and this plan will be added to each task description.
+
+### Using the Planning Feature
+
+Getting started with the planning feature is very easy, the only step required is to add `planning=True` to your Crew:
+
+<CodeGroup>
+```python Code
+from crewai import Crew, Agent, Task, Process
+
+# Assemble your crew with planning capabilities
+my_crew = Crew(
+    agents=self.agents,
+    tasks=self.tasks,
+    process=Process.sequential,
+    planning=True,
+)
+```
+</CodeGroup>
+
+From this point on, your crew will have planning enabled, and the tasks will be planned before each iteration.
+
+#### Planning LLM
+
+Now you can define the LLM that will be used to plan the tasks. You can use any ChatOpenAI LLM model available.
+
+When running the base case example, you will see something like the output below, which represents the output of the `AgentPlanner` 
+responsible for creating the step-by-step logic to add to the Agents' tasks.
+
+<CodeGroup>
+```python Code
+from crewai import Crew, Agent, Task, Process
+from langchain_openai import ChatOpenAI
+
+# Assemble your crew with planning capabilities and custom LLM
+my_crew = Crew(
+    agents=self.agents,
+    tasks=self.tasks,
+    process=Process.sequential,
+    planning=True,
+    planning_llm=ChatOpenAI(model="gpt-4o")
+)
+
+# Run the crew
+my_crew.kickoff()
+```
+
+```markdown Result
+[2024-07-15 16:49:11][INFO]: Planning the crew execution
+**Step-by-Step Plan for Task Execution**
+
+**Task Number 1: Conduct a thorough research about AI LLMs**
+
+**Agent:** AI LLMs Senior Data Researcher
+
+**Agent Goal:** Uncover cutting-edge developments in AI LLMs
+
+**Task Expected Output:** A list with 10 bullet points of the most relevant information about AI LLMs
+
+**Task Tools:** None specified
+
+**Agent Tools:** None specified
+
+**Step-by-Step Plan:**
+
+1. **Define Research Scope:**
+
+   - Determine the specific areas of AI LLMs to focus on, such as advancements in architecture, use cases, ethical considerations, and performance metrics.
+
+2. **Identify Reliable Sources:**
+
+   - List reputable sources for AI research, including academic journals, industry reports, conferences (e.g., NeurIPS, ACL), AI research labs (e.g., OpenAI, Google AI), and online databases (e.g., IEEE Xplore, arXiv).
+
+3. **Collect Data:**
+
+   - Search for the latest papers, articles, and reports published in 2023 and early 2024.
+   - Use keywords like "Large Language Models 2024", "AI LLM advancements", "AI ethics 2024", etc.
+
+4. **Analyze Findings:**
+
+   - Read and summarize the key points from each source.
+   - Highlight new techniques, models, and applications introduced in the past year.
+
+5. **Organize Information:**
+
+   - Categorize the information into relevant topics (e.g., new architectures, ethical implications, real-world applications).
+   - Ensure each bullet point is concise but informative.
+
+6. **Create the List:**
+
+   - Compile the 10 most relevant pieces of information into a bullet point list.
+   - Review the list to ensure clarity and relevance.
+
+**Expected Output:**
+
+A list with 10 bullet points of the most relevant information about AI LLMs.
+
+---
+
+**Task Number 2: Review the context you got and expand each topic into a full section for a report**
+
+**Agent:** AI LLMs Reporting Analyst
+
+**Agent Goal:** Create detailed reports based on AI LLMs data analysis and research findings
+
+**Task Expected Output:** A fully fledged report with the main topics, each with a full section of information. Formatted as markdown without '```'
+
+**Task Tools:** None specified
+
+**Agent Tools:** None specified
+
+**Step-by-Step Plan:**
+
+1. **Review the Bullet Points:**
+   - Carefully read through the list of 10 bullet points provided by the AI LLMs Senior Data Researcher.
+
+2. **Outline the Report:**
+   - Create an outline with each bullet point as a main section heading.
+   - Plan sub-sections under each main heading to cover different aspects of the topic.
+
+3. **Research Further Details:**
+   - For each bullet point, conduct additional research if necessary to gather more detailed information.
+   - Look for case studies, examples, and statistical data to support each section.
+
+4. **Write Detailed Sections:**
+   - Expand each bullet point into a comprehensive section.
+   - Ensure each section includes an introduction, detailed explanation, examples, and a conclusion.
+   - Use markdown formatting for headings, subheadings, lists, and emphasis.
+
+5. **Review and Edit:**
+   - Proofread the report for clarity, coherence, and correctness.
+   - Make sure the report flows logically from one section to the next.
+   - Format the report according to markdown standards.
+
+6. **Finalize the Report:**
+   - Ensure the report is complete with all sections expanded and detailed.
+   - Double-check formatting and make any necessary adjustments.
+
+**Expected Output:**
+A fully fledged report with the main topics, each with a full section of information. Formatted as markdown without '```'.
+```
+</CodeGroup>

docs/concepts/processes.mdx

@@ -0,0 +1,67 @@
+---
+title: Processes
+description: Detailed guide on workflow management through processes in CrewAI, with updated implementation details.
+icon: bars-staggered
+---
+
+## Understanding Processes
+<Tip>
+  Processes orchestrate the execution of tasks by agents, akin to project management in human teams. 
+  These processes ensure tasks are distributed and executed efficiently, in alignment with a predefined strategy.
+</Tip>
+
+## Process Implementations
+
+- **Sequential**: Executes tasks sequentially, ensuring tasks are completed in an orderly progression.
+- **Hierarchical**: Organizes tasks in a managerial hierarchy, where tasks are delegated and executed based on a structured chain of command. A manager language model (`manager_llm`) or a custom manager agent (`manager_agent`) must be specified in the crew to enable the hierarchical process, facilitating the creation and management of tasks by the manager.
+- **Consensual Process (Planned)**: Aiming for collaborative decision-making among agents on task execution, this process type introduces a democratic approach to task management within CrewAI. It is planned for future development and is not currently implemented in the codebase.
+
+## The Role of Processes in Teamwork
+Processes enable individual agents to operate as a cohesive unit, streamlining their efforts to achieve common objectives with efficiency and coherence.
+
+## Assigning Processes to a Crew
+To assign a process to a crew, specify the process type upon crew creation to set the execution strategy. For a hierarchical process, ensure to define `manager_llm` or `manager_agent` for the manager agent.
+
+```python
+from crewai import Crew
+from crewai.process import Process
+from langchain_openai import ChatOpenAI
+
+# Example: Creating a crew with a sequential process
+crew = Crew(
+    agents=my_agents,
+    tasks=my_tasks,
+    process=Process.sequential
+)
+
+# Example: Creating a crew with a hierarchical process
+# Ensure to provide a manager_llm or manager_agent
+crew = Crew(
+    agents=my_agents,
+    tasks=my_tasks,
+    process=Process.hierarchical,
+    manager_llm=ChatOpenAI(model="gpt-4")
+    # or
+    # manager_agent=my_manager_agent
+)
+```
+**Note:** Ensure `my_agents` and `my_tasks` are defined prior to creating a `Crew` object, and for the hierarchical process, either `manager_llm` or `manager_agent` is also required.
+
+## Sequential Process
+
+This method mirrors dynamic team workflows, progressing through tasks in a thoughtful and systematic manner. Task execution follows the predefined order in the task list, with the output of one task serving as context for the next.
+
+To customize task context, utilize the `context` parameter in the `Task` class to specify outputs that should be used as context for subsequent tasks.
+
+## Hierarchical Process
+
+Emulates a corporate hierarchy, CrewAI allows specifying a custom manager agent or automatically creates one, requiring the specification of a manager language model (`manager_llm`). This agent oversees task execution, including planning, delegation, and validation. Tasks are not pre-assigned; the manager allocates tasks to agents based on their capabilities, reviews outputs, and assesses task completion.
+
+## Process Class: Detailed Overview
+
+The `Process` class is implemented as an enumeration (`Enum`), ensuring type safety and restricting process values to the defined types (`sequential`, `hierarchical`). The consensual process is planned for future inclusion, emphasizing our commitment to continuous development and innovation.
+
+## Conclusion
+
+The structured collaboration facilitated by processes within CrewAI is crucial for enabling systematic teamwork among agents. 
+This documentation has been updated to reflect the latest features, enhancements, and the planned integration of the Consensual Process, ensuring users have access to the most current and comprehensive information.

docs/concepts/tasks.mdx

@@ -0,0 +1,883 @@
+---
+title: Tasks
+description: Detailed guide on managing and creating tasks within the CrewAI framework.
+icon: list-check
+---
+
+## Overview of a Task
+
+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.
+
+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.                                                                 |
+| **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.                                                                |
+
+## Creating Tasks
+
+There are two ways to create tasks 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 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"
+)
+```
+
+<Tip>
+  Directly specify an `agent` for assignment or let the `hierarchical` CrewAI's process decide based on roles, availability, etc.
+</Tip>
+
+## 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.
+
+### Task Output Attributes
+
+| Attribute         | Parameters      | Type                       | Description                                                                                        |
+| :---------------- | :-------------- | :------------------------- | :------------------------------------------------------------------------------------------------- |
+| **Description**   | `description`   | `str`                      | Description of the task.                                                                           |
+| **Summary**       | `summary`       | `Optional[str]`            | Summary of the task, auto-generated from the first 10 words of the description.                    |
+| **Raw**           | `raw`           | `str`                      | The raw output of the task. This is the default format for the output.                             |
+| **Pydantic**      | `pydantic`      | `Optional[BaseModel]`      | A Pydantic model object representing the structured output of the task.                            |
+| **JSON Dict**     | `json_dict`     | `Optional[Dict[str, Any]]` | A dictionary representing the JSON output of the task.                                             |
+| **Agent**         | `agent`         | `str`                      | The agent that executed the task.                                                                  |
+| **Output Format** | `output_format` | `OutputFormat`             | The format of the task output, with options including RAW, JSON, and Pydantic. The default is RAW. |
+
+### Task Methods and Properties
+
+| Method/Property | Description                                                                                       |
+| :-------------- | :------------------------------------------------------------------------------------------------ |
+| **json**        | Returns the JSON string representation of the task output if the output format is JSON.           |
+| **to_dict**     | Converts the JSON and Pydantic outputs to a dictionary.                                           |
+| **str**         | Returns the string representation of the task output, prioritizing Pydantic, then JSON, then raw. |
+
+### Accessing Task Outputs
+
+Once a task has been executed, its output can be accessed through the `output` attribute of the `Task` object. The `TaskOutput` class provides various ways to interact with and present this output.
+
+#### Example
+
+```python Code
+# Example task
+task = Task(
+    description='Find and summarize the latest AI news',
+    expected_output='A bullet list summary of the top 5 most important AI news',
+    agent=research_agent,
+    tools=[search_tool]
+)
+
+# Execute the crew
+crew = Crew(
+    agents=[research_agent],
+    tasks=[task],
+    verbose=True
+)
+
+result = crew.kickoff()
+
+# Accessing the task output
+task_output = task.output
+
+print(f"Task Description: {task_output.description}")
+print(f"Task Summary: {task_output.summary}")
+print(f"Raw Output: {task_output.raw}")
+if task_output.json_dict:
+    print(f"JSON Output: {json.dumps(task_output.json_dict, indent=2)}")
+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
+)
+```
+
+## Task Guardrails
+
+Task guardrails provide a way to validate and transform task outputs before they
+are passed to the next task. This feature helps ensure data quality and provides
+efeedback to agents when their output doesn't meet specific criteria.
+
+### Using Task Guardrails
+
+To add a guardrail to a task, provide a validation function through the `guardrail` parameter:
+
+```python Code
+from typing import Tuple, Union, Dict, Any
+
+def validate_blog_content(result: str) -> Tuple[bool, Union[Dict[str, Any], str]]:
+    """Validate blog content meets requirements."""
+    try:
+        # Check word count
+        word_count = len(result.split())
+        if word_count > 200:
+            return (False, {
+                "error": "Blog content exceeds 200 words",
+                "code": "WORD_COUNT_ERROR",
+                "context": {"word_count": word_count}
+            })
+
+        # Additional validation logic here
+        return (True, result.strip())
+    except Exception as e:
+        return (False, {
+            "error": "Unexpected error during validation",
+            "code": "SYSTEM_ERROR"
+        })
+
+blog_task = Task(
+    description="Write a blog post about AI",
+    expected_output="A blog post under 200 words",
+    agent=blog_agent,
+    guardrail=validate_blog_content  # Add the guardrail function
+)
+```
+
+### Guardrail Function Requirements
+
+1. **Function Signature**:
+   - Must accept exactly one parameter (the task output)
+   - Should return a tuple of `(bool, Any)`
+   - Type hints are recommended but optional
+
+2. **Return Values**:
+   - Success: Return `(True, validated_result)`
+   - Failure: Return `(False, error_details)`
+
+### Error Handling Best Practices
+
+1. **Structured Error Responses**:
+```python Code
+def validate_with_context(result: str) -> Tuple[bool, Union[Dict[str, Any], str]]:
+    try:
+        # Main validation logic
+        validated_data = perform_validation(result)
+        return (True, validated_data)
+    except ValidationError as e:
+        return (False, {
+            "error": str(e),
+            "code": "VALIDATION_ERROR",
+            "context": {"input": result}
+        })
+    except Exception as e:
+        return (False, {
+            "error": "Unexpected error",
+            "code": "SYSTEM_ERROR"
+        })
+```
+
+2. **Error Categories**:
+   - Use specific error codes
+   - Include relevant context
+   - Provide actionable feedback
+
+3. **Validation Chain**:
+```python Code
+from typing import Any, Dict, List, Tuple, Union
+
+def complex_validation(result: str) -> Tuple[bool, Union[str, Dict[str, Any]]]:
+    """Chain multiple validation steps."""
+    # Step 1: Basic validation
+    if not result:
+        return (False, {"error": "Empty result", "code": "EMPTY_INPUT"})
+
+    # Step 2: Content validation
+    try:
+        validated = validate_content(result)
+        if not validated:
+            return (False, {"error": "Invalid content", "code": "CONTENT_ERROR"})
+
+        # Step 3: Format validation
+        formatted = format_output(validated)
+        return (True, formatted)
+    except Exception as e:
+        return (False, {
+            "error": str(e),
+            "code": "VALIDATION_ERROR",
+            "context": {"step": "content_validation"}
+        })
+```
+
+### Handling Guardrail Results
+
+When a guardrail returns `(False, error)`:
+1. The error is sent back to the agent
+2. The agent attempts to fix the issue
+3. The process repeats until:
+   - The guardrail returns `(True, result)`
+   - Maximum retries are reached
+
+Example with retry handling:
+```python Code
+from typing import Optional, Tuple, Union
+
+def validate_json_output(result: str) -> Tuple[bool, Union[Dict[str, Any], str]]:
+    """Validate and parse JSON output."""
+    try:
+        # Try to parse as JSON
+        data = json.loads(result)
+        return (True, data)
+    except json.JSONDecodeError as e:
+        return (False, {
+            "error": "Invalid JSON format",
+            "code": "JSON_ERROR",
+            "context": {"line": e.lineno, "column": e.colno}
+        })
+
+task = Task(
+    description="Generate a JSON report",
+    expected_output="A valid JSON object",
+    agent=analyst,
+    guardrail=validate_json_output,
+    max_retries=3  # Limit retry attempts
+)
+```
+
+## Getting Structured Consistent Outputs from Tasks
+
+<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.
+
+## Creating a Task with Tools
+
+```python Code
+import os
+os.environ["OPENAI_API_KEY"] = "Your Key"
+os.environ["SERPER_API_KEY"] = "Your Key" # serper.dev API key
+
+from crewai import Agent, Task, Crew
+from crewai_tools import SerperDevTool
+
+research_agent = Agent(
+  role='Researcher',
+  goal='Find and summarize the latest AI news',
+  backstory="""You're a researcher at a large company.
+  You're responsible for analyzing data and providing insights
+  to the business.""",
+  verbose=True
+)
+
+# to perform a semantic search for a specified query from a text's content across the internet
+search_tool = SerperDevTool()
+
+task = Task(
+  description='Find and summarize the latest AI news',
+  expected_output='A bullet list summary of the top 5 most important AI news',
+  agent=research_agent,
+  tools=[search_tool]
+)
+
+crew = Crew(
+    agents=[research_agent],
+    tasks=[task],
+    verbose=True
+)
+
+result = crew.kickoff()
+print(result)
+```
+
+This demonstrates how tasks with specific tools can override an agent's default set for tailored task execution.
+
+## Referring to Other Tasks
+
+In CrewAI, the output of one task is automatically relayed into the next one, but you can specifically define what tasks' output, including multiple, should be used as context for another task.
+
+This is useful when you have a task that depends on the output of another task that is not performed immediately after it. This is done through the `context` attribute of the task:
+
+```python Code
+# ...
+
+research_ai_task = Task(
+    description="Research the latest developments in AI",
+    expected_output="A list of recent AI developments",
+    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",
+    async_execution=True,
+    agent=research_agent,
+    tools=[search_tool]
+)
+
+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",
+    agent=writer_agent,
+    context=[research_ai_task, research_ops_task]
+)
+
+#...
+```
+
+## Asynchronous Execution
+
+You can define a task to be executed asynchronously. This means that the crew will not wait for it to be completed to continue with the next task. This is useful for tasks that take a long time to be completed, or that are not crucial for the next tasks to be performed.
+
+You can then use the `context` attribute to define in a future task that it should wait for the output of the asynchronous task to be completed.
+
+```python Code
+#...
+
+list_ideas = Task(
+    description="List of 5 interesting ideas to explore for an article about AI.",
+    expected_output="Bullet point list of 5 ideas for an article.",
+    agent=researcher,
+    async_execution=True # Will be executed asynchronously
+)
+
+list_important_history = Task(
+    description="Research the history of AI and give me the 5 most important events.",
+    expected_output="Bullet point list of 5 important events.",
+    agent=researcher,
+    async_execution=True # Will be executed asynchronously
+)
+
+write_article = Task(
+    description="Write an article about AI, its history, and interesting ideas.",
+    expected_output="A 4 paragraph article about AI.",
+    agent=writer,
+    context=[list_ideas, list_important_history] # Will wait for the output of the two tasks to be completed
+)
+
+#...
+```
+
+## Callback Mechanism
+
+The callback function is executed after the task is completed, allowing for actions or notifications to be triggered based on the task's outcome.
+
+```python Code
+# ...
+
+def callback_function(output: TaskOutput):
+    # Do something after the task is completed
+    # Example: Send an email to the manager
+    print(f"""
+        Task completed!
+        Task: {output.description}
+        Output: {output.raw}
+    """)
+
+research_task = Task(
+    description='Find and summarize the latest AI news',
+    expected_output='A bullet list summary of the top 5 most important AI news',
+    agent=research_agent,
+    tools=[search_tool],
+    callback=callback_function
+)
+
+#...
+```
+
+## Accessing a Specific Task Output
+
+Once a crew finishes running, you can access the output of a specific task by using the `output` attribute of the task object:
+
+```python Code
+# ...
+task1 = Task(
+    description='Find and summarize the latest AI news',
+    expected_output='A bullet list summary of the top 5 most important AI news',
+    agent=research_agent,
+    tools=[search_tool]
+)
+
+#...
+
+crew = Crew(
+    agents=[research_agent],
+    tasks=[task1, task2, task3],
+    verbose=True
+)
+
+result = crew.kickoff()
+
+# Returns a TaskOutput object with the description and results of the task
+print(f"""
+    Task completed!
+    Task: {task1.output.description}
+    Output: {task1.output.raw}
+""")
+```
+
+## Tool Override Mechanism
+
+Specifying tools in a task allows for dynamic adaptation of agent capabilities, emphasizing CrewAI's flexibility.
+
+## Error Handling and Validation Mechanisms
+
+While creating and executing tasks, certain validation mechanisms are in place to ensure the robustness and reliability of task attributes. These include but are not limited to:
+
+- Ensuring only one output type is set per task to maintain clear output expectations.
+- Preventing the manual assignment of the `id` attribute to uphold the integrity of the unique identifier system.
+
+These validations help in maintaining the consistency and reliability of task executions within the crewAI framework.
+
+## Task Guardrails
+
+Task guardrails provide a powerful way to validate, transform, or filter task outputs before they are passed to the next task. Guardrails are optional functions that execute before the next task starts, allowing you to ensure that task outputs meet specific requirements or formats.
+
+### Basic Usage
+
+```python Code
+from typing import Tuple, Union
+from crewai import Task
+
+def validate_json_output(result: str) -> Tuple[bool, Union[dict, str]]:
+    """Validate that the output is valid JSON."""
+    try:
+        json_data = json.loads(result)
+        return (True, json_data)
+    except json.JSONDecodeError:
+        return (False, "Output must be valid JSON")
+
+task = Task(
+    description="Generate JSON data",
+    expected_output="Valid JSON object",
+    guardrail=validate_json_output
+)
+```
+
+### How Guardrails Work
+
+1. **Optional Attribute**: Guardrails are an optional attribute at the task level, allowing you to add validation only where needed.
+2. **Execution Timing**: The guardrail function is executed before the next task starts, ensuring valid data flow between tasks.
+3. **Return Format**: Guardrails must return a tuple of `(success, data)`:
+   - If `success` is `True`, `data` is the validated/transformed result
+   - If `success` is `False`, `data` is the error message
+4. **Result Routing**:
+   - On success (`True`), the result is automatically passed to the next task
+   - On failure (`False`), the error is sent back to the agent to generate a new answer
+
+### Common Use Cases
+
+#### Data Format Validation
+```python Code
+def validate_email_format(result: str) -> Tuple[bool, Union[str, str]]:
+    """Ensure the output contains a valid email address."""
+    import re
+    email_pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$'
+    if re.match(email_pattern, result.strip()):
+        return (True, result.strip())
+    return (False, "Output must be a valid email address")
+```
+
+#### Content Filtering
+```python Code
+def filter_sensitive_info(result: str) -> Tuple[bool, Union[str, str]]:
+    """Remove or validate sensitive information."""
+    sensitive_patterns = ['SSN:', 'password:', 'secret:']
+    for pattern in sensitive_patterns:
+        if pattern.lower() in result.lower():
+            return (False, f"Output contains sensitive information ({pattern})")
+    return (True, result)
+```
+
+#### Data Transformation
+```python Code
+def normalize_phone_number(result: str) -> Tuple[bool, Union[str, str]]:
+    """Ensure phone numbers are in a consistent format."""
+    import re
+    digits = re.sub(r'\D', '', result)
+    if len(digits) == 10:
+        formatted = f"({digits[:3]}) {digits[3:6]}-{digits[6:]}"
+        return (True, formatted)
+    return (False, "Output must be a 10-digit phone number")
+```
+
+### Advanced Features
+
+#### Chaining Multiple Validations
+```python Code
+def chain_validations(*validators):
+    """Chain multiple validators together."""
+    def combined_validator(result):
+        for validator in validators:
+            success, data = validator(result)
+            if not success:
+                return (False, data)
+            result = data
+        return (True, result)
+    return combined_validator
+
+# Usage
+task = Task(
+    description="Get user contact info",
+    expected_output="Email and phone",
+    guardrail=chain_validations(
+        validate_email_format,
+        filter_sensitive_info
+    )
+)
+```
+
+#### Custom Retry Logic
+```python Code
+task = Task(
+    description="Generate data",
+    expected_output="Valid data",
+    guardrail=validate_data,
+    max_retries=5  # Override default retry limit
+)
+```
+
+## Creating Directories when Saving Files
+
+You can now specify if a task should create directories when saving its output to a file. This is particularly useful for organizing outputs and ensuring that file paths are correctly structured.
+
+```python Code
+# ...
+
+save_output_task = Task(
+    description='Save the summarized AI news to a file',
+    expected_output='File saved successfully',
+    agent=research_agent,
+    tools=[file_save_tool],
+    output_file='outputs/ai_news_summary.txt',
+    create_directory=True
+)
+
+#...
+```
+
+## Conclusion
+
+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.