Introduction to LLM

This page provides an easy-to-understand guide on LLMs (Large Language Models) from basics to applications for AI enthusiasts.

Total of 52 articles available. | Currently on page 1 of 2.

Chapter 12 — Access Control and Identity

Twelfth post of the LLM Primer VII walkthrough. OAuth 2.0 + PKCE, ABAC vs ReBAC (Zanzibar), multi-tenant isolation, and token-bucket rate limits for LLM APIs.

2026-05-21

Chapter 11 — Observability, Logging, and Incident Response

Eleventh post of the LLM Primer VII walkthrough. Structured LLM logging with PII redaction, OpenTelemetry GenAI conventions, and the NIST SP 800-61 IR cycle adapted for probabilistic systems.

2026-05-20

Chapter 10 — Designing Secure LLM Architectures

Tenth post of the LLM Primer VII walkthrough. Isolation boundaries, policy engines (OPA, Cedar), microVM sandboxes, and the "lethal trifecta" of agent + private data + untrusted content.

2026-05-19

Chapter 9 — Model Integrity and Supply Chain Risks

Ninth post of the LLM Primer VII walkthrough. Open-source model dependency risk, Sleeper Agents (Hubinger et al.), safetensors vs pickle, CVE-2024-3568, and the SLSA / Sigstore artifact-signing discipline.

2026-05-18

Chapter 8 — Adversarial Attacks on Models

Eighth post of the LLM Primer VII walkthrough. Adversarial examples in NLP (HotFlip, TextFooler), model extraction (Tramèr et al., Carlini et al.), and the defensive strategies for API-boundary abuse.

2026-05-17

Chapter 5 — Input Validation and Output Filtering

Fifth post of the LLM Primer VII walkthrough. Input sanitization, structured guardrails (NeMo, Llama Guard 3, Lakera, Bedrock), and red teaming with Garak, PyRIT, and promptfoo.

2026-05-14

Chapter 3 — Data Security and Privacy

Third post of the LLM Primer VII walkthrough. Training-data risks, memorization and extraction (Carlini et al., Nasr et al.), and the encryption, isolation, and retention disciplines that keep sensitive prompts contained.

2026-05-12

Chapter 2 — Threat Modeling for LLM Systems

Second post of the LLM Primer VII walkthrough. Adapting STRIDE, PASTA, and attack trees to LLM systems — model, prompt, data, and infrastructure as assets, and MITRE ATLAS as the LLM-specific adversary catalog.

2026-05-11

LLM Primer VII — Series Introduction & Index

Kicking off the chapter-by-chapter walkthrough of Book VII in the LLM Primer series — AI Security. Why in LLM systems code and data are the same string, and the schedule for the seventeen posts that follow, May 10 through May 26. This is the series finale.

2026-05-09

Chapter 16 — Cost-Cutting Strategies in Production

Sixteenth and final post of the LLM Primer VI walkthrough. Intelligent model routing, context compaction, async batch APIs, and semantic caching — plus a look ahead to Volume VII on AI Security.

2026-05-08

Chapter 15 — Serverless APIs vs Dedicated Infrastructure

Fifteenth post of the LLM Primer VI walkthrough. The breakeven math between serverless APIs and dedicated infrastructure, the hidden platform-engineering overhead each side takes on, and microVM sandboxes for agent code execution.

2026-05-07

Chapter 14 — Token Economics and API Pricing

Fourteenth post of the LLM Primer VI walkthrough. The input-vs-output token asymmetry, the hidden cost of conversation history, and the invisible reasoning tokens that quietly rewrite the daily bill.

2026-05-06

Chapter 13 — Autoscaling and Cold-Start Mitigation

Thirteenth post of the LLM Primer VI walkthrough. Why standard HPA fails for LLM serving, KEDA for TTFT-aware scaling, Knative scale-to-zero, and CRIU / CUDA graph caching for sub-5-second cold starts.

2026-05-05

Chapter 12 — Disaggregated Serving and Kubernetes

Twelfth post of the LLM Primer VI walkthrough. Why aggregating prefill and decode wastes compute, and how LeaderWorkerSet, NVIDIA Grove, and KAI Scheduler split them apart on Kubernetes.

2026-05-04

Chapter 10 — The LLM Engine Layer

Tenth post of the LLM Primer VI walkthrough. vLLM as the safe default, TensorRT-LLM for peak NVIDIA-only throughput, SGLang for structured and agentic outputs, and TGI/Ollama for the rest.

