GenAI Agents track

From no-code prototypes to autonomous UI agents

An 18-module specialisation inside the course: foundations, prompt engineering, RAG, agents from scratch, Model Context Protocol, the three orchestration frameworks, agentic design patterns, DSPy, Kùzu graph RAG - and a capstone agent that operates a real browser and terminal.

18 modules · Module 7.5 MCP · Project Manus capstone
How it fits the arc

This track lives alongside the mathematics, systems, and inference spine. It takes the LLM/RAG work of the later phases and turns it into agents that can share tools and state safely. Each framework below is tied back to the tests, failure cases, and tenant concerns used elsewhere in the course.

FoundationsNo-code prototypingCoding essentialsLangChainPromptingRAGAgents from scratchMCPLangGraph / AutoGen / CrewAIAgentic patternsAdvanced frameworksAgentic RAGDSPyKùzuManus capstone
The bridge - not a merge

Do Modules 1–18 + Manus capstone in 16 weeks. You'll be an agent builder who can ship. Then, when you hit the ceiling - when your RAG pipeline breaks at 10k QPS, when your AutoGen crew deadlocks, when your DSPy optimizer converges to garbage - tensor-to-tenant is waiting. Weeks 22, 38, 57, 75, 88, 98, 99, 102. That's where the ceiling becomes a floor.

This is the bridge. Not a merge. A ladder.

The modules

Open any module to see its topics, key concepts, labs, and the bridge - the exact tensor-to-tenant weeks that explain why the framework works under the hood.

Module 1 Exploring the Generative AI Universe
Topics
  • Fundamentals of Generative AI: Models, Parameters, Embeddings
  • The GenAI Universe: Components, Key Players, Ecosystem Overview
  • Introduction to Prompt Engineering Techniques
  • Basics of Retrieval Augmented Generation (RAG) and its applications
  • Introduction to AI Agents and their applications
Learning outcomes
  • Explain the foundational concepts of generative AI models
  • Identify key components in the GenAI ecosystem
  • Apply basic prompt engineering techniques
  • Understand RAG systems and their applications
  • Describe the role and potential of AI agents
Bridge to the arc

Module 1 gives you the *what*. tensor-to-tenant gives you the *why* - the math in Weeks 7–10, the primitives in Weeks 31–33, and the production LLM/RAG work in Weeks 70–81.

Bootcamp concept tensor-to-tenant week What you actually learn
Embeddings & what a model "is" Weeks 7–10 Linear algebra and vector geometry that actually produce embeddings - the math under the vocabulary.
Model parameters & training intuition Weeks 31–33 Engineering micro-projects where you build ML primitives from scratch; parameters stop being magic.
RAG at a high level Week 70 The LLM+RAG phase starts here; you build retrieval pipelines rather than hear a definition.
AI agents overview Weeks 79, 81 The agents weeks where the "agent" label gets an actual implementation.
Module 2 AI Agent Prototyping (No-Code Introduction)
Topics
  • Understanding AI Agents: Workings and Use Cases
  • Features of Agent Development with Code-Free Tools
  • Building Simple to Advanced AI Agents with NoCode platforms
  • Customizing and Deploying AI Agents using NoCode tools
Key Concepts
  • Flowise, Zapier AI and other no-code platforms
  • Agent capabilities without programming
  • Deployment strategies for no-code agents
Bridge to the arc

The no-code drag-and-drop hides the machine. Week 6 shows you the shape, Week 51 shows you the deployment reality, and Week 81 shows you the compiled version.

Bootcamp concept tensor-to-tenant week What you actually learn
What an agent does (no-code view) Week 6 Orientation weeks where you diagnose tooling and the shape of an agent loop before writing code.
Deployment strategies for no-code agents Week 51 Distributed systems: how services actually get deployed and connected.
Agent capabilities without programming Week 81 The agents phase - you now know what those drag-and-drop nodes compile to.
Module 3 Coding Essentials for AI Programming
Topics
  • Core Python skills for AI: Advanced data structures, async programming, error handling
  • Data processing from CSV/JSON files using Python (Pandas, Polars)
  • SQL and Python frameworks for database management
  • Interacting with APIs in Python
  • Prompting LLMs programmatically
  • Building AI applications with web frameworks
  • Introduction to popular tools and frameworks for building AI Agents
Technologies Covered
  • Python 3.10+
  • Pandas, Polars
  • DuckDB, SQLModel
  • Flask/FastAPI
  • CrewAI, AutoGen, LangGraph, LangChain
