Agentic AI Curriculum Guide¶

This document describes the seed curriculum for mastering Agentic AI Design Patterns, including the structure, learning paths, and how to apply the seed data.

Curriculum Overview¶

The seed data provides a comprehensive curriculum for learning to build AI agents:

Metric	Count
Domain	1 (Agentic AI)
Trails	3 learning paths
Concepts	12 knowledge clusters
Sparks	18 micro-lessons
Beacons	18 discovery tags
Prerequisite Links	20+ relationships

Total Learning Time: ~35 hours across all trails

Domain: Agentic AI¶

The single domain covers everything needed to master AI agent development, from foundational concepts to production deployment.

Learning Paths (Trails)¶

Trail 1: Agentic AI Foundations¶

Difficulty: Beginner | Time: ~8 hours

Build a solid foundation before diving into advanced patterns.

Concept	Sparks	Time
Understanding AI Agents	What is an AI Agent?, Agent Architecture Stack, Agents vs Traditional Software	45 min
LLM Fundamentals for Agents	Tokens and Context Windows, Temperature and Sampling	60 min
Tool Use Basics	Introduction to Function Calling, Designing Effective Tool Schemas	50 min
Agent Memory Systems	Short-term vs Long-term Memory	55 min

Learning Outcomes: - Define what makes a system "agentic" - Understand LLM constraints that affect agent design - Implement basic tool/function calling - Design memory strategies for agents

Trail 2: Agentic Design Patterns¶

Difficulty: Intermediate | Time: ~12 hours

Master the core patterns that power modern AI agents.

Concept	Sparks	Time
Reasoning Patterns	Chain of Thought Prompting, Tree of Thoughts	60 min
The ReAct Pattern	Understanding the ReAct Loop, Implementing ReAct from Scratch	55 min
Planning Patterns	Plan-and-Execute Pattern	50 min
Reflection and Self-Critique	Self-Critique and Reflection	45 min

Learning Outcomes: - Apply Chain of Thought for complex reasoning - Build ReAct agents from scratch - Choose between ReAct, Planning, and Reflection patterns - Implement self-improvement loops

Prerequisites: Complete Trail 1 or equivalent knowledge

Trail 3: Multi-Agent Architectures¶

Difficulty: Advanced | Time: ~15 hours

Scale to multi-agent systems and production deployment.

Concept	Sparks	Time
Multi-Agent Fundamentals	Why Multiple Agents?	50 min
Orchestration Patterns	Supervisor Architecture	60 min
Agent Frameworks Deep Dive	LangGraph Essentials	70 min
Production and Safety	Agent Guardrails	55 min

Learning Outcomes: - Design multi-agent systems - Implement supervisor/orchestrator patterns - Use LangGraph for complex workflows - Secure agents for production

Prerequisites: Complete Trail 2 or equivalent experience

Knowledge Graph¶

The curriculum forms a Directed Acyclic Graph (DAG) of prerequisites:

                    What is an AI Agent?
                           │
              ┌────────────┼────────────┐
              │            │            │
              ▼            ▼            ▼
      Architecture    Agents vs     Tokens &
         Stack        Traditional   Context
              │                         │
              └──────────┬──────────────┘
                         │
                         ▼
              ┌──── Function Calling ────┐
              │          │               │
              │          ▼               │
              │    Tool Schemas          │
              │                          │
              ▼                          ▼
      Chain of Thought              Memory Systems
              │
              ├──────────────────────────┐
              ▼                          ▼
      Understanding ReAct          Tree of Thoughts
              │
              ▼
      Implementing ReAct ────────────────┐
              │                          │
              ├─────────┬────────────────┤
              ▼         ▼                ▼
      Plan-Execute  Reflection    Why Multi-Agent?
                                         │
                                         ▼
                               Supervisor Architecture
                                         │
                          ┌──────────────┴──────────────┐
                          ▼                             ▼
                    LangGraph                     Guardrails

Spark Details¶

Each Spark (micro-lesson) includes:

Field	Description
`title`	Clear, descriptive lesson name
`slug`	URL-friendly identifier
`summary`	1-2 sentence overview (max 300 chars)
`content_md`	Full lesson in Markdown
`estimated_mins`	5-10 minutes (micro-learning format)
`difficulty`	beginner, intermediate, advanced, expert
`ai_metadata`	Generation info and review status

Content Structure¶

Each Spark follows a consistent structure:

Introduction: What and why
Core Concepts: Main content with code examples
Visual Aids: ASCII diagrams, tables
Practical Examples: Real code snippets
Key Takeaway: Single memorable insight

Beacons (Tags)¶

Tags enable cross-cutting discovery:

Technology Tags¶

python, langchain, langgraph, openai, claude

Concept Tags¶

