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 72 articles available. | Currently on page 1 of 2.

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

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 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 8 — Next-Generation KV Cache Management

Eighth post of the LLM Primer VI walkthrough. PagedAttention, KV eviction algorithms (H2O, InfiniGen), and prefix caching for multi-turn conversations and multi-agent RAG.

2026-04-30

Chapter 6 — Pruning and Knowledge Distillation

Sixth post of the LLM Primer VI walkthrough. Structured vs unstructured pruning, 2:4 sparsity on Hopper, and the distillation lineage from soft probabilities to Patient Knowledge Distillation and MiniLLM.

2026-04-28

Chapter 5 — Demystifying Quantization

Fifth post of the LLM Primer VI walkthrough. From BF16 to INT4 to Blackwell FP4 — quantization algorithms (AWQ, GPTQ, GGUF, SmoothQuant), NVIDIA ModelOpt, and when quantization is safe versus lossy.

2026-04-27

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 4 — AI Agents and Tool Calling

Fourth post of the LLM Primer V walkthrough. ReAct loops, tool schemas as contracts, and the three memory layers agents actually need in production.

2026-04-17

Chapter 2 — Foundation Models & Prompt Engineering

Second post of the LLM Primer V walkthrough. Model tiering, sampling parameters, defensive prompt patterns, and structured outputs as engineering surfaces — the layer just inside the deterministic wrapper.

2026-04-15

Chapter 14 — Benchmarking, Testing, and Performance

Fifteenth and final post of the LLM Primer IV walkthrough. The MCP-Universe Benchmark on real servers, the two systemic failure modes it exposed, the ten-times throughput gap between session-per-request and shared session pools, and the bridge to Volume V.

2026-04-12

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 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 9 — Managing the Attention Budget

Ninth post of the LLM Primer IV walkthrough. Context rot, the lost-in-the-middle cliff, tool-loadout rot, and the three architectural answers — MCP, RAG, fine-tuning — to the question of where a model's missing knowledge actually belongs.

2026-04-07

Chapter 7 — Advanced Collaborative and Dynamic Patterns

Seventh post of the LLM Primer IV walkthrough. Roundtable consensus, handoff routing, and magentic orchestration — the patterns that emerge when the topology has to be built per request, with the failure modes (non-termination, mis-routing, runaway planning) the simpler patterns avoid.

2026-04-05

Chapter 3 — Server Primitives: Exposing Context and Capabilities

Third post of the LLM Primer IV walkthrough. The three nouns an MCP server can offer — Resources (read state), Prompts (reusable scaffolding), Tools (write actions) — their schemas, their lifecycles, their error models, and the discipline of choosing the right primitive.

2026-04-01

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

LLM Primer IV — Series Introduction & Index

Kicking off the chapter-by-chapter walkthrough of Book IV in the LLM Primer series — Designing AI Cognition with MCP. Why agents need a protocol layer to scale past demoware, who this book is for, and the schedule for the fourteen posts that follow, March 30 through April 12.

2026-03-29

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 10 — Leading Evaluation Frameworks

Tenth post of the LLM Primer III walkthrough. A field guide to the frameworks that turn the Evaluation Triad into something a team can actually run — RAGAS, TruLens, DeepEval on one side, Braintrust, LangSmith, Phoenix, Galileo, Opik on the other, and the Evaluation Gap none of them has yet closed.

2026-03-27

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 3 — Advanced Chunking Frameworks

Third post of the LLM Primer III walkthrough. The chunking spectrum from fixed-size to structure-aware, the overlap myth, the context cliff that destroys retrieval quietly, and the contextual-retrieval and late-chunking techniques that have reshaped the frontier.

2026-03-20

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

LLM Primer III — Series Introduction & Index

Kicking off the chapter-by-chapter walkthrough of Book III in the LLM Primer series — Enhancing Enterprise AI with RAG. Why retrieval-augmented generation looks simple from the outside and is a stack of disciplines underneath, who this book is for, and the schedule for the eleven posts that follow, March 18 through March 28.

2026-03-17

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 12 — Real-World Applications of LLMs

Twelfth post of the LLM Primer II walkthrough. Text generation, summarization, QA, translation, reasoning — and the constrained decoding, agent loops, and multimodal generalization that turn one next-token machine into a dozen kinds of product.

2026-03-14

