AI & Agentic Engineering Lessons

The Model Context Protocol (MCP) is an open standard, introduced by Anthropic in November 2024, that lets AI applications connect to external tools and data through one uniform interface. Instead of writing custom integration code for every

beginner · 12 min

An AI voice agent is a system that listens to a user's speech, reasons about it with a large language model, and replies in a natural-sounding voice in real time. You build one by chaining speech-to-text (STT), an LLM, and text-to-speech (T

intermediate · 22 min

Function calling, also called tool use, is a capability that lets a large language model request that your code run a specific function — such as a weather lookup or a database query — and then use the result in its answer. You describe eac

intermediate · 22 min

An intelligent agent is a system that perceives its environment through sensors and acts on it through actuators to achieve goals. In classical artificial intelligence, intelligent agents are grouped into five types by how they decide: simp

intermediate · 22 min

This Model Context Protocol (MCP) tutorial builds a working MCP server that exposes a tool to any MCP client, such as Claude Desktop. Using the official Python SDK's FastMCP helper, you create a server, decorate a function with @mcp.tool()

intermediate · 22 min

An AI agent is a software system that uses a large language model (LLM) as its reasoning engine to pursue a goal over multiple steps — it decides which action to take, calls tools or APIs to act on the world, observes the result, and repeat

beginner · 22 min

An autonomous AI agent is a system that perceives its environment, decides what to do, acts, and loops — pursuing a goal without step-by-step human instruction.

beginner · 25 min

AI Agents and Agentic AI describe related but distinct ideas — one names a specific architectural pattern, the other describes a spectrum of autonomous behavior — and confusing them leads to mismatched tool choices and poorly scoped systems

intermediate · 35 min

An AI coding agent is a language model wired into a reasoning-action loop that lets it plan, write, execute, and iteratively fix code to complete a programming task autonomously.

intermediate · 35 min

Understand observe, decide, act, and update as the spine of tool-using agents.

beginner · 35 min

Know when planning helps agents and when it only adds latency.

advanced · 38 min

Real-world AI agents share a common perceive-reason-act loop but differ sharply in tools, memory, and orchestration patterns depending on their domain.

intermediate · 42 min

Separate thread state, long-term memory, and retrieved knowledge.

intermediate · 42 min

Understand pixel, browser, and DOM action loops plus their safety limits.

advanced · 42 min

Agent memory is the set of mechanisms that let an LLM-based agent persist, retrieve, and act on information beyond a single context window — enabling continuity, personalization, and improving decision-making across interactions.

intermediate · 45 min

LangGraph, CrewAI, AutoGen, LangChain, LlamaIndex, and the OpenAI Agents SDK each solve a different slice of the agentic problem — picking the right one means matching its control model, multi-agent style, and data story to your use case.

intermediate · 45 min

Limit blast radius with permissions, sandboxes, approvals, and traces.

advanced · 52 min

AI marketing agents are autonomous LLM-powered systems that plan, execute, and iterate on marketing tasks — from content creation to campaign optimization — by combining reasoning loops, tools, and multi-agent coordination.

intermediate · 55 min

Build functional AI agents with Claude by wiring the Messages API into an agentic loop, defining tools, and composing multi-step workflows that plan, act, and observe until a goal is complete.

intermediate · 55 min

Use durable execution when agent work must survive retries and crashes.

advanced · 55 min

An AI agent is an LLM wired into a perception-decision-action loop with tools, memory, and error handling — build each layer in order and you have a working agent from first principles.

intermediate · 55 min

Add approvals, review, and correction points to agent workflows.

intermediate · 55 min

Use MCP to expose tools, resources, and prompts through a shared protocol.

intermediate · 55 min

Split work across specialists only when isolation creates real value.

advanced · 55 min

You can build, connect, and deploy functional AI agents using visual no-code platforms — without writing a single line of code — by configuring triggers, actions, and integrations through drag-and-drop interfaces.

intermediate · 55 min

Design narrow, auditable tools that agents can call safely.

intermediate · 55 min

A functional Python AI agent combines an LLM, a tool-calling loop, and state management into an autonomous system that decides what to do next at each step.

intermediate · 75 min

Build a functional AI agent from scratch by wiring together an LLM, tools, a reasoning loop, and memory — then harden it with error handling and deploy it with confidence.

intermediate · 75 min

