The Complete Guide to AI and Machine Learning Tools 2026: LLMs, RAG, Agents, and Beyond

A neural network trained on massive text corpora to understand and generate human language. LLMs use the Transformer architecture and are trained to predict the next token in a sequence. Parameters range from billions to trillions. Key examples: GPT-4, Claude, Gemini, Llama. LLMs demonstrate emergent capabilities like reasoning, coding, and translation that were not explicitly trained.

The neural network architecture introduced in the 2017 "Attention Is All You Need" paper by Vaswani et al. Transformers use self-attention mechanisms to process input sequences in parallel (unlike RNNs which process sequentially). The architecture consists of encoder and decoder blocks with multi-head attention, feed-forward layers, and residual connections. Foundation of all modern LLMs.

The basic unit of text that LLMs process. Tokens are not words; they are subword units. "tokenization" becomes ["token", "ization"]. Common tokenizers: BPE (Byte-Pair Encoding), SentencePiece. English averages about 1.3 tokens per word. Pricing is based on token count. Context windows are measured in tokens (e.g., 200K tokens for Claude).

The maximum number of tokens an LLM can process in a single request (input + output combined). Larger context windows allow processing longer documents. GPT-4.1: 1M tokens. Claude: 200K tokens. Gemini 2.5: 1M tokens. Longer context generally increases cost. Models may lose attention on middle sections of very long contexts (the "lost in the middle" problem).

The practice of crafting inputs (prompts) to get desired outputs from LLMs. Techniques include: zero-shot (no examples), few-shot (provide examples), chain-of-thought (step-by-step reasoning), system prompts (set persona/rules), structured output (request JSON/XML), and role-playing. Good prompts are specific, provide context, and include output format requirements.

A prompting technique where the model is asked to show its reasoning step by step before giving a final answer. "Let's think step by step" significantly improves accuracy on math, logic, and reasoning tasks. Variants: zero-shot CoT (just add "think step by step"), few-shot CoT (provide example reasoning chains), and tree-of-thought (explore multiple reasoning paths).

A technique that enhances LLM responses by first retrieving relevant documents from a knowledge base, then including them in the prompt. Pipeline: query -> embed query -> search vector DB -> retrieve top-K documents -> add to prompt -> LLM generates answer with citations. RAG reduces hallucinations, keeps knowledge current, and allows domain-specific answers without fine-tuning.

Training a pre-trained model on domain-specific data to improve performance on particular tasks. Methods: full fine-tuning (update all parameters, expensive), LoRA (Low-Rank Adaptation, update small matrices), QLoRA (quantized LoRA, even cheaper). Fine-tuning teaches the model a specific style, format, or domain knowledge. Requires labeled training data. Services: OpenAI fine-tuning API, Hugging Face, Together AI.

A parameter-efficient fine-tuning method that freezes the pre-trained model weights and adds small trainable rank decomposition matrices. Instead of updating billions of parameters, LoRA trains only millions (0.1-1% of the model). This reduces compute, memory, and storage requirements dramatically. Multiple LoRA adapters can be swapped at inference time for different tasks.

A dense vector representation of text (or images, audio) in a high-dimensional space where semantic similarity corresponds to vector proximity. Text embedding models convert sentences/paragraphs into fixed-size vectors (e.g., 1536 dimensions). Similar texts have similar embeddings. Used for: semantic search, RAG retrieval, clustering, classification, and recommendations. Measured by cosine similarity.

A specialized database optimized for storing and querying high-dimensional vectors (embeddings). Supports approximate nearest neighbor (ANN) search to find similar vectors efficiently. Key players: Pinecone, Weaviate, Qdrant, Chroma, Milvus, pgvector. Essential infrastructure for RAG pipelines, semantic search, and recommendation systems.

When an LLM generates information that is factually incorrect, fabricated, or inconsistent with the input. LLMs can confidently state false facts, cite non-existent papers, or invent plausible-sounding but wrong answers. Mitigation strategies: RAG (ground in real data), chain-of-thought (show reasoning), temperature=0 (reduce randomness), fact-checking, and citations.

A parameter (0.0-2.0) controlling the randomness of LLM output. Temperature 0: deterministic, picks the most likely token every time (best for factual/code tasks). Temperature 0.7-1.0: balanced creativity. Temperature 1.5+: highly creative and unpredictable. Works by scaling the logits before the softmax function. Lower temperature = more focused, higher = more diverse.

A parameter (0.0-1.0) that limits token selection to the smallest set whose cumulative probability exceeds P. Top-P 0.1: only consider tokens in the top 10% probability mass. Top-P 1.0: consider all tokens. Often used with temperature. Top-P provides more dynamic vocabulary than Top-K (which limits to a fixed number of tokens). Recommended: use either temperature OR top-p, not both aggressively.