Bridge to the arc

Coding essentials give you the vocabulary. Weeks 2–4, 47, 52, and 81 show you what the vocabulary actually compiles to.

Bootcamp concept tensor-to-tenant week What you actually learn
Python data structures, async & error handling Weeks 2–4 The tooling phase where you implement the primitives those frameworks wrap.
SQL & database frameworks Week 47 System design: data modeling, schema, and storage engines.
Interacting with APIs Week 52 Distributed patterns: request/response, contracts, and failure handling.
Web frameworks & agent tooling Week 81 The agents phase where those Flask/FastAPI skills become agent tool servers.
Module 4 Introduction to LangChain
Topics
  • Core LangChain components: LLMs, Model I/O, Parsers, and Chains
  • Mastering LangChain Expression Language (LCEL)
  • Creating efficient prompt templates and output parsers
  • Developing conversational applications
  • Implementing advanced LCEL chains
Key Features
  • LLM abstraction layer
  • Prompt templates and output parsing
  • Chains for sequential processing
  • Memory management for conversations
Bridge to the arc

LangChain gives you chains. Weeks 37, 79–80, and 98 give you the composition, state, and production discipline those chains need.

Bootcamp concept tensor-to-tenant week What you actually learn
LCEL & composable chains Week 37 Engineering primitives: composing small, testable units - the same discipline as pipeline composition.
Model I/O & the LLM abstraction Week 79 The LLM/RAG phase: you build the abstraction and understand its cost.
Memory & conversational apps Week 80 RAG and memory systems - state management under the hood.
Chains in production Week 98 Production AI platform: multi-tenant accounting and reliability for LLM pipelines.
Module 5 Prompt Engineering Essentials
Topics
  • Core principles of crafting effective prompts
  • Exploration of popular prompt engineering patterns
  • Hands-on experience with industry-specific use cases
  • The art of conversational prompting
  • Advanced prompting techniques: Chain of Thought, Self Consistency
  • Exploring prompts with external tools
Patterns Covered
  • Persona-based prompting
  • Flipped Interaction
  • N-shot prompting
  • Meta Language Prompting
  • Chain of Thought (CoT)
  • Self Consistency
Bridge to the arc

Prompting is the surface. Weeks 5, 61, 73, and 79 explain why the surface behaves the way it does.

Bootcamp concept tensor-to-tenant week What you actually learn
Prompt patterns & persona Week 5 Hypothesis choice: how you phrase an experiment changes the result.
Chain of Thought Week 73 LLM training/RAG - why reasoning traces work, from the model’s perspective.
Self Consistency Week 61 Experimentation and evaluation: sampling, variance, and aggregation.
Prompting with external tools Week 79 Agents week: tool-calling contracts and the ReAct loop.
Module 6 RAG Systems Essentials
Topics
  • Document loading and processing techniques
  • Document chunking strategies
  • The role of vector databases in RAG systems
  • Tools for connecting to vector databases
  • Differentiating vector databases from other DB types
  • Mastering retrieval strategies
  • Connecting Vector DBs to LLMs
  • Common problems and mitigation strategies
Key Concepts
  • PDF, Word, multimodal document processing
  • Recursive character, token-based, semantic chunking
  • ChromaDB, Weaviate, LanceDB integration
  • Semantic search, hybrid search, multi-query retrieval
  • Hallucination mitigation techniques
Bridge to the arc

RAG modules show you retrieval. Weeks 31–33 and 75–78 show you the index, the pipeline, and the failure modes.

Bootcamp concept tensor-to-tenant week What you actually learn
Vector databases Weeks 31–33 Build embedding/vector primitives from scratch - you stop trusting the index and build one.
Chunking & document processing Week 36 ML micro-projects: tokenization and preprocessing with measurable trade-offs.
Retrieval strategies Weeks 75–78 The RAG weeks: retrieval pipelines, hybrid search, and evaluation at depth.
Hallucination mitigation Weeks 75–78 Grounding, attribution, and evaluation - the why behind CRAG and self-RAG.
Module 7 Building AI Agents from Scratch & Graph-RAG
Topics
  • Structure of an AI agent: Prompts, Tools, and LLMs
  • Building a simple ReAct style AI Agent
  • Building an AI Agent based on the Reflection pattern
  • Extended Study: Graph RAG and Hybrid RAG Workshop
