
Already know some of this? A 2-minute test skips the lessons you know.
Take the placement testA free 38-lesson course built from Krish Naik's 7h 49m of YouTube video. 5 days at 90 minutes a day, with study notes and a quiz in every lesson. A 2-minute placement test skips what you already know.
Taught by Krish Naik on YouTube. Videos play in YouTube's own player, so the creator keeps every view.
Understand the four-module structure of the course (Guardrails, Evals, Memory, AgentOps) and why LLM security—guardrails against prompt injection, jailbreak, and off-topic queries—is critical for robust, fault-tolerant, cost-controlled AI agents.
Compare Nemo Guardrails (NVIDIA), Guardrails AI, Meta Llama Firewall, and AWS Bedrock Guardrails; learn why Nemo Guardrails was chosen for the hands-on demo.
See a raw LLM fail against prompt injections, jailbreaks, and off-topic queries, then observe how intent classification and guardrails block or safely redirect each attack while preserving on-topic answers.
Learn the Colang rule language (define user/bot/flow), write input/output/custom rails, implement PII detection with regex, and understand how guardrails sit on both input and output sides of the LLM.
Create a Groq API key and a Pydantic Logfire project/key, paste them into the provided Streamlit app, and verify live tracing of guardrail-filtered LLM calls.
Grasp why evaluations are the confidence layer for production RAG: move from raw demos to automated, metric-driven test suites that expose hallucination, relevance, and retrieval gaps.
Distinguish static benchmarks from custom eval pipelines; learn to build 'goldens' (query + expected answer + expected context + metric focus) authored by domain experts or synthesized via LLM.
Understand the LLM-as-a-judge pattern (separate judge model to avoid provider bias) and survey the five core Ragas metrics: Faithfulness, Answer Relevancy, Context Precision, Context Recall, Answer Correctness.
Learn how Faithfulness decomposes the LLM answer into atomic claims, checks each against retrieved chunks, and scores grounded claims / total claims to catch hallucinations.
See how Answer Relevancy uses the judge LLM to generate questions from the actual answer, compares them semantically to the user query, and averages similarity for a 0–1 score.
Understand Context Precision: the judge LLM rates each retrieved chunk's relevance to the query, penalizing off-topic or noisy chunks to improve retrieval ranking.
Learn Context Recall: extract expected claims from the golden answer, verify each appears in retrieved context, and score coverage to ensure no critical fact is missed.
See how Answer Correctness blends factual claim matching (F1) with semantic embedding similarity, weighted by hyper-parameters W1/W2, to produce a unified correctness score.
Execute the full eval pipeline (parallelized async), inspect per-golden and per-metric dashboards, download JSON traces, and set judge-model API keys (Gemini/Groq) for production use.
Frame the memory challenge: short-term buffers reset on session end; long-term stores (vector, graph) persist. Learn why production agents always use hybrid memory architectures.
See how naive message lists grow token usage exponentially (18% budget in 5 turns), making buffer memory viable only for tiny apps or as a short-term layer in a hybrid stack.
Understand sliding window (keep last K turns, evict older), its constant token cost, and the context-loss trade-off; learn how evicted messages can be hybridized into a vector store.
Learn abstractive (rolling) and progressive (summary-of-summaries) compression; see how lossy compression drops low-frequency/high-importance facts (e.g., allergies) over cycles.
Combine recent verbatim messages with a running LLM-generated summary of older history; tune the transition threshold and token-budget split for medium-scale apps.
Use LangChain's ConversationTokenBufferMemory to enforce a hard token ceiling (system_prompt + min(history, max_buffer)); no compression, predictable cost, zero latency spikes.
Embed conversations into persistent vector DBs (Chroma, FAISS, Pinecone, etc.), retrieve top-K by cosine similarity, and hybridize with short-term buffers for production RAG.
Extract and update structured facts (person, city, preferences) via NER; store as JSON/key-value for instant lookup; ideal for HR, CRM, and profile-building agents.
Store each session as a timestamped episode (summary + decisions + emotional context); enable temporal queries ('what happened in April?') and compliance audit trails.
Build a growing user profile of general reusable facts (traits, preferences) across sessions; stop re-asking known facts and anticipate needs—core for recommendation agents.
Let the agent rewrite its own system prompt (instructions) based on outcomes; enables self-improving agents but risks context poisoning if bad procedures are reinforced.
Run post-session LLM reflection to generate structured improvement notes stored in episodic memory; overlaps with procedural memory but focuses on performance critique.
Classify each incoming message to route it to the right memory store (entity, episodic, semantic, vector, buffer); hybrid retrieval strategies keep token usage bounded.
Apply Ebbinghaus forgetting curve (R(t)=e^(-t/S)) and half-life scores to systematically evict stale facts; explore TTL, LRU, importance-weighted, and budget-constrained pruning.
Walk through the 7-phase AgentOps lifecycle: infra setup (Airflow, Neon Postgres, OpenSearch), data ingestion DAGs, FastAPI + LangGraph agent, LangFuse tracing, Bedrock guardrails, hybrid search, Redis caching, MCP server, EKS deployment, Locust load testing, HPA/VPA scaling.
Provision serverless Neon Postgres (CRUD + vector), OpenSearch for vectors, Airflow for scheduled arXiv/PubMed ingestion DAGs; track ingestion status in Neon.
Instrument the agentic RAG service with LangFuse spans (retrieve, generate, guardrail) for waterfall traces; enable human-in-the-loop feedback via submit-feedback endpoint.
Configure Bedrock guardrails (hate, violence, PII, grounding, relevance thresholds); test off-topic, hate-speech, NSFW, and prompt-injection blocking with live curl calls and LangFuse traces.
Blend semantic dense retrieval (HNSW/IVF) with lexical BM25 for keyword-heavy queries; use reciprocal rank fusion (RRF) to merge result sets for higher recall.
Add Upstash serverless Redis (or local container) to cache repeated queries; observe sub-millisecond cache hits vs. 20-30 s cold starts; swap via .env flag.
Expose every FastAPI route as an MCP tool (list-papers, search, archive, feedback); let any LLM client (Claude, Copilot) discover and call tools dynamically via tool descriptions.
Provision EKS cluster (m5.xlarge nodes, max 16 GB), namespace isolation, IRSA-secured service accounts; use bash scripts for one-shot cluster create/teardown.
Run Locust swarm from 100 to 10,000 concurrent users; watch CPU/memory/Grafana dashboards; identify breaking point (22% failure at 50 parallel) and cost implications.
Configure HPA (min 2, max 6 pods, 70% memory target) and VPA (instance-type upgrade); demonstrate auto-scale under load; summarize bare-minimum production checklist.