adding new docs and smaller fixes

README.md

@@ -68,7 +68,7 @@ os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"
 # Install duckduckgo-search for this example:
 # !pip install -U duckduckgo-search
 
-from langchain.tools import DuckDuckGoSearchRun
+from langchain_community.tools import DuckDuckGoSearchRun
 search_tool = DuckDuckGoSearchRun()
 
 # Define your agents with roles and goals

docs/core-concepts/Agents.md

@@ -21,9 +21,12 @@ description: What are crewAI Agents and how to use them.
 | **Goal**       | The individual objective that the agent aims to achieve. It guides the agent's decision-making process. |
 | **Backstory**    | Provides context to the agent's role and goal, enriching the interaction and collaboration dynamics. |
 | **Tools**    | Set of capabilities or functions that the agent can use to perform tasks. Tools can be shared or exclusive to specific agents. |
+| **Max Iter**    | The maximum number of iterations the agent can perform before forced to give its best answer |
+| **Max RPM**    | The maximum number of requests per minute the agent can perform to avoid rate limits |
 | **Verbose**    | This allow you to actually see what is going on during the Crew execution. |
 | **Allow Delegation**    | Agents can delegate tasks or questions to one another, ensuring that each task is handled by the most suitable agent. |
 
+
 ## Creating an Agent
 
 !!! note "Agent Interaction"
@@ -32,18 +35,22 @@ description: What are crewAI Agents and how to use them.
 To create an agent, you would typically initialize an instance of the `Agent` class with the desired properties. Here's a conceptual example:
 
 ```python
+# Example: Creating an agent with all attributes
 from crewai import Agent
 
-# Create an agent with a role and a goal
 agent = Agent(
   role='Data Analyst',
   goal='Extract actionable insights',
-  verbose=True,
   backstory="""You're a data analyst at a large company.
   You're responsible for analyzing data and providing insights
   to the business.
   You're currently working on a project to analyze the
-  performance of our marketing campaigns."""
+  performance of our marketing campaigns.""",
+  tools=[my_tool1, my_tool2],
+  max_iter=10,
+  max_rpm=10,
+  verbose=True,
+  allow_delegation=True
 )
 ```
 

docs/core-concepts/Tasks.md

@@ -17,7 +17,8 @@ Tasks in CrewAI can be designed to require collaboration between agents. For exa
 | **Agent**    | Optionally, you can specify which agent is responsible for the task. If not, the crew's process will determine who takes it on. |
 | **Expected Output** *(optional)*      | Clear and detailed definition of expected output for the task.  |
 | **Tools** *(optional)*   | These are the functions or capabilities the agent can utilize to perform the task. They can be anything from simple actions like 'search' to more complex interactions with other agents or APIs. |
-| **Context**  *(optional)*     | Other tasks that will have their output used as context for this task. |
+| **Async Execution** *(optional)*      | If the task should be executed asynchronously.  |
+| **Context**  *(optional)*     | Other tasks that will have their output used as context for this task, if one is an asynchronous task it will wait for that to finish |
 | **Callback**  *(optional)*  | A function to be executed after the task is completed. |
 
 ## Creating a Task