Workshop Components
  • Environment setup using uv package manager
  • Graph Construction with crud.py logic
  • Entity & relationship extraction with LlamaIndex
  • Traditional RAG via vector search
  • Graph RAG with Cypher queries
  • Hybrid RAG with reranking
Bridge to the arc

Building agents from scratch teaches the loop. Weeks 37, 73, 77, 81 and the Forge’s graph theory teach the structure that makes the loop correct.

Bootcamp concept tensor-to-tenant week What you actually learn
ReAct loop from scratch Week 37 Engineering primitives: the loop as a concrete, testable program.
Reflection pattern Week 73 LLM evaluation: self-critique and feedback loops.
Graph RAG with Cypher Week 77 Graph retrieval - and the Algorithmic Forge graph-theory spine underneath.
Entity & relationship extraction Week 81 Agents phase: knowledge structuring for multi-step reasoning.
Module 7.5 Model Context Protocol (MCP)
USB-C for LLMs - because if your agent can't plug into arbitrary tools and data securely, it's just cosplaying autonomy.
Topics
  • Integrate MCP to create interoperable, pluggable AI agents
  • Develop MCP Servers that expose local data or tools to LLMs
  • Develop MCP Clients that talk to MCP servers
  • Build secure bridges between LangGraph/AutoGen agents and external systems
  • Use MCP Inspector to debug and validate real-time tool access
Core Concepts
  • MCP Host, Client, Server architecture
  • Local Resource and Remote Service integration
  • Transport Layer standardization
  • Secure tool/data access for LLMs
Lab exercises
  • Lab 7.5.1: Build a quote-server MCP server
  • Lab 7.5.2: Build a Claude-accessible RAG system via MCP
Bridge to the arc

MCP standardizes the plug. Weeks 47, 76–77, 87, 98, and 102 build the contract, security, and platform layers the plug lives in.

Bootcamp concept tensor-to-tenant week What you actually learn
MCP Host / Client / Server architecture Week 47 Distributed systems: contracts, transports, and service boundaries.
Secure tool/data access Weeks 76–77 RAG/agents: how tools authenticate, scope, and audit.
Transport layer standardization Week 87 Inference/performance: protocol and interface engineering.
MCP in production Weeks 98, 102 Platform: multi-tenant tool access, rate limiting, and observability.
Module 8 Implementing ReAct Agents with LangChain
Topics
  • The ReAct Framework: Core Principles and Loop Mechanics
  • Building a Simple ReAct Style Agent with Tool Use
  • Adding Conversational Memory to the ReAct Agent
  • Extending for Real-World Scenarios with Multi-User Support
Key Components
  • Thought-Action-Observation loop
  • AgentExecutor in LangChain
  • Custom tools with @tool decorator
  • ConversationBufferMemory and variants
  • Session ID management for multi-user support
Bridge to the arc

The ReAct framework wires the loop. Weeks 80–81, 90, 98, and 99 give it sessions, scale, and tenancy.

Bootcamp concept tensor-to-tenant week What you actually learn
Thought-Action-Observation loop Week 80 The RAG/agents phase: the loop as a system you can measure.
Multi-user support & session ID management Week 81 Session state and isolation for concurrent users.
Tool use at scale Week 90 Inference/performance: tool-calling throughput and latency.
ReAct in production Weeks 98, 99 Platform: multi-tenant agents, quotas, accounting.
Module 9 Building Agents with LangGraph
Topics
  • Introduction to LangGraph: Beyond Sequential Chains
  • Key Components of LangGraph
  • Architecting Components for Real-World AI Agents
  • Understanding State Management and Cyclical Execution
Key Features
  • StateGraph for explicit state management
  • Nodes and Edges for control flow
  • Conditional edges for dynamic routing
  • MessageGraph for chat applications
  • Persistence with checkpointers
Bridge to the arc

LangGraph makes state explicit. Weeks 51, 81, 97–98, and 100 teach you state machines, routing, and durable recovery.

Bootcamp concept tensor-to-tenant week What you actually learn
StateGraph & state management Week 51 Distributed systems: explicit state and state transitions.
Conditional edges & routing Week 81 Agents phase: routing logic and control flow in agent systems.
Persistence with checkpointers Week 97 Platform: durable state and failure recovery.
Cyclical execution Weeks 98, 100 Production agent platforms and capstones.
Module 10 Building Agents with AutoGen
Topics
  • Introduction to AutoGen: Multi-Agent Conversation
  • Key Components of AutoGen
  • Architecting Multi-Agent Collaboration
  • Managing Conversation Flow and Task Completion