react, chain-of-thought, function-calling
multi-agent, rag, memory, planning, guardrails

Application Tags¶

chatbots, automation, code-generation

Level Tags¶

beginner-friendly, advanced-topic

Applying the Seed Data¶

Method 1: Supabase Migration (Recommended)¶

The seed data is included as a migration file that runs automatically:

# Reset database and apply all migrations including seed
supabase db reset

# Or apply only new migrations
supabase migration up

Method 2: Direct SQL Execution¶

Run the seed file directly against your database:

# Via psql
psql "postgresql://postgres:postgres@127.0.0.1:54322/postgres" \
  -f supabase/migrations/20241229000002_seed_agentic_ai_curriculum.sql

# Via Supabase Studio
# 1. Open http://127.0.0.1:54323
# 2. Go to SQL Editor
# 3. Paste and run the migration file contents

Method 3: API Seeding (For Production)¶

For production environments where you can't run migrations:

// seed-curriculum.ts
import { createClient } from '@supabase/supabase-js';

const supabase = createClient(
  process.env.SUPABASE_URL!,
  process.env.SUPABASE_SECRET_KEY!  // Use service role for seeding
);

// Insert domain
await supabase.from('domains').insert({
  name: 'Agentic AI',
  slug: 'agentic-ai',
  description: 'Master AI agent development...',
  // ... rest of data
});

// Continue with trails, concepts, sparks...

Verifying the Seed Data¶

After seeding, verify the data is correct:

Via API¶

# List domains
curl http://localhost:8000/api/v1/domains

# Get the Agentic AI domain
curl http://localhost:8000/api/v1/domains/agentic-ai

# List trails
curl http://localhost:8000/api/v1/trails

# Get a specific spark
curl http://localhost:8000/api/v1/sparks/what-is-an-ai-agent

# Get prerequisite graph
curl http://localhost:8000/api/v1/graph/sparks/implementing-react-scratch

# Calculate learning path
curl "http://localhost:8000/api/v1/graph/path?target=agent-guardrails"

# Search
curl "http://localhost:8000/api/v1/search?q=react+pattern"

Via Supabase Studio¶

Open http://127.0.0.1:54323
Navigate to Table Editor
Check each table has data:
domains: 1 record
trails: 3 records
concepts: 12 records
sparks: 18 records
beacons: 18 records
spark_links: 20+ records

Extending the Curriculum¶

Adding New Sparks¶

Insert the spark:

INSERT INTO sparks (id, title, slug, summary, content_md, estimated_mins, difficulty, is_published)
VALUES (
  uuid_generate_v4(),
  'Your New Spark Title',
  'your-new-spark-slug',
  'Brief summary...',
  E'# Full content in markdown...',
  7,
  'intermediate',
  true
);

Link to concepts:

INSERT INTO concept_sparks (concept_id, spark_id, order_index)
VALUES ('concept-uuid', 'your-spark-uuid', 3);

Add prerequisites:

INSERT INTO spark_links (source_id, target_id, link_type, weight)
VALUES ('prerequisite-spark-uuid', 'your-spark-uuid', 'prerequisite', 0.8);

Add tags:

INSERT INTO spark_beacons (spark_id, beacon_id)
VALUES ('your-spark-uuid', 'tag-uuid');

Adding New Trails¶

Follow the same pattern: Trail → Concepts → Sparks → Links → Tags

Curriculum Design Principles¶

The seed data follows these principles:

1. Micro-Learning (5-10 minutes)¶

Each Spark teaches exactly one concept, completable in a single session.

2. Progressive Complexity¶

Trail 1: Foundations (beginner)
Trail 2: Patterns (intermediate)
Trail 3: Advanced (expert)

3. Practical Code Examples¶

Every pattern includes working Python code, not just theory.

4. Visual Learning¶

ASCII diagrams, tables, and structured comparisons aid understanding.

5. Clear Prerequisites¶

The DAG ensures learners don't jump ahead unprepared.

6. Multiple Entry Points¶

Follow a Trail for structured learning
Jump to any Spark for quick reference
Browse by Beacon for topic exploration

Future Expansion Ideas¶

The curriculum can grow to include:

Additional Trails¶

RAG Mastery: Advanced retrieval-augmented generation
Agent Evaluation: Testing and benchmarking agents
Enterprise Agents: Security, compliance, scale

Additional Concepts¶

CrewAI and AutoGen frameworks
Prompt injection defense
Long-running agent patterns
Human-in-the-loop workflows

Additional Sparks¶

Each concept can expand to 5-8 sparks for deeper coverage
Add hands-on exercises and projects
Include real-world case studies

Questions?¶

API Documentation: http://localhost:8000/doc
Developer Guide: DEVELOPER_GUIDE.md
Database Setup: DATABASE_SETUP.md