Build AI Agents with Python RAG and MCP training course

Module 1 — Agent Core

• Understand the message format that drives an agent (system, user, assistant, tool messages).

• Build a tool-calling loop from first principles, implementing the ReAct reasoning pattern — schema in, action out, result back, repeat.

• Implement a tool registry with schema validation, routing, and error handling.

• Add safety rails (allowlists, rate limits, redaction), human-in-the-loop checkpoints, and an eval-driven evaluation harness with golden tests.

Module 2 — Working with the LLM

• Call the LLM chat-completion API directly — message roles, parameters, function/tool-calling, and streaming.

• Build a CLI chat loop with conversation history and a FastAPI streaming endpoint with SSE.

• Implement session storage: in-memory first, then file-based.

• Apply context engineering patterns that hold up in production (structured outputs, grounding).

Module 3 — Conversational AI + Multimodal

• Build a conversational AI application that integrates the agent core, LLM calls, and prompt engineering from earlier modules.

• Apply prompt engineering: system prompts, few-shot examples, structured outputs, and grounding.

• Work with multimodal inputs and outputs: vision-language models, speech-to-text, text-to-speech.

• Add guardrails: model selection, token budgeting, content filters, and confidence thresholds.

Module 4 — MCP Servers

• Understand MCP concepts: tool discovery, schemas, and calling conventions — the emerging standard for agent-tool interoperability, alongside protocols like A2A.

• Build a minimal MCP server in Python, then add practical tools.

• Implement real-world tools: data lookups, queries, sensor reads.

• Add per-tool auth scopes and structured logging for observability.

Module 5 — RAG Fundamentals

• Design chunking strategies (size, overlap, structure-aware splits) for long documents.

• Produce embeddings, store them in a vector index, and query effectively.

• Apply retrieval strategies: hybrid search, metadata filters, reranking, and grounded answers with citations.

• Run basic RAG evaluation: recall/precision on retrieval and adversarial queries — the foundation for agentic RAG in later modules.

Module 6 — Multi-Agent Systems

• Decide when multi-agent designs are worth the latency and operational complexity.

• Model roles (router, researcher, coder, critic) and coordination patterns (orchestrator-worker, swarm, debate) — the same underlying concepts powering frameworks like LangGraph, AutoGen, and CrewAI.

• Share context and tools safely across agents and apply conflict resolution / consensus strategies.

Module 7 — Agent Memory + Workflows

• Implement episodic, semantic, and procedural memory, kept separate from long-term profile or notes.

• Apply summarisation to fit context limits; model decay and explicit "do not remember" controls.

• Compare agentic design patterns: ReAct, Reflection, plan-and-execute, and tool routing for multi-step tasks.

Module 8 — Structured Facts

• Use structured outputs (Pydantic models, JSON Schema) to get reliable, typed data from an LLM.

• Build a fact extraction pipeline that decomposes text into individual claims with provenance.

• Construct a knowledge graph from extracted entities and relationships.

• Implement grounded QA that answers questions from the graph and cites source documents.

Module 9 — Adaptive Retrieval

• Build a retrieval router that selects the right source (vector store, knowledge graph, keyword search) based on query type.

• Implement query decomposition — breaking complex questions into focused sub-queries.

• Add a self-critique loop (corrective RAG / CRAG, a form of the Reflection pattern) that evaluates retrieved documents and re-retrieves when quality is low.

• Orchestrate multi-source retrieval — merging results from different backends with relevance scoring.

Module 10 — Production Concerns

• Add distributed tracing and structured logging so every tool call is attributable and debuggable.

• Define metrics and dashboards that surface latency, errors, and dependency health.

• Implement reliability (retries, timeouts, circuit breakers, fallbacks) and cost controls (caching, batching, token budgets, small language models for narrow tasks).

• Outline deployment: containers, running MCP alongside HTTP APIs, and config per environment.

Module 11 — LangChain with Python

• Understand what LangChain provides vs building from scratch: chains, agents, tools, memory, and output parsers.

• Rewrite a hand-rolled agent loop using LangChain components and compare the trade-offs against LangGraph, CrewAI, and AutoGen.

• Connect LangChain to an MCP server and RAG pipeline built in earlier modules.

Module 12 — Capstone Project

• Build a full agentic application: chat UI or CLI, RAG, MCP tools, and a coordinated multi-agent path for complex questions, deployed behind a simple Streamlit or FastAPI interface.

• Write demo scenarios and integration tests that guard against regressions.

• Document extension points for adding tools, data sources, and policies — leave with a working, demonstrable system to show your organisation.