Core Classes
  • ConversableAgent base class
  • AssistantAgent for LLM-powered agents
  • UserProxyAgent for human/code execution
  • GroupChat and GroupChatManager
Bridge to the arc

AutoGen wires conversations. Weeks 81, 96, 98–99, and 100 give you the coordination and execution discipline.

Bootcamp concept tensor-to-tenant week What you actually learn
Multi-agent conversation Week 81 Agents phase: how agents coordinate and hand off.
GroupChat & GroupChatManager Week 96 Platform: orchestration, scheduling, and conversation routing.
Code execution & UserProxyAgent Weeks 98, 99 Platform: sandboxed execution and human-in-the-loop.
Collaboration at scale Week 100 Capstones: coordination protocols for real workloads.
Module 11 Building Agents with CrewAI
Topics
  • Introduction to CrewAI: Orchestrating Agent Crews
  • Key Components of CrewAI
  • Architecting Role-Based Agent Collaboration
  • Understanding Task Execution and Crew Dynamics
Key Concepts
  • Agent roles, goals, backstories
  • Task decomposition and dependencies
  • Sequential and hierarchical processes
  • Tool delegation and integration
Bridge to the arc

CrewAI organizes roles. Weeks 96–99 give you authorization, orchestration, and delegation at platform scale.

Bootcamp concept tensor-to-tenant week What you actually learn
Role-based crews Week 96 Platform: role/authorization models for agent systems.
Task decomposition & dependencies Week 97 Platform: workflow and DAG orchestration.
Sequential & hierarchical processes Week 98 Platform: process design and failure domains.
Tool delegation & integration Week 99 Platform: scoped tool access and accountability.
Module 12 Agentic AI Design Patterns
Topics
  • The Need for Design Patterns in Agentic AI
  • Core agentic AI design patterns
  • Exploration of Other Relevant Patterns and Best Practices
  • Best Practices in Agentic System Design
Patterns Covered
  • Reflection Pattern
  • Tool Use Pattern
  • Planning Pattern
  • Multi-Agent Pattern
  • Task Delegation Pattern
  • Human-in-the-Loop Pattern
Bridge to the arc

Patterns are the vocabulary of agentic design. Weeks 57, 62, 73–74, 81, 98–99 show you where each pattern is load-bearing.

Bootcamp concept tensor-to-tenant week What you actually learn
Reflection Pattern Week 73 LLM evaluation: self-critique, feedback, and iterative refinement.
Planning Pattern Week 74 LLM/RAG: plan-and-execute architectures.
Human-in-the-Loop Pattern Week 57 System design: human approval flows and reliability.
Multi-Agent & Task Delegation Weeks 81, 98–99 Agents + platform: coordination and task delegation.
Module 13 Advanced LangGraph Agents
Topics
  • Utilizing Built-ins for ReAct Style Agents
  • Building ReAct Agents from Scratch
  • Extending Agents for Multi-User Conversations
  • Building Reflection and Multi-Agent Systems
Advanced Features
  • Stateful agents with checkpointers
  • Prepared statements for performance
  • Reflection loops for self-correction
  • Multi-agent coordination patterns
Bridge to the arc

Advanced LangGraph is where the framework meets systems. Weeks 52, 73, 88, 99–100 give it planning, measurement, and durability.

Bootcamp concept tensor-to-tenant week What you actually learn
Prepared statements for performance Week 52 System design: query planning and prepared execution.
Reflection loops for self-correction Week 73 LLM evaluation: self-correction under measurement.
Stateful agents with checkpointers Week 88 Inference/performance: state persistence cost.
Multi-agent coordination patterns Weeks 99, 100 Platform + capstones.
Module 14 Advanced AutoGen Agents
Topics
  • Exploring Advanced Agentic Designs
  • Building Industry-Relevant Agentic Systems
  • Constructing Code Execution, Refinement, and Testing Systems
  • Prototyping Agents using AutoGen Studio
  • Extending for Multi-User Conversations
Advanced Concepts
  • Hierarchical agent structures
  • Dynamic group chats
  • Function calling at scale
  • Human-in-the-loop patterns
  • AutoGen Studio for rapid prototyping
Bridge to the arc

