CrewAI CLI Quick Quide

# Install CrewAI core
pip install crewai

# Install CrewAI with additional tools
pip install 'crewai[tools]'

# Fix tiktoken issues
pip install 'crewai[embeddings]'

# Create a new CrewAI project
crewai create crew <project_name>

# Example
crewai create crew my-ai-team

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

# Install dependencies (optional)
crewai install

# Run the crew
crewai run

# Update CrewAI version
crewai update

# Direct Python execution
python src/my_project/main.py

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 clearly.

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 turn complex
    data into clear and actionable reports.

research_task:
  description: >
    Conduct thorough research about {topic}. Make sure you find any interesting
    and relevant information given the current year is 2025.
  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 all relevant information.
  expected_output: >
    A fully fledged report with main topics, each with a full section of
    information. Formatted as markdown without '```'
  agent: reporting_analyst
  output_file: report.md

from crewai import Agent

# Define agent with specific role and capabilities
agent = Agent(
    role="Senior Data Researcher",
    goal="Uncover cutting-edge developments in AI",
    backstory="Expert researcher with deep domain knowledge",
    verbose=True,
    tools=[SerperDevTool()],  # Add tools as needed
    llm=llm_instance  # Optional: specify LLM
)

from crewai import Task

# Define task with clear objectives
task = Task(
    description="Research the latest trends in AI",
    expected_output="Comprehensive report with key findings",
    agent=researcher,
    output_file="research_report.md"  # Optional: save output
)

from crewai import Crew, Process

# Create crew with agents and tasks
crew = Crew(
    agents=[researcher, analyst],
    tasks=[research_task, analysis_task],
    process=Process.sequential,  # or Process.hierarchical
    verbose=True
)

# Execute crew
result = crew.kickoff(inputs={'topic': 'AI Agents'})

from crewai.flow.flow import Flow, start, listen, router

class AnalysisFlow(Flow):
    @start()
    def fetch_data(self):
        return {"data": "initial_data"}

    @listen(fetch_data)
    def analyze_data(self, data):
        # Process data with crew or custom logic
        return analysis_results

    @router(analyze_data)
    def route_next_step(self):
        # Conditional routing based on results
        if confidence > 0.8:
            return "high_confidence"
        return "needs_review"

crew = Crew(
    agents=[agent1, agent2],
    tasks=[task1, task2],
    process=Process.sequential
)

crew = Crew(
    agents=[agent1, agent2],
    tasks=[task1, task2],
    process=Process.hierarchical
)

from crewai_tools import SerperDevTool, WebsiteSearchTool

# Web search
search_tool = SerperDevTool()

# Website content search
website_tool = WebsiteSearchTool()

from crewai_tools import (
    FileReadTool,
    DirectoryReadTool,
    PDFSearchTool,
    CSVSearchTool
)

# File operations
file_tool = FileReadTool()
pdf_tool = PDFSearchTool()
csv_tool = CSVSearchTool()

from crewai_tools import CodeDocsSearchTool, GithubSearchTool

# Code documentation search
code_docs = CodeDocsSearchTool()

# GitHub repository search
github_tool = GithubSearchTool()

# .env file
OPENAI_API_KEY=sk-...
SERPER_API_KEY=your_serper_key
ANTHROPIC_API_KEY=your_anthropic_key  # If using Claude

from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic

# OpenAI
openai_llm = ChatOpenAI(model="gpt-4")

# Anthropic
anthropic_llm = ChatAnthropic(model="claude-3-sonnet-20240229")

# Local models with Ollama
from langchain_ollama import ChatOllama
local_llm = ChatOllama(model="llama3")

# Simple crew execution
result = crew.kickoff()
print(result)

# Pass input parameters
inputs = {
    'topic': 'Machine Learning',
    'industry': 'Healthcare',
    'timeframe': '2024'
}
result = crew.kickoff(inputs=inputs)

import asyncio

async def run_crew():
    result = await crew.kickoff_async(inputs=inputs)
    return result

# Run async
result = asyncio.run(run_crew())

# Run crew multiple times with different inputs
inputs_list = [
    {'topic': 'AI'},
    {'topic': 'ML'},
    {'topic': 'NLP'}
]

results = crew.kickoff_for_each(inputs=inputs_list)

from crewai.tools import BaseTool
from pydantic import BaseModel, Field

class MyCustomTool(BaseTool):
    name: str = "My Custom Tool"
    description: str = "Description of what the tool does"

    def _run(self, query: str) -> str:
        # Tool implementation
        return f"Processed: {query}"

from crewai import Task

task_with_human_input = Task(
    description="Analyze data and get human approval",
    expected_output="Analysis with human validation",
    agent=analyst,
    human_input=True
)

crew = Crew(
    agents=[agent],
    tasks=[task],
    memory=True,  # Enable memory
    verbose=True
)

# Train crew based on execution results
crew.train(
    n_iterations=5,
    filename="training_data.pkl"
)

crew = Crew(
    agents=[agent],
    tasks=[task],
    verbose=True,  # Enable detailed logging
    share_crew=False  # Control telemetry
)

# Module not found errors
pip install 'crewai[tools]'

# Dependency conflicts
pip install --upgrade crewai

# Memory issues with large crews
# Reduce agent count or use hierarchical process

crew = Crew(
    agents=[agent],
    tasks=[task],
    verbose=True,  # Enable debug output
)

try:
    result = crew.kickoff()
except Exception as e:
    print(f"Crew execution failed: {e}")
    # Implement recovery logic

import streamlit as st
from crewai import Crew, Agent, Task

st.title("CrewAI Interface")
topic = st.text_input("Enter research topic:")

if st.button("Run Analysis"):
    result = crew.kickoff(inputs={'topic': topic})
    st.write(result)

from fastapi import FastAPI
from crewai import Crew

app = FastAPI()

@app.post("/analyze")
async def analyze(topic: str):
    result = await crew.kickoff_async(inputs={'topic': topic})
    return {"result": result}