2026-05-02

Chapter 9 — Speculative Decoding

Ninth post of the LLM Primer VI walkthrough. The draft-verify paradigm — EAGLE, Medusa, MTP, Lookahead, N-gram — and the verification bottleneck that decides real speedup.

2026-05-01

Chapter 7 — Advanced Batching Strategies

Seventh post of the LLM Primer VI walkthrough. Static vs dynamic vs continuous (in-flight) batching, iteration-level scheduling, and how a batch's slots actually progress on the GPU.

2026-04-29

Chapter 3 — Data Center GPUs for Generative AI

Third post of the LLM Primer VI walkthrough. The NVIDIA lineup (H100, H200, B200, L40S) vs AMD MI300X — and why HBM bandwidth matters more than FLOPs for decoding.

2026-04-25

Chapter 2 — The KV Cache Challenge

Second post of the LLM Primer VI walkthrough. The KV cache formula, the attention-variant trade-offs (MHA vs GQA vs MQA), and the memory-fragmentation problem PagedAttention solves.

2026-04-24

Chapter 1 — The Mechanics of Token Generation

First post of the LLM Primer VI walkthrough. The autoregressive bottleneck, the prefill/decode split, and why a high-end GPU is 99.7% idle while serving a single user.

2026-04-23

LLM Primer VI — Series Introduction & Index

Kicking off the chapter-by-chapter walkthrough of Book VI in the LLM Primer series — Scaling AI Systems. Why inference is the discipline that decides whether an LLM app survives real users, and the schedule for the sixteen posts that follow, April 23 through May 8.

2026-04-22

Chapter 8 — Optimizing Performance, Serving, and Cost

Eighth and final post of the LLM Primer V walkthrough. Semantic caching, dynamic model routing, and what actually happens inside the inference server — plus a look ahead to Volume VI on scaling.

2026-04-21

Chapter 6 — AI Observability and Tracing

Sixth post of the LLM Primer V walkthrough. OpenTelemetry GenAI conventions, span design for LLM apps, cost tracking, and the loop back into the evaluation harness.

2026-04-19

Chapter 5 — Evaluating LLM Applications

Fifth post of the LLM Primer V walkthrough. The offline-online eval distinction, LLM-as-judge patterns, the RAG Triad, and trajectory tests for agents.

2026-04-18

LLM Primer V — Series Introduction & Index

Kicking off the chapter-by-chapter walkthrough of Book V in the LLM Primer series — Building Real-World LLM Applications. Why AI engineering is a discipline of its own, who this book is for, and the schedule for the eight posts that follow, April 14 through April 21.

2026-04-13

Chapter 13 — Frameworks and Cloud Integration

Fourteenth post of the LLM Primer IV walkthrough. Strands with Bedrock, the AWS state-layer pattern, the Microsoft Agent Framework, LangChain, Semantic Kernel — and the three production integration shapes teams keep arriving at independently.

2026-04-11

Chapter 12 — Protocol Hardening and Defenses

Thirteenth post of the LLM Primer IV walkthrough. The four defense clusters — cryptographic attestation, OAuth scope discipline with bounded sessions, runtime sandboxing, and human-in-the-loop gates — compose into a posture that does not depend on the model behaving correctly under adversarial conditions.

2026-04-10

Chapter 11 — Attack Surfaces and Protocol Vulnerabilities

Eleventh post of the LLM Primer IV walkthrough. The classical attacks adapted to MCP — Confused Deputy, Token Passthrough, Session Hijacking — the protocol-level flaws around capability escalation and unauthenticated sampling, and the implicit trust propagation that makes context poisoning a structural problem rather than a hygiene one.

2026-04-09

Chapter 10 — Long-Horizon Task Memory

Tenth post of the LLM Primer IV walkthrough. Short-term memory through windows and ReAct scratchpads, long-term memory through episodic vectors and semantic stores, and the compaction techniques that keep an agent productive over hours and days.

2026-04-08

Chapter 4 — Client Primitives: Agentic Behaviors and Control

Fourth post of the LLM Primer IV walkthrough. Sampling, Roots, and Elicitation are the three small, controlled holes MCP punches through the host-server wall — each a capability granted back, each a risk accepted on the user's behalf.

2026-04-02

Chapter 2 — Unveiling the Model Context Protocol (MCP)

