Build Real AI Applications
with LLMs, RAG
& AI Agents

Transformer architecture intuition — attention mechanism, tokens and tokenization, context windows (why 128k context ≠ infinite memory). The difference between base models, instruction-tuned models, and RLHF-trained models. Temperature, top-p, top-k, frequency penalty, presence penalty — what they actually control and when to change them. Comparing frontier models: GPT-4o, Claude 3.5 Sonnet, Gemini 1.5 Pro, LLaMA 3, Mistral — benchmarks that matter vs benchmarks that don't. Understanding hallucination — why it happens, how to detect it, and architectural approaches to reduce it. Model context protocol and how function calling works internally. API pricing — tokens, costs, optimisation strategies for production.

Why most prompt engineering advice is wrong. Zero-shot, one-shot, few-shot prompting — when each works and when it doesn't. Chain-of-Thought (CoT) prompting — step-by-step reasoning, zero-shot CoT ("think step by step" and why it works). Tree-of-Thoughts (ToT) for complex problem-solving. Self-consistency — generating multiple reasoning paths and majority-voting. Reflection and self-critique prompts. Meta-prompting — prompts that generate better prompts. Role prompting — system vs user vs assistant roles. XML and structured output prompting. Negative prompting. Constitutional AI and safety-aware prompting. Prompt chaining — breaking complex tasks into sequential prompts. Building a systematic prompt evaluation and versioning system. Prompt injection attacks and defences.

OpenAI Python SDK — chat completions (messages array, system/user/assistant roles), streaming responses with event-source, function calling / tool use (defining tools, parsing tool calls, handling tool results, parallel tool calling). Structured outputs with JSON mode and response_format. Vision API — sending images (URL and base64), multimodal prompts, image analysis applications. Batch API for cost-efficient bulk processing. Assistants API — threads, messages, runs, file attachments, code interpreter tool, retrieval tool. Anthropic Claude API — Messages API, extended thinking, vision. Google Gemini API — multimodal, 1M context window use cases. Building a model-agnostic abstraction layer for switching providers. Managing API keys, rate limits, retry logic, exponential backoff.

LangChain Expression Language (LCEL) — the pipe operator (|), runnable interfaces (invoke, stream, batch, astream). Building chains: PromptTemplate → LLM → OutputParser. Chat message types (SystemMessage, HumanMessage, AIMessage). Output parsers — PydanticOutputParser (structured data), CommaSeparatedListOutputParser, JsonOutputParser, custom parsers. Memory types: ConversationBufferMemory (full history), ConversationBufferWindowMemory (last N turns), ConversationSummaryMemory (LLM-compressed), ConversationSummaryBufferMemory. Building a stateful multi-turn chatbot. LangChain callbacks for logging, monitoring, and debugging. LangSmith for tracing and evaluating chains. Sequential chains vs parallel chains. Router chains for dynamic routing based on input.

What embeddings are and why they're the foundation of modern AI applications. Text embedding models: OpenAI text-embedding-3-large, Cohere embed-v3, sentence-transformers (all-MiniLM, BGE, E5). Comparing embedding models — MTEB benchmark. Vector similarity: cosine similarity, dot product, L2 distance — when to use each. Vector databases deep dive: Pinecone (serverless, pods, namespaces, metadata filtering, hybrid search), ChromaDB (local development, in-memory, persistent), Weaviate (graph-based, multi-tenancy), Qdrant (payload filtering, sparse vectors), pgvector (PostgreSQL extension — SQL + vectors). Building a semantic search engine from scratch. Hybrid search — combining dense (vector) and sparse (BM25/keyword) retrieval for better recall. Indexing strategies for large document corpora.

Why RAG: solving hallucination and knowledge cutoff problems without fine-tuning. Naive RAG pipeline: Document loading (PDF, DOCX, HTML, CSV, YouTube transcripts, web pages) → Text splitting (recursive character, semantic chunking, late chunking) → Embedding → Vector store → Retrieval → Augmented prompt → LLM → Response. Advanced RAG techniques: Query rewriting and HyDE (Hypothetical Document Embeddings). Multi-query retrieval — generating multiple sub-queries. Reranking with Cohere Rerank, BGE Reranker, ColBERT. Contextual compression — extracting only relevant parts of retrieved chunks. Parent-child chunking strategy. Sentence-window retrieval. Self-RAG — LLM decides when to retrieve. Corrective RAG (CRAG) — evaluating retrieved documents and falling back to web search. Multi-modal RAG with images and tables. Evaluating RAG: faithfulness, answer relevancy, context recall using RAGAS framework.