Advanced AutoGen scales the conversation. Weeks 62, 96–97, 99, 101 give it hierarchy, sandboxing, and studio-grade iteration.

Bootcamp concept tensor-to-tenant week What you actually learn
Hierarchical agent structures Week 62 MLOps: layered orchestration and environments.
Code execution, refinement & testing Week 96 Platform: sandboxing and test harnesses.
Dynamic group chats Week 97 Platform: conversation scheduling.
AutoGen Studio prototyping Weeks 99, 101 Platform/capstones: rapid iteration on real systems.
Module 15 Advanced CrewAI Agents
Topics
  • Building Complex Collaborating Agent Crews
  • Exploring Advanced Agentic Designs
  • Building Industry-Relevant Agentic Systems
  • Learning Frameworks for Multi-Agent Systems
Key Features
  • Advanced composition techniques
  • Hierarchical crews with delegation
  • Iterative refinement loops
  • Conditional task execution
  • Dynamic tool generation
Bridge to the arc

Advanced CrewAI composes crews. Weeks 73, 97–99, 102 give you the branching, refinement, and tooling discipline.

Bootcamp concept tensor-to-tenant week What you actually learn
Hierarchical crews with delegation Week 73 LLM phase: delegation structures for reasoning work.
Conditional task execution Week 97 Platform: workflow branching and state.
Iterative refinement loops Week 98 Platform: feedback-driven execution.
Dynamic tool generation Weeks 99, 102 Platform/capstones: self-describing tool interfaces.
Module 16 Agentic RAG using LangGraph
Topics
  • Research on Agentic RAG Systems
  • Building Corrective RAG Systems
  • Extending to Self-Reflective RAG Systems
  • Implementing Self-Route RAG Logic
Advanced RAG Techniques
  • Corrective RAG (CRAG) with self-correction loops
  • Self-Reflective RAG with confidence scoring
  • Self-Route RAG with adaptive query routing
  • Query reformulation mechanisms
Bridge to the arc

Agentic RAG adds the loop. Weeks 38, 73, 76–78 show you routing, reformulation, and evaluation that make the loop trustworthy.

Bootcamp concept tensor-to-tenant week What you actually learn
Corrective RAG (CRAG) Weeks 76–77 The RAG weeks: correctness loops grounded in evaluation.
Self-Reflective RAG Week 78 RAG: confidence scoring and self-assessment.
Self-Route RAG logic Week 38 Engineering micro-projects: routing logic as a primitive.
Query reformulation Week 73 LLM evaluation: rewrite-and-retrieve trade-offs.
Module 17 Stanford DSPy
Compilers for LLMs - stop fiddling with prompts. Start engineering self-optimizing AI programs.
Topics
  • Design and implement DSPy Signatures
  • Construct DSPy Modules for complex pipelines
  • Utilize DSPy Optimizers to automatically tune prompts
  • Implement DSPy Assertions to enforce constraints
  • Build sophisticated RAG and agentic systems
Core Components
  • Signatures for declarative task specification
  • Modules (Predict, ChainOfThought, Retrieve)
  • Optimizers (BootstrapFewShot, MIPRO, COPRO)
  • Assertions for computational constraints
  • RetrieverModels for optimized RAG
Lab exercises
  • Lab 17.1: Smart Summarizer with DSPy
  • Lab 17.2: DSPy-Powered RAG System
Bridge to the arc

DSPy compiles prompts. Weeks 22, 38, 61, 76–79, and 81 turn prompting from a craft into an optimization problem.

Bootcamp concept tensor-to-tenant week What you actually learn
Signatures & Modules Week 22 Math foundations: declarative composition and types.
Optimizers (BootstrapFewShot, MIPRO, COPRO) Weeks 38, 61 Experimentation: automated search over prompts as a measurable optimization.
Assertions for constraints Weeks 76–78 RAG/agents: enforced constraints and evaluation.
DSPy pipelines & agents Weeks 79, 81 Agents phase: compiled, self-optimizing agent programs.
Module 18 Kùzu Deep Dive
The Embedded Rocket-Ship for Graph RAG
Topics
  • Kùzu Architecture Crash-Course
  • Hands-On: Spin & Query
  • Prepared Statements & Cypher Reuse
  • Kùzu-Wasm (browser + edge)
  • Interop Pipelines: Arrow & External Scans
  • Graph Algorithms (Built-in & Extension)
  • Concurrency & Embedded Server
  • Integration Pattern: "Graph-First RAG"