Second post of the LLM Primer IV walkthrough. What MCP actually standardizes, the three-role split of Host, Client, and Server, why dynamic discovery and bidirectional messaging differ from REST in the cases that matter, and the session lifecycle that opens with capability negotiation.

2026-03-31

Chapter 1 — The AI Integration Crisis and the Rise of Agentic Architecture

First post of the LLM Primer IV walkthrough. Why monolithic agents fray as system prompts grow, the N times M integration problem hiding underneath, and the move from prompt engineering to context engineering that MCP was built to enable.

2026-03-30

Chapter 11 — Continuous Updates and Pipeline Optimization

Eleventh and final post of the LLM Primer III walkthrough. CDC and incremental indexing keep the corpus fresh, semantic caching and model tiering keep latency down, and a four-stage feedback loop closes the gap between what production tells the team and what the team actually changes — plus a bridge to Volume IV on Model Context Protocol.

2026-03-28

Chapter 8 — Data Anonymization in the RAG Pipeline

Eighth post of the LLM Primer III walkthrough. Pre-generation versus post-generation anonymisation, the three technique families — masking, synthetic replacement, differential privacy — and the utility-privacy tradeoff that determines whether the system remains useful at all.

2026-03-25

Chapter 6 — RAG Threat Models and Vulnerabilities

Sixth post of the LLM Primer III walkthrough. The expanded attack surface of retrieval — corpus poisoning, adversarial chunks, indirect prompt injection, embedding inversion, and the confused-deputy problem in agentic RAG. Concrete attacks, each demonstrated, each reproducible.

2026-03-23

Chapter 4 — Selecting the Right Vector Database

Fourth post of the LLM Primer III walkthrough. The architectural split between purpose-built vector databases and Postgres-style extensions, the managed leaders (Pinecone, Vertex), the open-source field (Qdrant, Milvus, Weaviate), the embedded options, and the three operational axes — residency, ops, cost — that decide the real choice.

2026-03-21

Chapter 1 — The Evolution of RAG Architecture

First post of the LLM Primer III walkthrough. The four architectural postures of RAG — Naive, Advanced, Modular, Agentic — read as a story about handing more agency to the LLM one decision at a time, and the honest answer to when fine-tuning is the better tool than retrieval.

2026-03-18

Chapter 14 — Practical Knowledge for Engineers

Twelfth post — the closing chapter of the LLM Primer II walkthrough. How to keep deepening your understanding after the book ends, the tools and libraries that turn the math into shipping work, and the bridge to the other books in the LLM Primer series.

2026-03-16

Chapter 9 — Training at Scale

Ninth post of the LLM Primer II walkthrough. How data preprocessing quietly shapes everything that follows, the mathematics of mini-batch learning and parallelism, and the surprisingly subtle question of how to keep a training run numerically stable across thousands of GPUs.

2026-03-11

Chapter 8 — How Models Learn

Eighth post of the LLM Primer II walkthrough. Why over-parameterized models generalize at all, the implicit bias of gradient-based optimization, the empirical scaling laws that forecast capability before training, and the open mathematical questions that still surround LLM theory.

2026-03-10

LLM Primer II — Language Models Through Mathematics: Series Introduction & Index

Kicking off the chapter-by-chapter walkthrough of Book II in the LLM Primer series — Language Models Through Mathematics. How the book is organized, what each chapter delivers, and the schedule for the fourteen posts that follow, March 3 through March 16.

2026-03-02

Chapter 9 — Performance, Scaling, and Costs: The Real Engineering Trade-offs

Chapter 9 of the LLM Primer I series. The operational realities of running LLMs at scale — model size vs capability, the latency–throughput trade-off, cost economics, quantization, and edge deployment. Why frontier-tier models are often the wrong choice even when you can afford them.

2026-02-26

Chapter 6 — Fine-Tuning & Adaptation: From Raw Model to Helpful Assistant

Chapter 6 of the LLM Primer I series. The full adaptation stack — from cheap prompt-based steering to parameter-efficient fine-tuning to full alignment with RLHF and its modern successors like DPO. Why post-training is now where closed-model APIs actually differentiate.

2026-02-23

A Chapter-by-Chapter Walkthrough of LLM Primer I — Series Introduction & Index

Introduction and index for the twelve-part chapter-by-chapter walkthrough of LLM Primer I: How Generative AI Works. One post per day, Feb 18 through March 1, 2026. Read them in order or pick the chapter that matters most to you. All twelve are listed and linked here.

2026-02-17

Page 1 of 2