Add thread state and long-term memory without confusing memory with facts.

intermediate · 55 min

Trace model calls, retrieval, tools, scores, and costs end to end.

intermediate · 55 min

Define functions, execute calls safely, and return tool results to the model.

intermediate · 55 min

Serve an open model with batching, streaming, and production checks.

advanced · 55 min

Run a local model API and connect it to a simple app workflow.

beginner · 55 min

Assemble ingestion, retrieval, prompting, citations, and answer validation.

beginner · 75 min

Wire loaders, retrievers, prompts, and model calls into a grounded Q&A flow.

intermediate · 75 min

Load docs, index chunks, query with sources, and evaluate retrieval.

intermediate · 75 min

Create a stateful tool-using agent with nodes, edges, and checkpoints.

intermediate · 75 min

Turn prompts and expected behavior into repeatable tests.

intermediate · 75 min

LLM evaluation is the practice of measuring how well a large language model or an LLM app performs, so you can compare versions and catch regressions instead of guessing. It combines reference-based metrics (exact match, semantic similarity

intermediate · 22 min

Read public benchmarks without confusing them for product evals.

intermediate · 45 min

Use model graders carefully for open-ended quality assessment.

intermediate · 45 min

Turn quality from opinion into repeatable checks, traces, and datasets.

beginner · 55 min

Create reusable examples from real failures and representative user questions.

intermediate · 55 min

Score multi-step agents by task success, tool safety, cost, and trace quality.

advanced · 55 min

Trace prompts, retrieval, tools, costs, and scores for LLM apps.

intermediate · 55 min

Run prompt and model tests in CI before release.

intermediate · 55 min

Measure context recall, faithfulness, answer relevance, and citation quality.

intermediate · 55 min

Probe prompts, tools, retrieval, and policies before users do.

advanced · 55 min

Use standard telemetry for model calls, tools, retrieval, and evals.

advanced · 55 min

AI works by learning patterns from data instead of following hand-written rules. During training, a model adjusts millions of internal numbers (parameters) until its predictions match known examples; during inference, it applies those learn

beginner · 12 min

AI is usually grouped into three types by capability: Artificial Narrow Intelligence (ANI), which does one task well and is all the AI that exists today; Artificial General Intelligence (AGI), a hypothetical AI matching human ability across

beginner · 12 min

Clustering and dimensionality reduction are the two workhorses of unsupervised learning. Clustering groups unlabeled data points by similarity — k-means and hierarchical clustering are the classics. Dimensionality reduction compresses many

intermediate · 22 min

An embedding is a dense vector of numbers that a model learns to represent something — a word, an image, a user — so that similar things get similar vectors. Instead of hand-coding features or treating categories as arbitrary IDs, a model l

beginner · 22 min

Feature engineering is the work of turning raw data into the inputs a model can learn from — encoding categories, scaling numbers, handling missing values, and creating informative new features. Pipelines package those steps with the model

intermediate · 22 min

Nearly every machine learning model learns the same way: a loss function scores how wrong its predictions are, and gradient descent repeatedly nudges the model's parameters in the direction that reduces that loss. The loss defines the goal,

beginner · 22 min

A neural network is a stack of layers of simple units that each compute a weighted sum of their inputs and pass it through a non-linear activation, letting the network learn complex patterns. Backpropagation is the algorithm that trains it:

beginner · 22 min

Machine learning splits into three main paradigms defined by the feedback a model gets. Supervised learning trains on labeled examples to predict a known answer. Unsupervised learning finds structure in unlabeled data, such as clusters or c

beginner · 22 min

Before neural networks dominated, machine learning ran on a small zoo of classic models — linear and logistic regression, decision trees, random forests, gradient boosting, support vector machines, k-nearest neighbors, and naive Bayes. Each

beginner · 22 min

Learn why clean evaluation starts before model training.

beginner · 40 min

Understand the nested map of AI, machine learning, deep learning, and where agents fit.

beginner · 45 min

Diagnose when a model memorizes, underfits, or generalizes.

intermediate · 45 min

LangGraph is a low-level orchestration framework that models agentic AI applications as a stateful graph of nodes and edges, enabling cycles, branching, persistence, and human-in-the-loop control that a plain agent loop cannot provide.

beginner · 20 min

AutoGen (and its community fork AG2) is a framework where multiple agents solve a task by exchanging messages, and its power is in the conversation patterns you compose. The core patterns are two-agent chat, group chat with a manager that p

advanced · 22 min

AutoGen is Microsoft's open-source framework for building applications where multiple AI agents converse with each other and with tools to solve a task. You create agents — such as an AssistantAgent that reasons and a code-executing agent —

intermediate · 22 min

LangChain is a framework for building LLM applications from composable pieces — models, prompts, tools, retrievers, and memory — wired together into chains or agents. A chain runs a fixed sequence of steps; an agent lets the model choose to

intermediate · 22 min

Claude, Anthropic's family of models, builds agents through tool use: you describe tools with a name, description, and input schema, and Claude replies with structured tool-use requests your code executes and returns. Running this in a loop

intermediate · 22 min

Choosing an AI agent framework comes down to how much control versus abstraction you want, and whether you need a single agent or a coordinated team. Low-level frameworks like LangGraph give explicit control flow; lightweight ones like the

intermediate · 22 min

CrewAI is an open-source Python framework for orchestrating teams of role-playing AI agents that collaborate to complete a task. You define Agents (each with a role, goal, and tools), Tasks (a description plus the expected output), and a Cr

intermediate · 22 min

In CrewAI, the quality of a multi-agent crew depends less on the framework than on how you design each agent's role. An agent is defined by a role, a goal, and a backstory, which together act as a focused system prompt, plus the tools it ca

intermediate · 22 min

Google's Agent Development Kit (ADK) is an open-source framework for building and deploying agents on top of Gemini, Google's model family, though it works with other models too. Its foundation is Gemini function calling: you declare functi

intermediate · 22 min

LangGraph is an open-source framework from the LangChain team for building stateful, multi-step LLM applications as graphs. You define nodes (functions that read and update a shared state), edges (which node runs next), and conditional edge

intermediate · 22 min

Beyond retrieval, LlamaIndex builds agents that reason over your data and Workflows that orchestrate multi-step processes. A LlamaIndex agent wraps a model with tools — often query engines over your indexes — so it can decide what to look u

intermediate · 22 min

LlamaIndex and LangChain are two open-source Python frameworks for building retrieval-augmented generation (RAG). LlamaIndex is a data framework focused on ingesting, indexing, and querying your documents, so retrieval-centric apps come tog

intermediate · 22 min

Semantic Kernel is Microsoft's open-source SDK for embedding large language models into conventional applications, with first-class support for C#/.NET as well as Python and Java. It centers on the kernel, a container that holds plugins — r

intermediate · 22 min

The OpenAI Agents SDK is a lightweight Python framework for building agents with a small set of primitives: an Agent (a model plus instructions and tools), tools it can call, handoffs to pass control to another agent, guardrails to validate

intermediate · 22 min

LangChain is an open-source framework that gives you a common application layer — models, tools, memory, and chains — so you can build LLM-powered apps without rewriting the same plumbing for every provider or use case.

beginner · 28 min

LangChain is the right default for most LLM applications — chains, RAG, and simple agents — while LangGraph is the right choice when your control flow itself is the product: branching, resuming, interrupts, and explicit state transitions.

intermediate · 35 min

Build a working multi-agent CrewAI crew by defining role-based agents, assigning tasks, and wiring them into a sequential or hierarchical workflow that produces a real output.

intermediate · 55 min

LangGraph Studio is a local visual IDE that lets you connect a running LangGraph agent, step through its graph execution node by node, inspect live state, and pinpoint failures without adding print statements.

intermediate · 55 min

Build and deploy AI-powered workflow automation by wiring n8n's agent node to LLMs, tools, and error-handling patterns — turning a visual canvas into a production-ready autonomous pipeline.

intermediate · 55 min

LangChain's document loaders, vector stores, LCEL chains, and LLM integrations give you a composable pipeline to build a production-ready RAG system that answers questions grounded in your own documents.

intermediate · 55 min

AI image generation is more than typing a prompt: real work uses a handful of workflows. Text-to-image creates an image from a description; image-to-image transforms an existing picture; inpainting edits a masked region; and outpainting ext

beginner · 22 min

A diffusion model generates images by learning to reverse a noising process. During training it takes real images, adds random noise in small steps until they are pure static, and learns to predict and remove that noise. To generate, it sta

beginner · 22 min

Multimodal prompting is the craft of combining images (or other media) with text instructions to get the most from a vision-language model. The same principles as text prompting apply — be specific, give examples, ask for a format — plus vi

intermediate · 22 min

Responsible generative media is the practice of creating and deploying AI-generated images, audio, and video in ways that avoid harm. The main risks are deepfakes and misinformation, non-consensual or infringing content, and amplified bias.

intermediate · 22 min

Whisper is an open speech-recognition model from OpenAI that transcribes audio into text and can translate speech into English. It is a transformer trained on a very large, diverse set of audio paired with transcripts, which makes it robust

beginner · 22 min

Stable Diffusion is a latent diffusion model: instead of denoising in pixel space, it runs the diffusion process in a compressed latent space, which is what makes high-resolution image generation fast enough to run on consumer GPUs. Its thr

intermediate · 22 min

Text-to-speech (TTS) turns written text into natural-sounding spoken audio, and modern neural TTS is realistic enough to be hard to distinguish from a human. It typically works by converting text into an acoustic representation and then int

beginner · 22 min

Diffusers is Hugging Face's library for running and building diffusion models like Stable Diffusion in Python. Its central abstraction is the pipeline, which bundles a model's components — the denoising network, the VAE, the text encoder, a

intermediate · 22 min

AI video generation extends image diffusion into time: a model generates a sequence of frames from a text prompt (or a starting image), and the central challenge is temporal consistency — keeping objects, motion, and style coherent across f

intermediate · 22 min

A vision-language model (VLM) is a model that understands images and text together, so you can show it a picture and ask questions in natural language. It works by pairing a vision encoder that turns an image into features with a language m

intermediate · 22 min

Deploying an AI app means putting a model-backed service into production reliably and affordably. The core patterns: separate the model-serving layer from your application logic, keep the app stateless so it scales horizontally, handle slow

intermediate · 22 min

An embedding pipeline turns a large, changing corpus into vectors in a search index, and at scale it becomes an engineering problem, not a one-off script. The core concerns are batching embeddings for throughput, updating incrementally as s

advanced · 22 min

AI runs on specialized hardware because training and inference are mostly massive amounts of matrix multiplication that can be done in parallel. GPUs have thousands of cores built for exactly this, which is why they dominate AI; TPUs are Go

beginner · 22 min

A model gateway is a single service your apps call instead of talking to LLM providers directly. It gives you one unified API across many providers, plus central control: routing, automatic fallbacks, rate limiting, cost tracking, caching,

intermediate · 22 min

A model registry is a central catalog that tracks trained models, their versions, metadata, and lifecycle stage (like staging and production). Versioning treats each model as a numbered, immutable artifact with a record of how it was made —

intermediate · 22 min

A model that performed well at launch can silently degrade because the world changes — a problem called drift. Monitoring watches production inputs and outputs to catch this early: data drift (the inputs shift), concept drift (the input-to-

advanced · 22 min

Cost and latency in an LLM app come mostly from tokens and model choice, so the biggest wins are picking the smallest model that does the job, cutting unnecessary tokens, and reusing work with caching. Prompt caching reuses a repeated prefi

intermediate · 22 min

The Hugging Face Transformers library is the standard way to load and run open models in Python, pairing a tokenizer with a model behind a simple API. It is excellent for prototyping and for non-LLM models, but for high-throughput LLM servi

intermediate · 22 min

Ollama is a tool that lets you download and run open-weight large language models on your own computer with a single command. Running locally keeps data private, removes per-token API costs, and works offline, at the price of your own hardw

beginner · 22 min

vLLM is an open-source inference server that makes self-hosted large language models fast and cost-efficient at scale. Its two key techniques are PagedAttention, which manages the attention key-value cache like virtual memory to eliminate w

intermediate · 22 min

A large language model (LLM) works by predicting the next token — a word or word-piece — over and over, given all the text so far. It was trained on vast text to learn these patterns, storing them in billions of parameters. Generating one t

beginner · 12 min

Prompt engineering is the practice of designing the text instructions given to a large language model so it produces accurate, useful, and consistent outputs. A strong prompt usually sets a role, a clear task, relevant context, examples, an

beginner · 12 min

Attention is the mechanism inside a transformer that lets the model weigh how much each token in the input should influence every other token when building meaning. For each token, attention creates a query, key, and value vector, scores th

beginner · 12 min

Generative AI is a class of artificial intelligence that creates new content — text, images, audio, video, or code — by learning patterns from large amounts of training data and then producing original outputs that resemble it. Models like

beginner · 12 min

LoRA (Low-Rank Adaptation) is a parameter-efficient fine-tuning method that adapts a large language model by freezing its original weights and training small low-rank matrices injected into its layers. Because it updates only about 0.1 to 1

intermediate · 22 min

Function calling lets a large language model request that your code run a defined function and then use the result, turning a text generator into something that can fetch data and act. Beyond the basic round trip, real systems rely on patte

intermediate · 22 min

A large language model works by turning text into tokens, converting those tokens into vectors, passing them through many transformer layers that use attention to build context, and predicting the probability of the next token — then sampli

beginner · 22 min

Pretraining is the phase where a large language model learns language and knowledge by predicting the next token across a massive text corpus, producing the base model that later fine-tuning refines. Scaling laws are the empirical finding t

intermediate · 22 min

Prompt engineering rests on a few durable principles rather than clever tricks: be specific about the task, show the model examples, tell it the exact output format, and give it room to reason before answering. Because a large language mode

beginner · 22 min

Prompt engineering is the discipline of designing the instructions, context, and examples given to a large language model to get reliable, high-quality outputs. This course covers the core skills in order: the anatomy of a prompt, zero-shot

intermediate · 22 min

Serving a large language model is dominated by inference cost, and three techniques cut it. Quantization stores weights in lower precision (16-bit to 8- or 4-bit), shrinking memory and speeding compute with minor accuracy loss. Distillation

advanced · 22 min

Preference tuning aligns a language model with human preferences — helpfulness, harmlessness, and following instructions — after pretraining and supervised fine-tuning. RLHF (Reinforcement Learning from Human Feedback) trains a reward model

advanced · 22 min

Structured outputs make a large language model return data in a machine-readable format — usually JSON that conforms to a schema you supply — instead of free prose. Modern providers offer a structured-output mode that constrains the model's

intermediate · 22 min

A large language model does not read characters or words — it reads tokens, chunks of text (roughly four characters or three-quarters of a word in English) produced by a tokenizer. The context window is the maximum number of tokens the mode

beginner · 22 min

Chunking is the step in a retrieval-augmented generation (RAG) pipeline that splits large documents into smaller passages before they are embedded and stored in a vector database. Good chunking keeps each passage semantically self-contained

beginner · 12 min

A vector embedding is a list of numbers that represents the meaning of a piece of data — a word, sentence, image, or document — as a point in space. An embedding model places similar meanings close together, so 'dog' and 'puppy' land near e

beginner · 12 min

Retrieval-Augmented Generation (RAG) is a technique that makes a large language model answer from your own documents instead of only its training data. Before answering, the system retrieves the most relevant text — usually by embedding sim

beginner · 12 min

A retrieval-augmented generation (RAG) chatbot answers questions from your own documents by retrieving relevant passages and feeding them to a large language model. You build one in Python in five steps: load documents, split them into chun

intermediate · 22 min

LlamaIndex is a data framework built for retrieval-augmented generation, giving you first-class pieces for the whole pipeline: loaders that ingest documents, an index that chunks and embeds them, a retriever that fetches relevant nodes, and

intermediate · 22 min

Chunking splits documents into passages before they are embedded for retrieval-augmented generation, and the strategy you choose is one of the highest-impact decisions in a RAG pipeline. Beyond fixed-size and recursive splitting, production

intermediate · 22 min

Embeddings and vector search are the retrieval building block behind most AI search and RAG systems. An embedding model turns each piece of text into a vector that captures its meaning; vector search then finds the stored vectors closest to

beginner · 22 min

Evaluating a retrieval-augmented generation (RAG) system means grading its two halves separately: retrieval and generation. Retrieval is measured by whether the right passages were fetched (context precision and recall). Generation is measu

intermediate · 22 min

Fine-tuning, retrieval-augmented generation (RAG), and prompting are three ways to adapt a large language model to your task. Prompting changes only the instructions you send; RAG injects relevant external data into the prompt at query time

intermediate · 22 min

GraphRAG is a retrieval-augmented generation approach that builds a knowledge graph of entities and their relationships from your documents, then retrieves over that structure instead of, or alongside, plain vector search. Because it can tr

advanced · 22 min

A vector database is a database built to store and search high-dimensional vectors — the numeric embeddings that represent the meaning of text, images, or audio. Instead of matching exact keywords, a vector database finds the items whose em

intermediate · 22 min

Hybrid retrieval combines keyword search and semantic (vector) search so a retrieval-augmented generation system gets both exact-term precision and meaning-based recall. Because the two methods produce scores on different scales, results ar

intermediate · 22 min

pgvector is an open-source extension that adds a vector data type and similarity search to PostgreSQL, letting you store embeddings and run nearest-neighbor queries in the database you already run. For retrieval-augmented generation, it mea

intermediate · 22 min

Reranking is a second retrieval stage that reorders an initial set of candidate passages by true relevance to the query before they go to the model. The first stage (vector or keyword search) is fast but coarse; a reranker — usually a cross

intermediate · 22 min

Semantic search is a search technique that ranks results by meaning rather than exact keyword matches. It converts both the query and every document into embeddings — numeric vectors from a model — and returns the documents whose vectors si

intermediate · 22 min

Vector databases store embeddings and run similarity search for retrieval-augmented generation, and the main options differ less in core search than in how you run and scale them. Pinecone is fully managed; Weaviate, Qdrant, and Milvus are

intermediate · 22 min

Choose Retrieval-Augmented Generation when you need fresh, citable facts from external documents; choose fine-tuning when you need to reshape a model's default style, format, or domain vocabulary.

intermediate · 45 min

Build and deploy a vector search application with Pinecone by mastering index creation, embedding ingestion, similarity querying, metadata filtering, and RAG pipeline integration.

intermediate · 55 min

Qdrant is a purpose-built vector database that stores embeddings as points inside collections and retrieves the nearest neighbors fast — with payload filtering, multiple index types, and a clean API that fits directly into RAG and semantic

intermediate · 55 min

Prompt injection is a security vulnerability in which an attacker hides malicious instructions inside text an AI system reads — a web page, email, or document — tricking the underlying large language model into ignoring its original instruc

beginner · 12 min

A safety release checklist is a gate an AI feature passes before shipping, turning scattered good intentions into a repeatable set of checks. It covers evaluation against a golden set, adversarial red-teaming, guardrails on inputs and outpu

intermediate · 22 min

Bias in AI is systematic unfairness in a model's behavior, usually inherited from skewed training data or historical patterns and expressed as worse outcomes for some groups. Fairness is the goal of not disadvantaging people based on protec

intermediate · 22 min

Defending against prompt injection means containing an attack you cannot fully prevent, since a language model can't reliably separate instructions from the data it reads. The strongest defenses are structural: least privilege on tools and

intermediate · 22 min

The EU AI Act is the European Union's comprehensive law regulating artificial intelligence, the first of its kind. It takes a risk-based approach: it bans a few unacceptable-risk uses, imposes strict obligations on high-risk systems, requir

intermediate · 22 min

Guardrails are programmatic checks placed around a large language model to keep its inputs and outputs within safe, valid bounds. Input guardrails screen what reaches the model — off-topic requests, injection attempts, personal data; output

intermediate · 22 min

A hallucination is when a large language model produces confident, fluent text that is factually wrong or unsupported — inventing a citation, a statistic, or an API that does not exist. It happens because the model predicts likely-sounding

beginner · 22 min

Privacy and data governance for AI is the practice of controlling how personal and sensitive data flows through an AI system — what is collected, sent to models, logged, retained, and trained on. It matters because LLM apps constantly move

intermediate · 22 min

Prompt injection is an attack in which adversarial instructions hidden in the text a large language model processes override the developer's intended instructions. Attacks range from direct jailbreaks a user types to indirect payloads plant

intermediate · 22 min

A tool-using agent can read data, call APIs, and take actions, which makes its security failures consequential: a hijacked agent doesn't just say the wrong thing, it does the wrong thing. Securing one rests on least privilege — minimal tool

advanced · 22 min

The NIST AI Risk Management Framework (AI RMF) is a voluntary, widely adopted framework from the US National Institute of Standards and Technology for managing AI risks across a system's life. It organizes work into four functions — Govern,

advanced · 22 min

The OWASP Top 10 for LLM Applications is a community-maintained list of the most critical security risks specific to apps built on large language models. It names threats that traditional security misses — prompt injection, sensitive inform

intermediate · 22 min