Chapter 11 — Evaluation, Calibration, and Inference

Eleventh post of the LLM Primer II walkthrough. Perplexity, calibration, the error bars that every benchmark score should carry, and the mathematics of measuring hallucination — the chapter where we ask how anyone can measure a machine that can say anything.

2026-03-13

Chapter 4 — Attention: The Core Mechanism

Fourth post of the LLM Primer II walkthrough. Self-attention derived from intuition, the geometry of queries/keys/values, multi-head structure and normalization, softmax in detail with its temperature knob, and a striking final move: attention seen as a kernel method.

2026-03-06

Chapter 2 — LLMs in Context: Concepts and Background

Second post of the LLM Primer II walkthrough. What an LLM actually is, the three things "pretraining, parameters, scale" really stand for, the unusual nature of language as a data source, and why the transformer rewrote the field in a single year.

2026-03-04

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 12 — Building Your Own LLM System: From Datasets to Production

Chapter 12 of the LLM Primer I series. The final chapter. What it actually takes to build an LLM-powered system end to end — dataset licensing, training pipelines, evaluation frameworks, the integrated application stack, and the case-study patterns that distinguish successful deployments from failed pilots.

2026-03-01

Chapter 11 — Cutting-Edge Research: MoE, Reasoning Models, and the New Scaling Axis

Chapter 11 of the LLM Primer I series. The research frontiers that are now production reality — mixture-of-experts, retrieval-augmented memory, native multimodal tokenization, continual learning, and the inference-time scaling paradigm that produced today's reasoning models. The 2026 edition's biggest content addition.

2026-02-28

Chapter 8 — Using LLMs in Applications: Chatbots, Code, Extraction, and Agents

Chapter 8 of the LLM Primer I series. The application patterns that actually ship in production — chatbots, summarization, code assistants, structured extraction, and the rise of agentic systems where the model drives a tool-use loop. Plus the benchmarks every engineer should recognize by name.

2026-02-25

Chapter 7 — Beyond Next-Token Prediction: Embeddings, Retrieval, and Multimodality

Chapter 7 of the LLM Primer I series. The capabilities that turn a next-token predictor into something much more — embeddings, semantic search, retrieval-augmented generation, and the move into multimodal inputs. How RAG actually keeps an LLM grounded in real documents instead of confabulating.

2026-02-24

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

Chapter 5 — Training Large Models: What Actually Goes Into a Frontier Model

Chapter 5 of the LLM Primer I series. How frontier LLMs are actually trained — the data pipeline, the loss function, the months of GPU time, and why "training" is now an industrial-scale engineering problem more than a research problem. Demystifies what those hundred-million-dollar training runs are paying for.

2026-02-22

Chapter 4 — The Transformer Architecture: Inside the Engine of Modern AI

Chapter 4 of the LLM Primer I series. A tour of the Transformer block — how self-attention, positional encoding, and stacked layers combine to produce the architecture every modern LLM is built on. Includes a clear explanation of why scaling Transformers works, and what it costs.

2026-02-21

Chapter 3 — Neural Networks for Language: From RNNs to Self-Attention

Chapter 3 of the LLM Primer I series. Why feedforward networks couldn't handle language, how RNNs hit a wall, and what attention changed. A clean conceptual progression through the three neural-network shapes that defined modern NLP — without the math anxiety.

2026-02-20

Chapter 2 — Probability, Tokens, and Text: The Game of Next-Word Guessing

Chapter 2 of the LLM Primer I series. How LLMs convert text into tokens, why language modeling is fundamentally a probability problem, and how the old n-gram approach gave way to neural models that can generalize. Includes plain-English explanations of perplexity and why every token boundary matters.

2026-02-19

The LLM Primer Series — A Field Guide to Generative AI, Built One Volume at a Time

The LLM Primer Series — a completed seven-volume field guide to generative AI by Sho Shimoda. From foundations to security. Includes Physical AI as sister volume. All 7 volumes available on Amazon.

2026-02-15

1.1 Getting Comfortable with Mathematical Notation

A clear and accessible guide to understanding the mathematical notation used in Large Language Models. Learn how tokens, sequences, functions, and conditional probability expressions form the foundation of LLM reasoning. This chapter prepares readers for probability, entropy, and information theory in later sections.

2025-09-04

Page 1 of 2