AI glossary: LLM, RAG, SLM, agents & essential terms
A practical AI glossary covering LLM, SLM, RAG, CAG, agents, tokens, LoRA, MCP, hallucinations, and the rest of the modern AI vocabulary.
1 Glossary
Each row is one term. Definitions stay short on purpose; follow related articles when you want a full walkthrough.
| Term | Definition |
|---|---|
| Artificial intelligence | Software that performs tasks that usually need human judgment: recognizing patterns, generating language, planning steps, or making recommendations. “AI” is the umbrella; most product talk today means generative models. |
| Machine learning | Teaching computers by showing examples (data) instead of writing every rule by hand. The system improves by adjusting internal numbers called parameters. |
| Deep learning | Machine learning with multi-layer neural networks. Transformers and modern language models are deep learning systems. |
| Neural network | A stack of math layers that transform inputs into outputs. Inspired loosely by brain cells, but it is still ordinary code and linear algebra. |
| Generative AI | AI that creates new content: text, code, images, audio, or video - instead of only classifying or ranking existing items. |
| Foundation model | A large model trained on broad data that can be adapted to many tasks with prompts, retrieval, or light fine-tuning. GPT, Claude, Gemini, and Llama-class models are foundation models. |
| Multimodal model | A model that accepts or produces more than one media type (for example text + images, or speech + text). |
| AGI | Speculative labels: artificial general intelligence (human-level breadth) and artificial superintelligence (beyond human). Useful for product roadmaps less often than for debates; most shipping work is narrow, task-specific AI. |
| AI slop | Low-effort, generic AI-generated content that feels empty or mass-produced. A culture term, not a formal metric - still useful when judging quality. |
| Large language model | A neural network trained to predict the next token in text (and often code). LLMs power chatbots, coding assistants, and many agents. “Large” usually means billions of parameters and a broad training corpus. |
| Small language model | A lighter language model designed for speed, cost, or on-device use. SLMs trade some capability for cheaper inference and easier local deployment. |
| Vision-language model | A model that reasons over images and text together (captioning, screenshot Q&A, UI understanding). |
| Mixture of experts | An architecture where only a subset of “expert” sub-networks activate per token. Total parameter count can be huge while active compute stays lower than a dense model of the same size. |
| Base model | The general model before heavy task specialization. Often used as the starting point for fine-tuning or instruction tuning. |
| Instruction-tuned model | A model further trained to follow natural-language instructions and chat conventions (what most people use in ChatGPT-style products). |
| Frontier model | Informal label for the strongest current closed or open models at the capability edge. |
| Open weights vs closed weights | Open weights can be downloaded and run (with a license); closed weights are only available through an API or app. “Open source” is stricter than “open weights” - check the license. |
| Parameters | The learned numbers inside a model. Parameter count (7B, 70B, etc.) is a rough size signal, not a quality guarantee. |
| Dense model | Opposite of MoE in spirit: most parameters participate in each forward pass. |
| Token | The small chunk a model reads and writes: often a word piece, punctuation mark, or code fragment. Billing and context limits are usually measured in tokens, not characters. |
| Tokenizer | The component that splits text into tokens and maps them to IDs the model understands. |
| Context window | How much token history the model can see at once (prompt + conversation + retrieved docs + output so far). Bigger windows help, but they cost more and do not magically replace good retrieval. |
| Embedding | A numeric vector that represents meaning. Similar ideas land near each other in vector space. Embeddings power semantic search and many RAG pipelines. |
| Transformer | The dominant neural architecture behind modern LLMs, built around attention mechanisms that weigh which parts of the input matter for the next prediction. |
| Attention | The mechanism that lets a token “look at” other tokens when computing its next representation. |
| Inference | Running a trained model to produce an answer. Training builds the model; inference uses it. |
| Latency | How long you wait for a response (time-to-first-token and total completion time both matter in UX). |
| Throughput | How many tokens or requests a system can serve per unit time. |
| Temperature | A sampling knob: higher values make outputs more random; lower values make them more deterministic. |
| Top-p | Other sampling controls that limit which next tokens are eligible, shaping creativity vs focus. |
| KV cache | Cached key/value attention state that speeds up generation of long replies by avoiding full recomputation of past tokens. |
| Speculative decoding | A speed trick where a smaller draft model proposes tokens and a larger model verifies them. |
| Prompt | The input you give the model: instructions, questions, examples, and any attached context. |
| System prompt | High-priority instructions that set role, rules, and style for a session or product. |
| Prompt engineering | Crafting prompts so the model reliably does the job. Still useful; not magic. |
| Context engineering | Broader than prompts: deciding what information enters the context window (docs, tools, memory, schemas) and in what form. |
| Zero-shot | Zero-shot means no examples in the prompt; few-shot means you include a handful of worked examples. |
| In-context learning | The model adapting its behavior from examples or instructions inside the current prompt without changing weights. |
| Chain-of-thought | Asking the model to reason step by step before the final answer. Helps some math/logic tasks; can also increase verbosity and cost. |
| Structured output | Forcing answers into JSON, XML, or a schema so downstream code can parse them safely. |
| Vibe coding | Informal term for building software by chatting with an AI coding agent and iterating on feel/results more than on a formal spec. Fun for prototypes; risky without tests and review. |
| Retrieval-augmented generation | Before the model answers, your system retrieves relevant snippets from an external store (docs, tickets, DB) and adds them to the prompt so generation is grounded in that evidence. Best when knowledge changes often or is private. |
| Cache-augmented generation | A pattern that preloads a known document set into a long context (and often warms the KV cache) instead of retrieving fresh chunks for every query. Useful for stable corpora that fit the window; less ideal when the knowledge base is huge or constantly changing. |
| GraphRAG | Retrieval that uses a knowledge graph (entities and relationships) so answers can follow structured links, not only similar text chunks. |
| Agentic RAG | RAG where an agent decides when/what to retrieve, may run multiple search steps, and refines queries iteratively. |
| Vector database | Storage optimized for similarity search over embeddings (examples people mention: Pinecone, Qdrant, pgvector, Chroma). |
| Chunking | Splitting documents into pieces sized for embedding and retrieval. Chunk strategy often matters more than the logo on the vector DB. |
| Hybrid search | Combining keyword/BM25 search with vector search so exact terms and semantic matches both work. |
| Reranking | A second-pass model that reorders retrieved candidates for higher precision before they enter the prompt. |
| Grounding | Tying answers to retrieved or tool-fetched sources so claims are checkable. |
| Semantic search | Search by meaning via embeddings, not only exact keyword overlap. |
| Pretraining | The expensive phase of learning general language/code patterns from massive corpora. |
| Fine-tuning | Continuing training on a narrower dataset to change behavior, style, or task skill. Updates weights (unlike RAG). |
| Supervised fine-tuning | Fine-tuning on labeled prompt â†' ideal response pairs. |
| RLHF | Aligning a model using human preference signals so answers better match what people rate as helpful or safe. |
| PEFT | Methods that adapt a model by training only a small set of extra weights. |
| LoRA | A popular PEFT method: small trainable matrices attached to layers, cheaper than full fine-tunes. |
| QLoRA | LoRA on a quantized base model to cut memory further during fine-tuning. |
| Quantization | Storing weights in fewer bits (8-bit, 4-bit, GGUF variants) to run models faster or on smaller hardware, with some quality trade-offs. |
| Distillation | Training a smaller “student” model to imitate a larger “teacher,” aiming for similar behavior at lower cost. |
| Synthetic data | Data generated by models (or pipelines) used to train or evaluate other models. Powerful and easy to pollute if quality is not checked. |
| Agent | A system where a model plans and takes actions toward a goal: calling tools, reading results, and looping until done (or until it fails honestly). |
| Agentic | Adjective for workflows with autonomy, tool use, and multi-step decision-making - not a single chat reply. |
| Tool use | Letting the model request structured actions (search, SQL, HTTP, calendar) that your runtime executes and returns. |
| Model Context Protocol | An open protocol for exposing tools, resources, and prompts to compatible agents in a standard way (popular in Cursor/Claude-era tooling). |
| ReAct | A pattern that interleaves reasoning traces with actions (“think, act, observe”) for tool-using agents. |
| Multi-agent system | Several specialized agents collaborating (researcher, coder, reviewer) under an orchestrator. |
| Memory (short-term | Short-term is usually the context window; long-term may be a vector store, database, or notes the agent can recall across sessions. |
| AI agent skills | Reusable instruction playbooks (often SKILL.md files) that teach coding agents a disciplined workflow for a recurring job. |
| Grilling | A pre-build interview where a coding agent stress-tests your plan one question at a time until you share the same understanding. Skills like /grill-me and /grill-with-docs run this flow; the docs variant also writes ADRs and project notes as you decide. |
| Human in the loop | Keeping a person in approval or review steps for risky actions. |
| Hallucination | Fluent output that is wrong, fabricated, or ungrounded. Mitigation: retrieval, citations, constraints, and evaluation - not vibes alone. |
| Evals | Automated or human tests that score model/system quality on real tasks (accuracy, groundedness, tone, safety). |
| LLM-as-a-judge | Using one model to score another model's answers. Convenient; needs calibration because judges have biases too. |
| RAGAS | Evaluation ideas focused on whether answers stick to retrieved context (names vary by library). |
| Prompt injection | Malicious or accidental text that tries to override system instructions (“ignore previous rules…”). A top risk in LLM apps that read untrusted content. |
| Jailbreak | An attempt to bypass safety policies with clever prompting. |
| Guardrails | Filters, validators, allow/deny lists, and policy layers around model I/O. |
| Alignment | Broad goal of making model behavior match human/organization intent and values. |
| Red teaming | Adversarial testing to find failure modes before users do. |
| Bias | Systematic skewed outcomes reflecting data or design choices. Measure on your domain; do not assume “the model is neutral.” |
| LLMOps | Operating LLM features in production: versioning prompts/models, monitoring cost/latency, evals, rollback, and incident response. |
| Model serving | Hosting models behind APIs with batching, scaling, and hardware scheduling. |
| vLLM | Popular serving/runtime stacks. vLLM targets high-throughput GPU serving; llama.cpp and Ollama are common for local/developer setups. |
| GGUF | A common file format for quantized models used with llama.cpp-family tools. |
| CUDA | Accelerators and software layers that make large-model training and inference practical. GPUs dominate indie/local setups; TPUs appear in some cloud stacks. |
| ONNX | Portability targets for running models outside a single Python stack (edge, browsers, mobile). |
| Rate limit | API caps on requests or tokens. Product design must assume they exist. |
| Token economics | The cost/latency trade-offs of prompt size, output length, model tier, and caching. |
| NLP | The older/broader field of language technology; LLMs are currently its loudest chapter. |
| Computer vision | Models for images and video. Often paired with LLMs in multimodal products. |
| Speech-to-text | Turning audio into text and back. Whisper-class models are common STT examples. |
| Diffusion model | A generative approach popular for images (and expanding to other media): iteratively denoising toward a sample. |
| OCR | Optical character recognition: extracting text from images/PDFs before RAG or search. |
| Feature engineering | Classic ML practice of crafting input signals. Still relevant outside pure LLM apps. |
| Supervised | Learning with labels, without labels, or from rewards. Modern LLM stacks mix all three ideas across pretraining and alignment. |