LlamaIndex vs LangChain — positioning and when to use each. Core abstractions: Documents, Nodes, Index, Query Engine, Retriever, Response Synthesizer. Index types: VectorStoreIndex (dense retrieval), SummaryIndex (iterative summarisation), KeywordTableIndex (BM25), KnowledgeGraphIndex (entity-relationship extraction). Sub-question query engine — decomposing complex questions. RouterQueryEngine — routing to different indexes based on question type. Multi-document agents. Property Graph Index for structured knowledge. Ingestion pipeline — caching, parallel processing, incremental indexing. Streaming responses. Building a document Q&A system over 100+ PDF files. Structured data extraction with LlamaIndex — extracting entities, relationships, and facts into structured schemas.

What makes something an "agent" vs a chain — the ReAct (Reason + Act) loop. Agent components: LLM (brain), tools (capabilities), memory (state), planning (orchestration). Tool creation — writing custom Python functions, wrapping APIs as tools, defining tool schemas (JSON Schema for OpenAI function calling, Pydantic for LangChain). Built-in tools: web search (Tavily, Serper, DuckDuckGo), code execution (E2B sandbox, Python REPL), file operations, web scraping (Playwright, Beautiful Soup), SQL database, calculator, Wikipedia, ArXiv. ReAct agent implementation from scratch. LangChain AgentExecutor vs LCEL agent — differences and when to use each. Handling agent errors and infinite loops — max_iterations, early stopping. Giving agents long-term memory with vector stores. Building a research assistant agent that searches the web, reads papers, and writes summaries.

Why LangGraph: overcoming the limitations of linear chains and simple agents. Graph-based agent orchestration — nodes (LLM calls, tool calls, decisions), edges (transitions), conditional edges (dynamic routing). StateGraph — defining agent state with TypedDict, persistence across nodes. Compiling and running graphs: .invoke(), .stream() (token and event streaming). Checkpointing with SqliteSaver and PostgresSaver — resumable long-running tasks. Human-in-the-loop: interrupt_before, interrupt_after — pausing for human approval. Time travel — re-running from any checkpoint. Multi-agent coordination: Supervisor architecture (one agent orchestrates others), Hierarchical teams, Swarm architecture. Building a code generation agent with reflection — generates code, runs it, fixes errors, repeats until passing. LangGraph Studio for visual debugging.

CrewAI — role-based multi-agent framework. Defining agents (role, goal, backstory, tools, LLM). Tasks (description, expected_output, agent assignment). Crew orchestration — sequential vs hierarchical process. Delegating tasks between agents. Memory: short-term (task context), long-term (vector store), entity memory (key facts), contextual memory. Custom tools for CrewAI agents. Real project: a content production crew — researcher agent + writer agent + editor agent + SEO agent working together. Microsoft AutoGen — conversational multi-agent. UserProxyAgent (human surrogate, code executor), AssistantAgent (LLM), GroupChat. AutoGen Studio for no-code agent building. Comparing CrewAI vs AutoGen vs LangGraph — when to use each architecture. Monitoring multi-agent systems with AgentOps.

When to fine-tune vs RAG vs few-shot prompting — the decision framework. Fine-tuning OpenAI models: preparing JSONL training data (system/user/assistant conversation format), uploading to OpenAI, creating fine-tuning job, monitoring training metrics (training/validation loss), evaluating the fine-tuned model, cost per token comparison. Preparing high-quality training data — quality over quantity, synthetic data generation with GPT-4o, data cleaning and deduplication. Open-source fine-tuning: QLoRA (Quantized Low-Rank Adaptation) — the most practical approach for consumer hardware. Hugging Face ecosystem: transformers library, datasets, PEFT (Parameter-Efficient Fine-Tuning), TRL (Transformer Reinforcement Learning). Training LLaMA 3 8B and Mistral 7B on custom data with Unsloth (2x faster training). RLHF basics — reward models, PPO, DPO (Direct Preference Optimisation — simpler and often better). Evaluating fine-tuned models: MT-Bench, task-specific evals. Deploying fine-tuned models on Hugging Face Inference Endpoints, Replicate, and Together AI.

Building AI applications with FastAPI — async endpoints, background tasks, WebSocket streaming. Frontend integration: React chatbot UI, streaming with Server-Sent Events, Markdown rendering. Deployment: Docker containerisation, deploying to AWS EC2 / Lambda / ECS, Hugging Face Spaces, Railway, Render. Observability: LangSmith for tracing, Helicone for API monitoring, cost tracking per user. AI Safety and guardrails: Guardrails AI framework — output validation, toxic content detection, PII redaction. LlamaGuard for input/output safety. Prompt injection prevention — input sanitisation, system prompt hardening. Responsible AI: bias detection, fairness evaluation, transparency. Rate limiting and cost controls for multi-user apps. AI app monetisation — credit systems, subscription tiers, metered billing. Capstone: design and build a complete AI-powered application of your choice — customer support bot with RAG, AI research assistant, AI code reviewer, personalised tutor, or business automation agent. Includes full stack: backend API + LLM integration + vector DB + frontend + deployment + monitoring.