AI AGENTS BOOTCAMP
from Prompts to Agents.

Gain a solid grounding in how reasoning-enabled agents extend traditional LLMs, exploring their building blocks, memory strategies, and design patterns through lectures, discussions, and hands-on labs.

Key Topics:

• Foundations of Agentic AI: from next-token prediction to reasoning models, limits of classic LLMs vs reasoning LLMs, and the core pillars—reasoning, context, autonomy
• Understanding LLMs: context windows, session memory, long-term memory (vector DBs, graphs, summaries), and data sources (pre-training, fine-tuning, in-context learning)
• Retrieval-Augmented Generation (RAG): naïve RAG workflow and challenges, RAG as a context booster, preparing data for RAG pipelines
• Agentic AI Components: cognition (reasoning, planning, self-reflection), knowledge representation, autonomy (actions, tools, monitoring)
• Agentic Design Patterns: planning, tool use, reflection; Agentic RAG, router, loop; sequential, parallel, hierarchical flows
• Architectures for Agents: single-agent vs multi-agent systems, human-in-the-loop strategies, hybrid reasoning and decision graphs
• Advanced Context Techniques: session summaries, hybrid memory, Model Context Protocol (MCP), scalable context management
• Observability, Safety & Governance: guardrails, explainability, monitoring and evaluation, ethical alignment and compliance
• Hands-on exercises on reasoning, memory, RAG workflows, and safe agent design

Learn to build robust, modular LLM-powered applications with LangChain. Explore its core components, retrieval workflows, and chaining logic through lectures, discussions, and hands-on labs.

Key Topics:

• Introduction to LangChain: purpose and scope, building LLM-powered applications, challenges with RAG
• Core Components: LLMs and chat models, prompt templates and example selectors, document loaders and transformers
• Output Parsers: structured data extraction, consistent formatting, error handling
• Retrieval: embedding and vectorization, retrievers and metadata filtering, parent document retrieval
• Vector Stores: storing embeddings, efficient similarity search, optimizing for large datasets
• Chains: sequential prompt logic, pre/post-LLM steps, integrating tools and retrieval into chains
• Tool Use: integrating APIs and external actions, passing results back into workflows, handling errors and retries
• Domain specific language like LCEL: piping components with runnable, parallel branches, modular workflows
• Hands-on exercises on building retrieval chains, parsing structured outputs, and combining LangChain modules into coherent workflows

Learn how to design, optimize, and integrate vector databases with agentic retrieval-augmented generation (RAG) workflows. Explore embeddings, hybrid retrieval, caching, and observability while implementing advanced reasoning-driven search pipelines.

Key Topics:

• Vector Database Fundamentals: embeddings and vector storage; ANN vs kNN search; modern vector DB architecture and data model
• Hybrid Retrieval Design: combining dense and sparse vectors; metadata filters and payload indexes; full-text tokenization for mixed queries
• Advanced Techniques: Maximal Marginal Relevance (MMR) for diversity; Discovery API for broader coverage; HNSW health monitoring and healing
• Agentic RAG Concepts: agents using AI native vector DBs as long-term memory; multi-step retrieval with reasoning loops; context selection and hallucination control
• Memory Tiers & Named Vectors: short-term, episodic, and long-term memory; multi-modal embeddings in one collection; modality-specific retrieval
• Semantic Caching: caching similar queries via vector similarity; TTL and invalidation policies; optimizing cost and latency
• APIs & Operations: search, scroll, recommendation, discovery; index optimization and quantization; deployment (OSS, Docker, Cloud)
• Monitoring & Observability: latency, recall, and throughput metrics; resource usage and drift detection; Web UI for search playground and ops
• Hands-on Exercises: explore AI-native vector database fundamentals, implement hybrid search, apply re-ranking techniques such as MMR, monitor HNSW index health, and build a RAG pipeline with agentic orchestration.

Learn agentic design patterns that improve LLM performance by structuring reasoning, control, and coordination.

This module presents agentic design as a pattern language — describing recurring solutions that make LLM applications more consistent, scalable, and capable across complex tasks.

Key Topics:

• Understand why agentic patterns matter — transforming single-pass prompting into iterative, goal-oriented reasoning loops.
• Explore the Reflection pattern — enable agents to evaluate and refine their own outputs through critique, revision, and feedback cycles.
• Apply the Planning pattern — design stepwise reasoning flows that decompose goals, manage dependencies, and adapt to new information.
• Implement the Tool Use pattern — connect models with external systems to gather data, perform actions, and extend problem-solving capacity.
• Study the Multi-Agent Collaboration pattern — coordinate specialized agents that share roles, exchange insights, and reach collective solutions.
• Compare pattern trade-offs — balancing autonomy with control, flexibility with stability, and creativity with reliability.
• Examine pattern composition — integrate reflection, planning, and tool use into hybrid workflows for more adaptive agents.
• Discuss evaluation dimensions — accuracy, interpretability, cooperation quality, and performance improvement over single-turn baselines.
• Practice hands-on labs implementing each pattern and combining them into complete agent workflows for real-world tasks.

Learn how to design, coordinate, and monitor multiple agents working together on complex problems. This module focuses on orchestration strategies, planning flows, delegation, and shared resources for scalable agentic systems.

Key Topics:

