Every term you keep bumping into, explained in plain English — protocols like MCP and UCP, the APIs that glue things together, development practices like FBD, and the model concepts underneath it all.
A standard way to plug tools and data into an AI model.
MCP defines how an AI application exposes tools, files, and data sources to a model through a common client/server interface. Instead of writing a bespoke integration for every model and every tool, you run an MCP server (for a database, a repo, a ticketing system) and any MCP-aware assistant can discover and call it.
Like USB-C for AI: one connector shape, many devices.
A protocol layer for carrying shared context between systems and agents.
UCP-style protocols standardise the *context envelope* passed around: who the user is, what session they are in, which permissions apply, and what prior state matters. Where MCP focuses on connecting tools, a UCP focuses on making context portable so multiple agents or services can act consistently without re-deriving the situation.
A passport that travels with the request: identity, stamps, and permissions all in one place.
A contract that lets one program call another.
An API defines the endpoints, inputs, and outputs a service accepts. AI apps use APIs both ways: they call model APIs (chat completions, embeddings, image generation), and they expose their own APIs so other software can use their features.
A restaurant menu: you order by name, the kitchen handles how it is made.
Letting a model trigger real code with structured arguments.
You describe available functions with a schema; the model replies with a function name plus JSON arguments; your code runs it and feeds the result back. This is how a chat model books a meeting, queries a database, or draws an infographic.
A callback URL an external service posts events to.
Instead of polling for changes, you register an endpoint and the provider pushes events to it. Always verify the signature before trusting the payload.
Organise work around end-user features, not technical layers.
In FBD each unit of work is a small, demonstrable feature that cuts vertically through UI, logic, and data. Teams design an overall feature list, then design-build-ship each feature in short iterations, so progress is measured in working capability rather than in half-finished layers.
Build the house one finished room at a time, not all the plumbing everywhere first.
Designing the instructions that shape model behaviour.
Roles, constraints, examples, and output formats reliably change quality more than model swaps do. Good prompts state the goal, the audience, the format, and the failure behaviour.
Automated tests for AI output quality.
A fixed set of inputs plus scoring (exact match, rubric grading, or model-as-judge) that tells you whether a prompt or model change made things better or worse.
Checks around a model that constrain what it can say or do.
Input filters, output validation against a schema, permission checks before tool calls, and refusal policies. Guardrails live in your code — never rely on the prompt alone.
Software that learns patterns from data instead of following hand-written rules.
Classical programming maps rules to answers. Machine learning maps examples to a model that then produces answers on new inputs.
Layers of simple numeric units that learn to transform inputs into outputs.
Each connection has a weight; training nudges weights so the network's outputs match the examples. Depth lets later layers combine simple features into complex ones.
A relay team where each runner slightly reshapes the baton before passing it on.
A very large network trained to predict the next token of text.
Because next-token prediction over huge corpora requires modelling grammar, facts, and reasoning patterns, LLMs generalise to summarising, coding, translation, and dialogue.
The architecture behind modern LLMs, built on attention.
Attention lets every token look at every other token and weigh which ones matter, so context is captured in parallel rather than word-by-word.
In a meeting, everyone hears everyone and decides who to listen to.
The chunk of text a model actually reads and writes.
Roughly 3–4 characters of English. Pricing, context limits, and speed are all measured in tokens.
How many tokens the model can consider at once.
Everything the model 'knows' in a turn — system prompt, history, retrieved documents, and its own answer — must fit inside this budget.
The learned numbers inside a model.
Parameter count is a rough proxy for capacity, but data quality and training method matter as much as size.
A model that handles more than text — images, audio, or video.
Multimodal models encode different media into a shared representation, so you can ask questions about a picture or generate an image from a sentence.
The technique behind most image generators.
The model learns to reverse a noising process: starting from static, it repeatedly denoises toward an image matching your prompt.
Learning the weights vs using them.
Training is expensive, done once (or occasionally), and updates parameters. Inference is running the finished model on a new input — this is what happens each time you chat.
The initial, large-scale learning phase.
The model learns general language and world structure from broad data before any task-specific adjustment.
Further training a base model on your own examples.
Useful for consistent tone, domain vocabulary, or strict output formats. Usually try prompting and retrieval first — they are cheaper and easier to change.
Reinforcement Learning from Human Feedback.
Humans rank candidate answers; a reward model learns those preferences; the LLM is optimised against it. This is what makes raw models helpful and well-behaved.
Memorising the training set instead of learning the pattern.
Signalled by great training scores and poor results on unseen data. Fixed with more/varied data, regularisation, or earlier stopping.
A list of numbers representing meaning.
Similar ideas land near each other in vector space, which makes semantic search, clustering, and recommendation possible.
Map coordinates for meaning: 'invoice' and 'bill' are neighbours.
Storage optimised for nearest-neighbour search over embeddings.
Given a query embedding, it returns the most semantically similar stored chunks, fast, at scale.
Fetch relevant documents, then answer using them.
Your content is chunked and embedded; at question time the top matches are pasted into the prompt so the model answers from your sources instead of memory. Reduces hallucination and keeps answers current without retraining.
An open-book exam instead of a memory test.
A model that plans, uses tools, and works in a loop toward a goal.
Agents observe, decide on a next action, call a tool, read the result, and repeat until the objective is met or a limit is hit. Reliability comes from narrow scopes, clear tools, and hard stop conditions.
Confident output that is simply wrong.
A consequence of predicting plausible text. Mitigate with retrieval, citations, structured validation, and letting the model say 'I don't know'.
A dial for randomness in generation.
Low values give consistent, predictable answers; higher values give more variety. Use low for extraction and code, higher for brainstorming.
How long an answer takes, and showing it as it arrives.
Streaming sends tokens as they are produced, so users see progress within a second even when the full answer takes longer.
What each call actually costs you.
Priced per input and output token. Shorter prompts, caching, and picking a smaller model for easy tasks are the main levers.