A special instruction set given to an LLM before the user conversation. System prompts define the AI persona, rules, capabilities, output format, and constraints. They persist across the conversation. Example: "You are a senior Python developer. Answer questions with code examples. Always explain edge cases." Effective system prompts are specific and include both positive and negative instructions.

The ability of an LLM to invoke external functions/APIs as part of its response. The model receives function definitions (name, parameters, description), decides when to call them, generates structured arguments, and the application executes the function and returns results. Enables: web search, database queries, calculations, API calls, and real-world actions.

An autonomous system that uses LLMs to plan, reason, and take actions to accomplish goals. Agents can: break tasks into steps, use tools (web search, code execution, APIs), maintain memory across interactions, and self-correct errors. Frameworks: LangChain Agents, AutoGPT, CrewAI, Anthropic tool use. Key challenge: reliability and error recovery in multi-step tasks.

AI models that can process and generate multiple types of data: text, images, audio, video. GPT-4o, Claude (vision), and Gemini natively handle text + images. Some models also process audio (GPT-4o) and video (Gemini). Multimodal enables: image understanding, document parsing, video analysis, and generating across modalities (text-to-image, text-to-speech).

An architecture where the model consists of multiple "expert" sub-networks, and a gating network routes each input to a subset of experts. This allows very large total parameter counts while keeping compute per token low (only active experts process each token). Mixtral activates 12.9B of 46.7B parameters. GPT-4 and Gemini are believed to use MoE architecture.

A training technique where human preferences guide model optimization. Process: (1) Generate multiple responses. (2) Humans rank responses by quality. (3) Train a reward model on these rankings. (4) Use reinforcement learning (PPO) to optimize the LLM against the reward model. RLHF aligns models with human values and preferences. Used by OpenAI, Anthropic, and Google.

An alignment technique developed by Anthropic where the model is trained to follow a set of principles (a "constitution") rather than relying solely on human feedback. The model critiques its own responses against these principles and revises them. CAI reduces the need for large-scale human labeling while maintaining safety and helpfulness. Used in Claude models.

Reducing model precision from 32-bit or 16-bit floating-point to lower-bit representations (8-bit, 4-bit, or even 2-bit). This dramatically reduces memory usage and increases inference speed with minimal quality loss. Methods: GPTQ, AWQ, GGUF (for llama.cpp). A 70B model at FP16 requires 140GB VRAM; at 4-bit quantization, it requires about 35GB.

The process of running a trained model to generate predictions or outputs. For LLMs, inference means generating text token by token. Inference cost depends on: model size, context length, output length, and hardware. Optimization techniques: quantization, KV-cache, speculative decoding, batching, and distillation. Inference is typically the largest ongoing cost.

The core operation in Transformers that allows each token to attend to (consider the relevance of) every other token in the sequence. Self-attention computes a weighted sum of all token representations, where weights are determined by the compatibility of query and key vectors. Multi-head attention runs multiple attention operations in parallel. Computational cost is O(n^2) with sequence length.

Training a smaller "student" model to mimic the behavior of a larger "teacher" model. The student learns from the teacher soft outputs (probability distributions) rather than just hard labels. This produces compact models that retain much of the teacher performance. Used to create smaller, faster models for deployment. Example: GPT-4 knowledge distilled into GPT-4o mini.

An optimization that caches the computation of a prompt prefix so subsequent requests with the same prefix are faster and cheaper. Anthropic Claude caches prefixes over 1024 tokens, reducing input costs by 90% and latency by 85% for cache hits. OpenAI automatically caches for requests over 1024 tokens. Essential for applications with long system prompts or repeated context.

The ability to constrain LLM output to a specific format (JSON, XML, YAML). OpenAI supports JSON mode and function calling with strict schemas. Anthropic supports tool use with JSON schemas. This ensures parseable outputs for programmatic consumption. Techniques: JSON mode, grammar-based sampling, tool use, and schema-constrained decoding.

Safety mechanisms that prevent AI models from generating harmful, biased, or inappropriate content. Implemented through: input/output classifiers, content filtering, system prompt constraints, Constitutional AI, and human review. Anthropic, OpenAI, and Google all implement multi-layer guardrail systems. Third-party tools: NeMo Guardrails (NVIDIA), Guardrails AI.

The challenge of ensuring AI systems behave in accordance with human values and intentions. Alignment research addresses: instruction following (do what the user wants), harmlessness (avoid causing harm), helpfulness (provide useful answers), and honesty (be truthful about uncertainty). Current approaches: RLHF, Constitutional AI, debate, and interpretability research.