• Learn when to use multi-agent setups versus single agents and weigh the benefits and risks of collaboration.
• Break large tasks into subtasks and delegate them through hierarchical flows to specialized agents.
• Apply Tree of Thoughts (ToT) and DAG-based planning for structured, reliable reasoning and parallel processing.
• Compare router agents with fully autonomous agents, and design routing, selective autonomy, and fallback paths.
• Manage shared resources like vector stores, databases, and APIs accessed by multiple agents.
• Coordinate agents with error-checking steps, discussion loops, and processes for validating each other’s outputs.
• Embed human approval points and checkpoints with human-in-the-loop supervision for complex workflows.
• Explore strategies for fault tolerance and efficient supervision in layered agent teams.
• Practice hands-on labs building multi-agent teams, adding supervisors in LangGraph, and testing robust workflows.

Understand how agents communicate, discover capabilities, and coordinate tasks through standardized protocols. Learn how MCP, A2A, and ACP enable secure, scalable cooperation between intelligent systems, and practice implementing protocol-driven workflows.

Key Topics:

• Multi-Agent Coordination: collaboration challenges with multiple agents; message routing and task management; scaling cooperation without chaos
• Need for Agentic Protocols: discovery and negotiation rules; task and state management; enabling secure cooperation
• Model Context Protocol (MCP): client–server architecture for LLM tools; standardized data and prompt access; tool, resource, and template exposure
• MCP Architecture: hosts, clients, and servers; message exchange and artifacts; connecting apps, IDEs, and assistants
• Agent-to-Agent Protocol (A2A): task-oriented communication flows; capability discovery with Agent Cards; message parts and artifact formats
• Agent Communication Protocol (ACP): open ecosystem for cross-agent exchange; routing, discovery, and dynamic updates; interoperability across frameworks
• MCP vs ACP vs A2A: scope and complexity comparison; message types and architecture; choosing protocols for different workflows
• Hands-on Exercise – MCP Client Using Streamlit: set up environment, install dependencies, and load your OpenAI API key; connect an MCP client to servers and discover available tools; automate workflows by invoking tools, retrieving data, and validating outputs

Learn how the Model Context Protocol (MCP) standardizes and secures LLM access to tools, data, and context. Explore protocol structure, operations, and security—and how MCP plugs into reflection, planning, tool use, and multi-agent workflows across end-to-end agent pipelines.

Key Topics:

• Origins & Motivation: fragmented integrations and brittle bespoke adapters → unified, interoperable interface (“USB-C for AI”).
• Protocol Structure: client–server handshake; resources, tools, prompts; JSON-RPC transport with schemed messages.
• Context Exposure: how MCP surfaces tools, data, and metadata in a consistent schema for discoverability and control.
• Agentic Integration: connect MCP endpoints to reflection, planning, tool-use, and multi-agent coordination patterns.
• Security & Governance: permission and auth, rate limits, audit trails, key rotation; risks from untrusted or malicious servers.
• Deployment Models: local vs remote servers, gateway/proxy layers, strategies for reliability and scale.
• Ecosystem & Adoption: support from major platforms and SDKs, community servers, and partner-hosted connectors.
• Hands-on Labs: set up an MCP client in Streamlit, discover and register tools, automate workflows by retrieving and validating data, and log traces for review.

Learn how to assess the reliability, safety, and effectiveness of LLM-based agents. Explore benchmarking methods, text-quality metrics, and RAG-specific evaluation frameworks to ensure business, ethical, and technical alignment.

Key Topics:

• Need for Evaluation: reliability, accuracy, safety; business and ethical alignment; transparency and user trust
• Challenges in Evaluation: hallucinations, prompt sensitivity, weak context; subjectivity and multiple valid answers; trade-offs between accuracy, fluency, and creativity
• Benchmarking Approaches: MMLU for multitask accuracy; HELM for holistic metrics (accuracy, robustness, fairness); BBH & HotpotQA for reasoning and multi-hop QA
• Text Quality Metrics: BLEU for n-gram precision; ROUGE (ROUGE-N, ROUGE-L) for recall; BERTScore for semantic similarity
• RAG-Specific Evaluation (RAGAs): faithfulness and answer relevance; context precision and recall; joint retrieval + generation scoring
• G-Eval for Open-Ended Outputs: fluency and faithfulness; answer relevance; claim-level scoring
• Additional Benchmarks: GLUE for NLU tasks; TriviaQA for multi-hop QA; RealToxicityPrompts for safety and toxicity; BST for blended dialogue quality
• Other Metrics: perplexity for prediction confidence; METEOR for synonym and stem alignment; MRR and MAP for ranking performance; ROSCOE for reasoning quality (SA, SS, LI, LC)
• Hands-on Exercises: apply RAGAs to evaluate retrieval + generation pipelines, compare BLEU/ROUGE/BERTScore on generated text, and use G-Eval to assess open-ended agent responses

Apply everything you’ve learned by designing and testing a complete multi-agent application. Work through structured phases from idea to production-ready prototype, incorporating version control, automated testing, and monitoring to ensure reliability and continuous improvement.

Project Tracks:

• Conversational Workflow Orchestration
• Knowledge-Enhanced Agent
• Document-Aware Action Agent
• Orchestrated Collaboration (with MCP)

Attendees Will Receive:

• Comprehensive Datasets
• Step-by-Step Implementation Guides
• Ready-to-Use Code Templates

Learners Can Choose to Implement:

• Virtual Assistant
• Content Generation (Marketing Co-pilot)
• Conversational Agent (Legal & Compliance Assistant)
• Q&A Bot (IRS Tax Advisor)
• Content Personalizer
• MCP Chatbot – AI agent with calendar, CRM, and API integrations

Outcome:

By the end of this project, you’ll have a fully functional, production-ready multi-agent application that demonstrates your mastery of reasoning, retrieval, tool use, and protocol-driven interoperability.