@@ -35,7 +36,6 @@ task = Task(
 !!! note "Task Assignment"
 	Tasks can be assigned directly by specifying an `agent` to them, or they can be assigned in run time if you are using the `hierarchical` through CrewAI's process, considering roles, availability, or other criteria.
 
-
 ## Integrating Tools with Tasks
 
 Tools from the [crewAI Toolkit](https://github.com/joaomdmoura/crewai-tools) and [LangChain Tools](https://python.langchain.com/docs/integrations/tools) enhance task performance, allowing agents to interact more effectively with their environment. Assigning specific tools to tasks can tailor agent capabilities to particular needs.
@@ -108,6 +108,39 @@ write_blog_task = 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
+#...
+
+list_ideas = Task(
+	description="List of 5 interesting ideas to explore for na 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, it's 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
 
 You can define a callback function that will be executed after the task is completed. This is useful for tasks that need to trigger some side effect after they are completed, while the crew is still running.
@@ -135,6 +168,40 @@ research_task = Task(
 #...
 ```
 
+## 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
+# ...
+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=2
+)
+
+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.result}
+""")
+```
+
+
+
+
 ## Tool Override Mechanism
 
 Specifying tools in a task allows for dynamic adaptation of agent capabilities, emphasizing CrewAI's flexibility.

docs/getting-started.md

@@ -28,7 +28,7 @@ os.environ["OPENAI_API_KEY"] = "YOUR KEY"
 # Install duckduckgo-search for this example:
 # !pip install -U duckduckgo-search
 
-from langchain.tools import DuckDuckGoSearchRun
+from langchain_community.tools import DuckDuckGoSearchRun
 search_tool = DuckDuckGoSearchRun()
 
 # Define your agents with roles and goals

docs/how-to/Creating-a-Crew-and-kick-it-off.md

@@ -1,75 +1,104 @@
-# Get a crew working
+---
+title: Assembling and Activating Your CrewAI Team
+description: A step-by-step guide to creating a cohesive CrewAI team for your projects.
+---
 
-Assembling a Crew in CrewAI is like casting characters for a play. Each agent you create is a cast member with a unique part to play. When your crew is assembled, you'll give the signal, and they'll spring into action, each performing their role in the grand scheme of your project.
+## Introduction
+Assembling a crew in CrewAI is akin to casting for a play, where each agent plays a unique role. This guide walks you through creating a crew, assigning roles and tasks, and activating them to work in harmony.
 
-# Step 1: Assemble Your Agents
-
-Start by creating your agents, each with its own role and backstory. These backstories add depth to the agents, influencing how they approach their tasks and interact with one another.
+## Step 1: Assemble Your Agents
+Begin by defining your agents with distinct roles and backstories. These elements not only add depth but also guide their task execution and interaction within the crew.
 
 ```python
+import os
+os.environ["OPENAI_API_KEY"] = "Your Key"
+
 from crewai import Agent
 
-# Create a researcher agent
+# Topic that will be used in the crew run
+topic = 'AI in healthcare'
+
+# Creating a senior researcher agent
 researcher = Agent(
   role='Senior Researcher',
-  goal='Discover groundbreaking technologies',
+  goal=f'Uncover groundbreaking technologies around {topic}',
   verbose=True,
-  backstory='A curious mind fascinated by cutting-edge innovation and the potential to change the world, you know everything about tech.'
+  backstory="""Driven by curiosity, you're at the forefront of
+  innovation, eager to explore and share knowledge that could change
+  the world."""
 )
 
-# Create a writer agent
+# Creating a writer agent
 writer = Agent(
   role='Writer',
-  goal='Craft compelling stories about tech discoveries',
+  goal=f'Narrate compelling tech stories around {topic}',
   verbose=True,
-  backstory='A creative soul who translates complex tech jargon into engaging narratives for the masses, you write using simple words in a friendly and inviting tone that does not sounds like AI.'
+  backstory="""With a flair for simplifying complex topics, you craft
+  engaging narratives that captivate and educate, bringing new
+  discoveries to light in an accessible manner."""
 )
 ```
 
-# Step 2: Define the Tasks
-
-Outline the tasks that your agents need to tackle. These tasks are their missions, the specific objectives they need to achieve.
+## Step 2: Define the Tasks
+Detail the specific objectives for your agents. These tasks guide their focus and ensure a targeted approach to their roles.
 
 ```python
 from crewai import Task
 
-# Task for the researcher
+# Install duckduckgo-search for this example:
+# !pip install -U duckduckgo-search
+
+from langchain_community.tools import DuckDuckGoSearchRun
+search_tool = DuckDuckGoSearchRun()
+
+# Research task for identifying AI trends
 research_task = Task(
-  description='Identify the next big trend in AI',
-  agent=researcher  # Assigning the task to the researcher
+  description=f"""Identify the next big trend in {topic}.
+  Focus on identifying pros and cons and the overall narrative.
+
+  Your final report should clearly articulate the key points,
+  its market opportunities, and potential risks.
+  """,
+  expected_output='A comprehensive 3 paragraphs long report on the latest AI trends.',
+  max_inter=3,
+  tools=[search_tool],
+  agent=researcher
 )
 
-# Task for the writer
+# Writing task based on research findings
 write_task = Task(
-  description='Write an article on AI advancements leveraging the research made.',
-  agent=writer  # Assigning the task to the writer
+  description=f"""Compose an insightful article on {topic}.
+  Focus on the latest trends and how it's impacting the industry.
+  This article should be easy to understand, engaging and positive.
+  """,
+  expected_output=f'A 4 paragraph article on {topic} advancements.',
+  tools=[search_tool],
+  agent=writer
 )
 ```
 
-# Step 3: Form the Crew
-
-Bring your agents together into a crew. This is where you define the process they'll follow to complete their tasks.
+## Step 3: Form the Crew
+Combine your agents into a crew, setting the workflow process they'll follow to accomplish the tasks.
 
 ```python
 from crewai import Crew, Process
 
-# Instantiate your crew
-tech_crew = Crew(
+# Forming the tech-focused crew
+crew = Crew(
   agents=[researcher, writer],
   tasks=[research_task, write_task],
-  process=Process.sequential  # Tasks will be executed one after the other
+  process=Process.sequential  # Sequential task execution
 )
 ```
 
-# Step 4: Kick It Off
-
-With the crew formed and the stage set, it's time to start the show. Kick off the process and watch as your agents collaborate to achieve their goals.
+## Step 4: Kick It Off
+With your crew ready and the stage set, initiate the process. Watch as your agents collaborate, each contributing their expertise to achieve the collective goal.
 
 ```python
-# Begin the task execution
-tech_crew.kickoff()
+# Starting the task execution process
+result = crew.kickoff()
+print(result)
 ```
 
-# Conclusion
-
-Creating a crew and setting it into motion is a straightforward process in CrewAI. With each agent playing their part and a clear set of tasks, your AI ensemble is ready to take on any challenge. Remember, the richness of their backstories and the clarity of their goals will greatly enhance their performance and the outcomes of their collaboration.
+## Conclusion
+Building and activating a crew in CrewAI is a seamless process. By carefully assigning roles, tasks, and a clear process, your AI team is equipped to tackle challenges efficiently. The depth of agent backstories and the precision of their objectives enrich the collaboration, leading to successful project outcomes.

docs/how-to/Customizing-Agents.md

@@ -1,45 +1,45 @@
-# Customizable Attributes
+---
+title: Customizing Agents in CrewAI
+description: A guide to tailoring agents for specific roles and tasks within the CrewAI framework.
+---
 
-Customizing your AI agents is a cornerstone of creating an effective CrewAI team. Each agent can be tailored to fit the unique needs of your project, allowing for a dynamic and versatile AI workforce.
+## Customizable Attributes
+Tailoring your AI agents is pivotal in crafting an efficient CrewAI team. Customization allows agents to be dynamically adapted to the unique requirements of any project.
 
-When you initialize an Agent, you can set various attributes that define its behavior and role within the Crew:
+### Key Attributes for Customization
+- **Role**: Defines the agent's job within the crew, such as 'Analyst' or 'Customer Service Rep'.
+- **Goal**: The agent's objective, aligned with its role and the crew's overall goals.
+- **Backstory**: Adds depth to the agent's character, enhancing its role and motivations within the crew.
+- **Tools**: The capabilities or methods the agent employs to accomplish tasks, ranging from simple functions to complex integrations.
 
-- **Role**: The job title or function of the agent within your crew. This can be anything from 'Analyst' to 'Customer Service Rep'.
-- **Goal**: What the agent is aiming to achieve. Goals should be aligned with the agent's role and the overall objectives of the crew.
-- **Backstory**: A narrative that provides depth to the agent's character. This could include previous experience, motivations, or anything that adds context to their role.
-- **Tools**: The abilities or methods the agent uses to complete tasks. This could be as simple as a 'search' function or as complex as a custom-built analysis tool.
+## Understanding Tools in CrewAI
+Tools empower agents with functionalities to interact and manipulate their environment, from generic utilities to specialized functions. Integrating with LangChain offers access to a broad range of tools for diverse tasks.
 
-# Understanding Tools in CrewAI
-
-Tools in CrewAI are functions that empower agents to interact with the world around them. These can range from generic utilities like a search function to more complex ones like integrating with an external API. The integration with LangChain allows you to utilize a suite of ready-to-use tools such as [Google Serper](https://python.langchain.com/docs/integrations/tools/google_serper), which enables agents to perform web searches and gather data.
-
-# Customizing Agents and Tools
-
-You can customize an agent by passing parameters when creating an instance. Each parameter tweaks how the agent behaves and interacts within the crew.
-
-Customizing an agent's tools is particularly important. Tools define what an agent can do and how it interacts with tasks. For instance, if a task requires data analysis, assigning an agent with data-related tools would be optimal.
-
-When initializing your agents, you can equip them with a set of tools that enable them to perform their roles more effectively:
+## Customizing Agents and Tools
+Agents are customized by defining their attributes during initialization, with tools being a critical aspect of their functionality.
 
+### Example: Assigning Tools to an Agent
 ```python
 from crewai import Agent
 from langchain.agents import Tool
 from langchain.utilities import GoogleSerperAPIWrapper
+import os
 
-# Initialize SerpAPI tool with your API key
+# Set API keys for tool initialization
 os.environ["OPENAI_API_KEY"] = "Your Key"
 os.environ["SERPER_API_KEY"] = "Your Key"
 
-search = GoogleSerperAPIWrapper()
+# Initialize a search tool
+search_tool = GoogleSerperAPIWrapper()
 
-# Create tool to be used by agent
+# Define and assign the tool to an agent
 serper_tool = Tool(
   name="Intermediate Answer",
-  func=search.run,
-  description="useful for when you need to ask with search",
+  func=search_tool.run,
+  description="Useful for search-based queries"
 )
 
-# Create an agent and assign the search tool
+# Initialize the agent with the tool
 agent = Agent(
   role='Research Analyst',
   goal='Provide up-to-date market analysis',
@@ -49,18 +49,17 @@ agent = Agent(
 ```
 
 ## Delegation and Autonomy
+Agents in CrewAI can delegate tasks or ask questions, enhancing the crew's collaborative dynamics. This feature can be disabled to ensure straightforward task execution.
 
-One of the most powerful aspects of CrewAI agents is their ability to delegate tasks to one another. Each agent by default can delegate work or ask question to anyone in the crew, but you can disable that by setting `allow_delegation` to `false`, this is particularly useful for straightforward agents that should execute their tasks in isolation.
-
+### Example: Disabling Delegation for an Agent
 ```python
 agent = Agent(
   role='Content Writer',
-  goal='Write the most amazing content related to market trends an business.',
-  backstory='An expert writer with many years of experience in market trends, stocks and all business related things.',
+  goal='Write engaging content on market trends',
+  backstory='A seasoned writer with expertise in market analysis.',
   allow_delegation=False
 )
 ```
 
 ## Conclusion
-
-Customization is what makes CrewAI powerful. By adjusting the attributes of each agent, you can ensure that your AI team is well-equipped to handle the challenges you set for them. Remember, the more thought you put into your agents' roles, goals, backstories, and tools, the more nuanced and effective their interactions and task execution will be.
+Customizing agents is key to leveraging the full potential of CrewAI. By thoughtfully setting agents' roles, goals, backstories, and tools, you craft a nuanced and capable AI team ready to tackle complex challenges.