+
+
+
+## Step 2: Explore the Project Structure
+
+Let's take a moment to understand the project structure created by the CLI:
+
+```
+research_crew/
+├── .gitignore
+├── pyproject.toml
+├── README.md
+├── .env
+└── src/
+ └── research_crew/
+ ├── __init__.py
+ ├── main.py
+ ├── crew.py
+ ├── tools/
+ │ ├── custom_tool.py
+ │ └── __init__.py
+ └── config/
+ ├── agents.yaml
+ └── tasks.yaml
+```
+
+This structure follows best practices for Python projects and makes it easy to organize your code.
+
+## Step 3: Configure Your Agents
+
+Let's modify the `agents.yaml` file to define two specialized agents: a researcher and an analyst.
+
+```yaml
+# src/research_crew/config/agents.yaml
+researcher:
+ role: >
+ Senior Research Specialist for {topic}
+ goal: >
+ Find comprehensive and accurate information about {topic}
+ with a focus on recent developments and key insights
+ backstory: >
+ You are an experienced research specialist with a talent for
+ finding relevant information from various sources. You excel at
+ organizing information in a clear and structured manner, making
+ complex topics accessible to others.
+ llm: openai/gpt-4o-mini
+
+analyst:
+ role: >
+ Data Analyst and Report Writer for {topic}
+ goal: >
+ Analyze research findings and create a comprehensive, well-structured
+ report that presents insights in a clear and engaging way
+ backstory: >
+ You are a skilled analyst with a background in data interpretation
+ and technical writing. You have a talent for identifying patterns
+ and extracting meaningful insights from research data, then
+ communicating those insights effectively through well-crafted reports.
+ llm: openai/gpt-4o-mini
+```
+
+## Step 4: Define Your Tasks
+
+Now, let's modify the `tasks.yaml` file to define the research and analysis tasks:
+
+```yaml
+# src/research_crew/config/tasks.yaml
+research_task:
+ description: >
+ Conduct thorough research on {topic}. Focus on:
+ 1. Key concepts and definitions
+ 2. Historical development and recent trends
+ 3. Major challenges and opportunities
+ 4. Notable applications or case studies
+ 5. Future outlook and potential developments
+
+ Make sure to organize your findings in a structured format with clear sections.
+ expected_output: >
+ A comprehensive research document with well-organized sections covering
+ all the requested aspects of {topic}. Include specific facts, figures,
+ and examples where relevant.
+ agent: researcher
+
+analysis_task:
+ description: >
+ Analyze the research findings and create a comprehensive report on {topic}.
+ Your report should:
+ 1. Begin with an executive summary
+ 2. Include all key information from the research
+ 3. Provide insightful analysis of trends and patterns
+ 4. Offer recommendations or future considerations
+ 5. Be formatted in a professional, easy-to-read style with clear headings
+ expected_output: >
+ A polished, professional report on {topic} that presents the research
+ findings with added analysis and insights. The report should be well-structured
+ with an executive summary, main sections, and conclusion.
+ agent: analyst
+ context:
+ - research_task
+ output_file: output/report.md
+```
+
+## Step 5: Configure Your Crew
+
+Now, let's modify the `crew.py` file to set up our research crew:
+
+```python
+# src/research_crew/crew.py
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+from crewai_tools import SerperDevTool
+
+@CrewBase
+class ResearchCrew():
+ """Research crew for comprehensive topic analysis and reporting"""
+
+ @agent
+ def researcher(self) -> Agent:
+ return Agent(
+ config=self.agents_config['researcher'],
+ verbose=True,
+ tools=[SerperDevTool()]
+ )
+
+ @agent
+ def analyst(self) -> Agent:
+ return Agent(
+ config=self.agents_config['analyst'],
+ verbose=True
+ )
+
+ @task
+ def research_task(self) -> Task:
+ return Task(
+ config=self.tasks_config['research_task']
+ )
+
+ @task
+ def analysis_task(self) -> Task:
+ return Task(
+ config=self.tasks_config['analysis_task'],
+ output_file='output/report.md'
+ )
+
+ @crew
+ def crew(self) -> Crew:
+ """Creates the research crew"""
+ return Crew(
+ agents=self.agents,
+ tasks=self.tasks,
+ process=Process.sequential,
+ verbose=True,
+ )
+```
+
+## Step 6: Set Up Your Main Script
+
+Let's modify the `main.py` file to run our crew:
+
+```python
+#!/usr/bin/env python
+# src/research_crew/main.py
+import os
+from research_crew.crew import ResearchCrew
+
+# Create output directory if it doesn't exist
+os.makedirs('output', exist_ok=True)
+
+def run():
+ """
+ Run the research crew.
+ """
+ inputs = {
+ 'topic': 'Artificial Intelligence in Healthcare'
+ }
+
+ # Create and run the crew
+ result = ResearchCrew().crew().kickoff(inputs=inputs)
+
+ # Print the result
+ print("\n\n=== FINAL REPORT ===\n\n")
+ print(result.raw)
+
+ print("\n\nReport has been saved to output/report.md")
+
+if __name__ == "__main__":
+ run()
+```
+
+## Step 7: Set Up Your Environment Variables
+
+Create a `.env` file in your project root with your API keys:
+
+```
+OPENAI_API_KEY=your_openai_api_key
+SERPER_API_KEY=your_serper_api_key
+```
+
+You can get a Serper API key from [Serper.dev](https://serper.dev/).
+
+## Step 8: Install Dependencies
+
+Install the required dependencies using the CrewAI CLI:
+
+```bash
+crewai install
+```
+
+This command will:
+1. Read the dependencies from your project configuration
+2. Create a virtual environment if needed
+3. Install all required packages
+
+## Step 9: Run Your Crew
+
+Now, run your crew using the CrewAI CLI:
+
+```bash
+crewai run
+```
+
+Your crew will start working! The researcher will gather information about the specified topic, and the analyst will create a comprehensive report based on that research.
+
+## Step 10: Review the Output
+
+Once the crew completes its work, you'll find the final report in the `output/report.md` file. The report will include:
+
+1. An executive summary
+2. Detailed information about the topic
+3. Analysis and insights
+4. Recommendations or future considerations
+
+## Exploring Other CLI Commands
+
+CrewAI offers several other useful CLI commands for working with crews:
+
+```bash
+# View all available commands
+crewai --help
+
+# Run the crew
+crewai run
+
+# Test the crew
+crewai test
+
+# Reset crew memories
+crewai reset-memories
+
+# Replay from a specific task
+crewai replay -t 
+
+
+## Step 2: Understanding the Project Structure
+
+The generated project has the following structure:
+
+```
+guide_creator_flow/
+├── .gitignore
+├── pyproject.toml
+├── README.md
+├── .env
+├── main.py
+├── crews/
+│ └── poem_crew/
+│ ├── config/
+│ │ ├── agents.yaml
+│ │ └── tasks.yaml
+│ └── poem_crew.py
+└── tools/
+ └── custom_tool.py
+```
+
+We'll modify this structure to create our guide creator flow.
+
+## Step 3: Add a Content Writer Crew
+
+Let's use the CrewAI CLI to add a content writer crew:
+
+```bash
+crewai flow add-crew content-crew
+```
+
+This command will automatically create the necessary directories and template files.
+
+## Step 4: Configure the Content Writer Crew
+
+Now, let's modify the generated files for the content writer crew:
+
+1. First, update the agents configuration file:
+
+```yaml
+# src/guide_creator_flow/crews/content_crew/config/agents.yaml
+content_writer:
+ role: >
+ Educational Content Writer
+ goal: >
+ Create engaging, informative content that thoroughly explains the assigned topic
+ and provides valuable insights to the reader
+ backstory: >
+ You are a talented educational writer with expertise in creating clear, engaging
+ content. You have a gift for explaining complex concepts in accessible language
+ and organizing information in a way that helps readers build their understanding.
+ llm: openai/gpt-4o-mini
+
+content_reviewer:
+ role: >
+ Educational Content Reviewer and Editor
+ goal: >
+ Ensure content is accurate, comprehensive, well-structured, and maintains
+ consistency with previously written sections
+ backstory: >
+ You are a meticulous editor with years of experience reviewing educational
+ content. You have an eye for detail, clarity, and coherence. You excel at
+ improving content while maintaining the original author's voice and ensuring
+ consistent quality across multiple sections.
+ llm: openai/gpt-4o-mini
+```
+
+2. Next, update the tasks configuration file:
+
+```yaml
+# src/guide_creator_flow/crews/content_crew/config/tasks.yaml
+write_section_task:
+ description: >
+ Write a comprehensive section on the topic: "{section_title}"
+
+ Section description: {section_description}
+ Target audience: {audience_level} level learners
+
+ Your content should:
+ 1. Begin with a brief introduction to the section topic
+ 2. Explain all key concepts clearly with examples
+ 3. Include practical applications or exercises where appropriate
+ 4. End with a summary of key points
+ 5. Be approximately 500-800 words in length
+
+ Format your content in Markdown with appropriate headings, lists, and emphasis.
+
+ Previously written sections:
+ {previous_sections}
+
+ Make sure your content maintains consistency with previously written sections
+ and builds upon concepts that have already been explained.
+ expected_output: >
+ A well-structured, comprehensive section in Markdown format that thoroughly
+ explains the topic and is appropriate for the target audience.
+ agent: content_writer
+
+review_section_task:
+ description: >
+ Review and improve the following section on "{section_title}":
+
+ {draft_content}
+
+ Target audience: {audience_level} level learners
+
+ Previously written sections:
+ {previous_sections}
+
+ Your review should:
+ 1. Fix any grammatical or spelling errors
+ 2. Improve clarity and readability
+ 3. Ensure content is comprehensive and accurate
+ 4. Verify consistency with previously written sections
+ 5. Enhance the structure and flow
+ 6. Add any missing key information
+
+ Provide the improved version of the section in Markdown format.
+ expected_output: >
+ An improved, polished version of the section that maintains the original
+ structure but enhances clarity, accuracy, and consistency.
+ agent: content_reviewer
+ context:
+ - write_section_task
+```
+
+3. Now, update the crew implementation file:
+
+```python
+# src/guide_creator_flow/crews/content_crew/content_crew.py
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+
+@CrewBase
+class ContentCrew():
+ """Content writing crew"""
+
+ @agent
+ def content_writer(self) -> Agent:
+ return Agent(
+ config=self.agents_config['content_writer'],
+ verbose=True
+ )
+
+ @agent
+ def content_reviewer(self) -> Agent:
+ return Agent(
+ config=self.agents_config['content_reviewer'],
+ verbose=True
+ )
+
+ @task
+ def write_section_task(self) -> Task:
+ return Task(
+ config=self.tasks_config['write_section_task']
+ )
+
+ @task
+ def review_section_task(self) -> Task:
+ return Task(
+ config=self.tasks_config['review_section_task'],
+ context=[self.write_section_task]
+ )
+
+ @crew
+ def crew(self) -> Crew:
+ """Creates the content writing crew"""
+ return Crew(
+ agents=self.agents,
+ tasks=self.tasks,
+ process=Process.sequential,
+ verbose=True,
+ )
+```
+
+## Step 5: Create the Flow
+
+Now, let's create our flow in the `main.py` file. This flow will:
+1. Get user input for a topic
+2. Make a direct LLM call to create a structured guide outline
+3. Process each section in parallel using the content writer crew
+4. Combine everything into a final document
+
+```python
+#!/usr/bin/env python
+import json
+from typing import List, Dict
+from pydantic import BaseModel, Field
+from crewai import LLM
+from crewai.flow.flow import Flow, listen, start
+from guide_creator_flow.crews.content_crew.content_crew import ContentCrew
+
+# Define our models for structured data
+class Section(BaseModel):
+ title: str = Field(description="Title of the section")
+ description: str = Field(description="Brief description of what the section should cover")
+
+class GuideOutline(BaseModel):
+ title: str = Field(description="Title of the guide")
+ introduction: str = Field(description="Introduction to the topic")
+ target_audience: str = Field(description="Description of the target audience")
+ sections: List[Section] = Field(description="List of sections in the guide")
+ conclusion: str = Field(description="Conclusion or summary of the guide")
+
+# Define our flow state
+class GuideCreatorState(BaseModel):
+ topic: str = ""
+ audience_level: str = ""
+ guide_outline: GuideOutline = None
+ sections_content: Dict[str, str] = {}
+
+class GuideCreatorFlow(Flow[GuideCreatorState]):
+ """Flow for creating a comprehensive guide on any topic"""
+
+ @start()
+ def get_user_input(self):
+ """Get input from the user about the guide topic and audience"""
+ print("\n=== Create Your Comprehensive Guide ===\n")
+
+ # Get user input
+ self.state.topic = input("What topic would you like to create a guide for? ")
+
+ # Get audience level with validation
+ while True:
+ audience = input("Who is your target audience? (beginner/intermediate/advanced) ").lower()
+ if audience in ["beginner", "intermediate", "advanced"]:
+ self.state.audience_level = audience
+ break
+ print("Please enter 'beginner', 'intermediate', or 'advanced'")
+
+ print(f"\nCreating a guide on {self.state.topic} for {self.state.audience_level} audience...\n")
+ return self.state
+
+ @listen(get_user_input)
+ def create_guide_outline(self, state):
+ """Create a structured outline for the guide using a direct LLM call"""
+ print("Creating guide outline...")
+
+ # Initialize the LLM
+ llm = LLM(model="openai/gpt-4o-mini", response_format=GuideOutline)
+
+ # Create the messages for the outline
+ messages = [
+ {"role": "system", "content": "You are a helpful assistant designed to output JSON."},
+ {"role": "user", "content": f"""
+ Create a detailed outline for a comprehensive guide on "{state.topic}" for {state.audience_level} level learners.
+
+ The outline should include:
+ 1. A compelling title for the guide
+ 2. An introduction to the topic
+ 3. 4-6 main sections that cover the most important aspects of the topic
+ 4. A conclusion or summary
+
+ For each section, provide a clear title and a brief description of what it should cover.
+ """}
+ ]
+
+ # Make the LLM call with JSON response format
+ response = llm.call(messages=messages)
+
+ # Parse the JSON response
+ outline_dict = json.loads(response)
+ self.state.guide_outline = GuideOutline(**outline_dict)
+
+ # Save the outline to a file
+ with open("output/guide_outline.json", "w") as f:
+ json.dump(outline_dict, f, indent=2)
+
+ print(f"Guide outline created with {len(self.state.guide_outline.sections)} sections")
+ return self.state.guide_outline
+
+ @listen(create_guide_outline)
+ def write_and_compile_guide(self, outline):
+ """Write all sections and compile the guide"""
+ print("Writing guide sections and compiling...")
+ completed_sections = []
+
+ # Process sections one by one to maintain context flow
+ for section in outline.sections:
+ print(f"Processing section: {section.title}")
+
+ # Build context from previous sections
+ previous_sections_text = ""
+ if completed_sections:
+ previous_sections_text = "# Previously Written Sections\n\n"
+ for title in completed_sections:
+ previous_sections_text += f"## {title}\n\n"
+ previous_sections_text += self.state.sections_content.get(title, "") + "\n\n"
+ else:
+ previous_sections_text = "No previous sections written yet."
+
+ # Run the content crew for this section
+ result = ContentCrew().crew().kickoff(inputs={
+ "section_title": section.title,
+ "section_description": section.description,
+ "audience_level": self.state.audience_level,
+ "previous_sections": previous_sections_text,
+ "draft_content": ""
+ })
+
+ # Store the content
+ self.state.sections_content[section.title] = result.raw
+ completed_sections.append(section.title)
+ print(f"Section completed: {section.title}")
+
+ # Compile the final guide
+ guide_content = f"# {outline.title}\n\n"
+ guide_content += f"## Introduction\n\n{outline.introduction}\n\n"
+
+ # Add each section in order
+ for section in outline.sections:
+ section_content = self.state.sections_content.get(section.title, "")
+ guide_content += f"\n\n{section_content}\n\n"
+
+ # Add conclusion
+ guide_content += f"## Conclusion\n\n{outline.conclusion}\n\n"
+
+ # Save the guide
+ with open("output/complete_guide.md", "w") as f:
+ f.write(guide_content)
+
+ print("\nComplete guide compiled and saved to output/complete_guide.md")
+ return "Guide creation completed successfully"
+
+def kickoff():
+ """Run the guide creator flow"""
+ GuideCreatorFlow().kickoff()
+ print("\n=== Flow Complete ===")
+ print("Your comprehensive guide is ready in the output directory.")
+ print("Open output/complete_guide.md to view it.")
+
+def plot():
+ """Generate a visualization of the flow"""
+ flow = GuideCreatorFlow()
+ flow.plot("guide_creator_flow")
+ print("Flow visualization saved to guide_creator_flow.html")
+
+if __name__ == "__main__":
+ kickoff()
+```
+
+## Step 6: Set Up Your Environment Variables
+
+Create a `.env` file in your project root with your API keys:
+
+```
+OPENAI_API_KEY=your_openai_api_key
+```
+
+## Step 7: Install Dependencies
+
+Install the required dependencies:
+
+```bash
+crewai install
+```
+
+## Step 8: Run Your Flow
+
+Now, run your flow using the CrewAI CLI:
+
+```bash
+crewai flow kickoff
+```
+
+Your flow will:
+
+1. Prompt you for a topic and target audience
+2. Make a direct LLM call to create a structured guide outline
+3. Process each section in parallel using the content writer crew
+4. Combine everything into a final comprehensive guide
+
+This demonstrates the power of flows to orchestrate different types of operations, including user input, direct LLM interactions, and crew-based processing.
+
+## Step 9: Visualize Your Flow
+
+You can also generate a visualization of your flow:
+
+```bash
+crewai flow plot
+```
+
+This will create an HTML file that shows the structure of your flow, which can be helpful for understanding and debugging.
+
+## Step 10: Review the Output
+
+Once the flow completes, you'll find two files in the `output` directory:
+
+1. `guide_outline.json`: Contains the structured outline of the guide
+2. `complete_guide.md`: The comprehensive guide with all sections
+
+## Key Features Demonstrated
+
+This guide creator flow demonstrates several powerful features of CrewAI:
+
+1. **User interaction**: The flow collects input directly from the user
+2. **Direct LLM calls**: Uses the LLM class for efficient, single-purpose AI interactions
+3. **Structured data with Pydantic**: Uses Pydantic models to ensure type safety
+4. **Sequential processing with context**: Writes sections in order, providing previous sections for context
+5. **Multi-agent crews**: Leverages specialized agents (writer and reviewer) for content creation
+6. **State management**: Maintains state across different steps of the process
+
+## Understanding the Flow Structure
+
+Let's break down the key components of this flow:
+
+### 1. Direct LLM Calls
+
+The flow uses CrewAI's `LLM` class to make direct calls to the language model:
+
+```python
+llm = LLM(model="openai/gpt-4o-mini")
+response = llm.call(prompt)
+```
+
+This is more efficient than using a crew when you need a simple, structured response.
+
+### 2. Asynchronous Processing
+
+The flow uses async/await to process multiple sections in parallel:
+
+```python
+@listen(create_guide_outline)
+async def write_sections(self, outline):
+ # ...
+ section_tasks = []
+ for section in outline.sections:
+ task = self.write_section(section, outline.target_audience)
+ section_tasks.append(task)
+
+ sections_content = await asyncio.gather(*section_tasks)
+ # ...
+```
+
+This significantly speeds up the guide creation process.
+
+### 3. Multi-Agent Crews
+
+The flow uses a crew with multiple specialized agents:
+
+```python
+# Content creation crew with writer and reviewer
+@agent
+def content_writer(self) -> Agent:
+ return Agent(
+ config=self.agents_config['content_writer'],
+ verbose=True
+ )
+
+@agent
+def content_reviewer(self) -> Agent:
+ return Agent(
+ config=self.agents_config['content_reviewer'],
+ verbose=True
+ )
+```
+
+This demonstrates how flows can orchestrate crews with multiple specialized agents that work together on complex tasks.
+
+### 4. Context-Aware Sequential Processing
+
+The flow processes sections in order, providing previous sections as context:
+
+```python
+# Getting previous sections for context
+previous_sections_text = ""
+if self.state.completed_sections:
+ previous_sections_text = "# Previously Written Sections\n\n"
+ for title in self.state.completed_sections:
+ previous_sections_text += f"## {title}\n\n"
+ previous_sections_text += self.state.sections_content.get(title, "") + "\n\n"
+```
+
+This ensures coherence and continuity throughout the guide.
+
+## Customizing Your Flow
+
+You can customize your flow in several ways:
+
+1. **Add more user inputs**: Collect additional information about the desired guide
+2. **Enhance the outline**: Modify the LLM prompt to create more detailed outlines
+3. **Add more crews**: Use different crews for different parts of the guide
+4. **Add review steps**: Include a review and refinement step for the final guide
+
+## Next Steps
+
+Now that you've built your first flow, you can:
+
+1. Experiment with more complex flow structures
+2. Try using `@router()` to create conditional branches
+3. Explore the `and_` and `or_` functions for more complex parallel execution
+4. Connect your flow to external APIs or services
+
+
+ 
| Component | Description | Key Features |
@@ -53,12 +56,87 @@ Think of it as assembling your dream team - each member (agent) brings unique sk
+## How Flows Work
+
+
+
+
+| Component | Description | Key Features |
+|:----------|:-----------:|:------------|
+| **Flow** | Structured workflow orchestration | • Manages execution paths• Handles state transitions
• Controls task sequencing
• Ensures reliable execution | +| **Events** | Triggers for workflow actions | • Initiate specific processes
• Enable dynamic responses
• Support conditional branching
• Allow for real-time adaptation | +| **States** | Workflow execution contexts | • Maintain execution data
• Enable persistence
• Support resumability
• Ensure execution integrity | +| **Crew Support** | Enhances workflow automation | • Injects pockets of agency when needed
• Complements structured workflows
• Balances automation with intelligence
• Enables adaptive decision-making | + +### Key Capabilities + +