A standardized test used to evaluate and compare AI model performance. Key LLM benchmarks: MMLU (knowledge), HumanEval (coding), GSM8K (math), HellaSwag (commonsense), ARC (science reasoning), GPQA (graduate-level QA), SWE-Bench (real-world software engineering). Benchmarks have limitations: models may be trained on test data, and benchmarks may not reflect real-world performance.

AI systems designed to operate autonomously over extended periods, making decisions, using tools, and accomplishing complex multi-step tasks with minimal human intervention. Agentic AI involves planning, memory, tool use, error recovery, and self-reflection. Examples: AI coding agents (Claude Code, Devin), research agents, and customer service agents. The 2025-2026 focus of major AI labs.

An open protocol developed by Anthropic for connecting AI models to external data sources and tools. MCP provides a standardized way for AI applications to access context from databases, file systems, APIs, and other services. It replaces custom integrations with a universal protocol, similar to how USB standardized peripheral connections.

Artificially generated data used to train or fine-tune AI models. LLMs can generate training data for specialized tasks, augmenting limited real-world datasets. Benefits: privacy (no real user data), scale (unlimited generation), and coverage (edge cases). Risks: model collapse (training on too much AI-generated data), bias amplification, and reduced diversity.

A component that converts raw text into tokens (subword units) that the model can process. Common algorithms: BPE (Byte-Pair Encoding, used by GPT), SentencePiece (used by Llama), and tiktoken (OpenAI fast implementation). Different models use different tokenizers, so token counts vary. Tokenizers handle multilingual text, code, and special characters.

Hardware accelerators used for AI training and inference. GPUs (NVIDIA A100, H100, H200, B200) are the standard for AI workloads. Google TPUs (Tensor Processing Units) are custom ASICs optimized for Transformers. NVIDIA H100 provides 3958 TFLOPS (FP8). AI training requires clusters of thousands of GPUs. Inference can run on smaller hardware, especially with quantization.

A generative model architecture used for image, audio, and video generation. Diffusion models work by gradually adding noise to data during training, then learning to reverse the process during generation. Starting from random noise, the model progressively refines it into a coherent output. Used by Stable Diffusion, DALL-E 3, Midjourney, and Sora.

A model that can process both visual and textual inputs. VLMs understand images, diagrams, charts, screenshots, and documents alongside text. Examples: GPT-4 Vision, Claude (vision), Gemini. Applications: document understanding, visual QA, image captioning, UI analysis, and accessibility. VLMs encode images into tokens that the LLM processes alongside text tokens.

The field of research and practice focused on ensuring AI systems are safe, beneficial, and aligned with human values. Key concerns: misuse (generating harmful content), existential risk (loss of control over superintelligent systems), bias and fairness, privacy, and economic disruption. Organizations: Anthropic, OpenAI Safety, DeepMind Safety, AI Safety Institute (UK/US).

AI models where the trained parameters (weights) are publicly available for download and use, but the training data, code, or full recipe may not be. Distinct from "open source" which implies full reproducibility. Examples: Llama (Meta), Mistral, DeepSeek. Open weights enable: local deployment, fine-tuning, privacy-sensitive applications, and research. License terms vary (some restrict commercial use).

The compressed, abstract representation space where a model encodes input data. In diffusion models, generation occurs in latent space (hence "Latent Diffusion"). In LLMs, the hidden states form a latent space where similar concepts are near each other. Latent space enables: interpolation between concepts, style transfer, and efficient computation.

When fine-tuning a model on new data causes it to lose performance on previously learned tasks. The model "forgets" its general knowledge while specializing on the new domain. Mitigation: LoRA (adds adapters without modifying base weights), elastic weight consolidation, replay buffers, and careful learning rate scheduling.

A technique where a long system prompt or few-shot examples are "baked into" the model through fine-tuning, allowing the same behavior without the prompt overhead. This reduces token costs and latency at inference time. The model learns to behave as if the instructions were present, even without them in the prompt.

An inference optimization where a small, fast "draft" model generates candidate tokens that a larger model verifies in parallel. The large model can check multiple tokens simultaneously, accepting correct predictions and correcting wrong ones. This can double inference speed with no quality loss, since the output distribution matches the large model exactly.

Key-Value cache stores the intermediate attention computations for previously generated tokens, avoiding redundant recalculation during autoregressive generation. Without KV-cache, generating the 1000th token would recompute attention for all 999 previous tokens. KV-cache trades memory for speed. Memory grows linearly with context length, which is why long-context models need significant RAM/VRAM.

The process of systematically measuring AI model performance. Components: benchmark suites (MMLU, HumanEval), human evaluation (preference ratings), automated evaluation (LLM-as-judge), domain-specific metrics (BLEU for translation, pass@k for code), and red-teaming (adversarial testing). Good evals are reproducible, representative, and resistant to gaming.