CrewAI Tutorial: Complete Crash Course for Beginners

High-level overview

• This video is a hands-on crash course for CrewAI, a framework for orchestrating multiple AI agents.
• Organized into three parts:
  1. What CrewAI is.
  2. How it works — the four core components.
  3. A live build: creating a Trip Planner crew from scratch.
• Purpose: teach how to design agents, tools, tasks, and processes; wire them together; run a crew; and debug/optimize for cost and accuracy.

Key technological concepts and architecture

Core components of a Crew

1. Agents
   • Autonomous, role-based workers (e.g., “Expert Travel Agent”, “City Selection Expert”, “Local Tour Guide”).
   • Properties: role, goal, backstory/resume, permitted tools, and delegation rules.
2. Tools
   • Functions available to agents, decorated with @tool so Crew/LangChain can call them.
   • Two types: built-in LangChain tools and custom tools you implement (examples: calculator, search, SEC filings fetcher).
   • Tools can be:
     • Simple: accept a free-form string.
     • Strict: define argument schemas via Pydantic models.
3. Tasks
   • Specific jobs assigned to agents. Should include: clear description, parameters, expected output format, and step-by-step instructions.
   • Tasks are critical to avoid low-quality outputs.
4. Processes
   • Orchestrate how work flows between agents and tasks.
   • Current recommended mode: sequential (agent A runs, outputs passed to agent B).
   • Future modes may include hierarchical orchestration.

Example use cases / demos

• Stock analyst crew Researches a company (news + SEC filings), builds internal memory, and produces a buy/hold/sell report. Demonstrates a custom filings tool and multi-agent coordination.

• Trip planner crew (main tutorial) From user inputs (origin, destination, dates, interests) it uses a city selector, local expert, and itinerary planner to produce a 7-day itinerary with daily plans, budget breakdown, packing recommendations, and weather notes.

• Game builder crew Agents iteratively generate and review source code (e.g., a Pong game), continuously approving and refining until runnable code is produced.

Hands-on build (Trip Planner) — key steps and recommendations

1. Start

   • Clone Xiao’s CrewAI starter/examples repo (use the template repository as the basis).

2. Environment & dependencies

   • Use Poetry (installed via pipx) to create and lock the Python environment.
   • Create pyproject.toml with required dependencies (CrewAI, LangChain, OpenAI client, and other libraries for weather/formatting).
   • Add linting/type checking tools (video references type checker + formatter).
   • Activate the Poetry shell and set the VS Code interpreter to the Poetry virtualenv.

3. Secrets

   • Store API keys in a .env file and add .env to .gitignore.
   • Example keys: Serper API key for web search and OpenAI API key for LLM calls.

4. Tools

   • Build a calculator tool (simple arithmetic). Optionally use a Pydantic schema for stricter args.
   • Build a search tool that calls Serper (or another search API). Return top results (title, URL, snippet).
   • Optional: SEC API-based tool for filing retrieval (used in stock analyst demo).
   • Use the @tool decorator so tools are discoverable by Crew/LangChain.

5. Agents

   • Define hierarchical agents (captain/manager + experts + workers). Example for trip planner:
     • Expert Travel Agent (captain)
     • City Selection Expert
     • Local Tour Guide
   • For each agent: set role, a clear results-driven goal, a backstory/resume, LLM model settings (e.g., GPT-4 for quality, GPT-3.5 for cheaper testing), and allowed tools.
   • Keep agents reusable and focused.

6. Tasks

   • Create explicit task templates: name, detailed instructions, parameters (city, dates, interests), and required output format.
   • Example tasks: plan_itinerary, identify_cities, gather_city_info.
   • Make outputs deterministic/structured so downstream agents can consume them.
   • Tip/self-reward trick: include a small “reward” string or bias in prompts to encourage better outputs (used in examples).

7. Main crew wiring

   • In main.py: instantiate agents, associate tools, define tasks with parameter bindings, register a sequential process, and call run to start the crew.
   • Provide CLI inputs: origin, cities, date range, traveler interests.

8. Debugging & gotchas

   • VS Code interpreter must point to the Poetry venv or imports will show unresolved packages.
   • Package name collisions: an installed package named tools can shadow your local tools module — fix with poetry remove tools.
   • Validate task parameter counts and names carefully; missing parameters can cause runtime errors.
   • Keep API keys private; don’t push .env to GitHub.
   • Costs: many GPT-4 calls are expensive. Use GPT-3.5 for iterative testing and switch to GPT-4 for final runs.

Implementation details and best practices

• Start with a single high-level goal and decompose it into many subtasks (10–100). The ideal workflow synthesizes many subtasks back into one final output.
• Make agents “results-driven”: explicit, actionable goals and example outputs reduce hallucinations and circular behavior.
• Prefer explicit, structured outputs from tasks so downstream agents can parse and act on them.
• Use Pydantic schemas for tool arguments when stricter input validation is needed.
• Start with sequential processes; consider hierarchical orchestration later.
• Design reusable components: local expert agents and tools should be reusable across teams/crews.

Deployment / running

• Example run:
  • Run python main.py.
  • The CLI prompts for origin/destination/dates/interests.
  • A typical run takes a few minutes and produces a 7-day itinerary with flights, daily schedule, recommended restaurants/hotels, packing and weather notes, and a cost estimate.

Services and libraries mentioned

• CrewAI (framework)
• LangChain (tool integration and orchestration)
• OpenAI (LLMs — GPT-4 recommended for quality, GPT-3.5 for low-cost testing)
• Serper (search API used in the search tool demo)
• SEC API (example used for filing retrieval)
• Poetry & pipx (environment & dependency management)
• Pydantic (argument schemas / models)
• Code quality tools (type checker, formatter, linter)

Sources / speakers

• Presenter / tutorial author: Brandon (walks through the tutorial and code).
• Creator of the original CrewAI examples and starter templates: Xiao (repo and examples).
• Other referenced services: OpenAI, Serper, SEC API.

If desired: the specific files/boilerplate used in the video (for example agents.py, tools/search_tools.py, task templates, and main.py) can be extracted and provided as a concise starter checklist or a pared-down example that runs with GPT-3.5 to keep costs low.