Key Features
  • Columnar disk store with compression
  • CSR adjacency indices for efficient joins
  • Vectorised + factorised executor
  • Embedded in-process design
  • Cypher support with MATCH, OPTIONAL, aggregations
  • ACID transactions and MVCC
Lab exercises
  • Lab 18.3.1: LangChain CypherQueryTool with prepared statements
  • Lab 18.5.1: Interop with Arrow and external data sources
  • Lab 18.6.1: Influencer-Finder Agent
  • Lab 18.7.1: Concurrency and embedded server
  • Lab 18.8.1: Graph-First RAG integration
Bridge to the arc

Kùzu is a graph rocket. Weeks 52, 75, 98, 100 plus the Forge’s graph spine and Capstone 2 give you the storage, indexing, and algorithm theory under the hood.

Bootcamp concept tensor-to-tenant week What you actually learn
Columnar disk store & compression Week 52 System design: storage engines and indexing.
CSR adjacency indices Week 75 Graph retrieval: how graph joins stay fast.
Cypher & graph-first RAG Week 98 Platform: graph-powered retrieval at scale.
Graph algorithms & concurrency Weeks 100 · Forge · Capstone 2 The Forge graph-theory spine and the tree-forensics capstone.
Summary map

Every module, mapped to its weeks

Module tensor-to-tenant weeks that explain it
Module 1 Weeks 7–10, 31–33, 70, 79, 81
Module 2 Weeks 6, 51, 81
Module 3 Weeks 2–4, 47, 52, 81
Module 4 Weeks 37, 79, 80, 98
Module 5 Weeks 5, 61, 73, 79
Module 6 Weeks 31–33, 36, 75–78
Module 7 Weeks 37, 73, 77, 81 + Algorithmic Forge graph theory
Module 7.5 Weeks 47, 76–77, 87, 98, 102
Module 8 Weeks 80, 81, 90, 98, 99
Module 9 Weeks 51, 81, 97, 98, 100
Module 10 Weeks 81, 96, 98, 99, 100
Module 11 Weeks 96, 97, 98, 99
Module 12 Weeks 57, 62, 73–74, 81, 98, 99
Module 13 Weeks 52, 73, 88, 99, 100
Module 14 Weeks 62, 96, 97, 99, 101
Module 15 Weeks 73, 97, 98, 99, 102
Module 16 Weeks 38, 73, 76–78
Module 17 Weeks 22, 38, 61, 76–79, 81
Module 18 Weeks 52, 75, 98, 100 + Algorithmic Forge, Capstone 2
This is the bridge. Not a merge. A ladder.

The bootcamp gives you a way to build agents. This course continues with the harder parts: throughput, deadlocks, optimization failures, and tenancy. The two tracks cover different levels of the same work: the 108-week curriculum goes further into systems.

Capstone
Capstone Project Manus - Agentic UI Automation

Develop a sophisticated AI agent capable of understanding and autonomously operating both web-based GUIs and CLIs to achieve complex, multi-step user goals.

Key features & capabilities
  • LLM-driven decision-making for action selection and planning
  • Sophisticated message management for internal state
  • Advanced web browser automation with DOM understanding
  • Robust terminal emulation with WebSocket interaction
  • Text editing capabilities for configuration files
  • Server infrastructure with API endpoints
  • Comprehensive logging and telemetry
Technical architecture
  • Central Orchestration Service
  • Modular Tool Interface
  • Browser Interaction Module (Playwright/Selenium)
  • Terminal Interaction Module
  • State Management with LangGraph
  • Prompt Engineering / DSPy Signatures
Potential challenges
  • Robust DOM interpretation without brittle selectors
  • State management across different tools
  • Error recovery in complex workflows
  • Adaptation to UI changes
  • Security considerations for UI automation
Evaluation criteria
  • Correctness and completeness of task execution
  • Robustness and error handling capabilities
  • Code quality and architectural design
  • Integration of course concepts
  • Presentation and documentation quality

Learning focus: Integration of all course concepts including LangChain, LangGraph, AutoGen, CrewAI, DSPy, MCP, and Kùzu.

Possible extensions
  • Multi-user support with session isolation
  • Integration with Model Context Protocol
  • Self-optimization using DSPy
  • Knowledge graph integration with Kùzu
  • Advanced planning and reflection mechanisms
LangGraphDSPyMCPKùzuPlaywright/Selenium