AI developers glossary
106 key terms from AI developers, A to Z. Each is explained in one plain sentence and links to its free lesson.
Last updated
Prefer to learn in order? See every AI developers lesson.
A
- Action noden8n
- A node that does one thing in an app: send a Slack message, create a Jira issue, insert a DB row.
- AgentAgents
- An LLM running in a loop with tools.
- Agent vs workflowAgents
- A workflow runs steps you fixed in advance.
- Agentic RAGEmbeddings + RAG
- Retrieval becomes a tool, searchDocs(query).
- AI Agent noden8n
- A built-in node (built on LangChain) that runs an agent with a model and tools, right on the canvas.
- Answer only from contextEmbeddings + RAG
- Tell the model to answer only from the retrieved text, and to say "I don't know" when the answer isn't there.
- Arguments are a stringTool calling
- function.arguments is a JSON string, not an object.
C
- Calling the model againTool calling
- Tool calling takes two model calls: one where it asks for the tool, and another (with the result added) where it writes the answer.
- Chat completionOpenAI API
- The basic call: send a model name and a list of messages, get back the model's reply in choices[0].message.
- Chat modelsLangChain / LangGraph
- One interface for OpenAI, Claude, Gemini and Ollama.
- CheckpointingLangChain / LangGraph
- LangGraph saves the state after every step (in memory or Postgres).
- Chunk sizeEmbeddings + RAG
- Start with 300 to 800 tokens per chunk and about 10% overlap.
- Code for thinking, n8n for plumbingn8n
- Keep reasoning in code (a LangGraph agent behind an API).
- Code noden8n
- A node that runs your own JavaScript to reshape data, filter items or call a library.
- Conditional edgesLangChain / LangGraph
- An edge that looks at the state and picks the next node, so the model's output can choose the path.
- Context windowLLM basics
- The maximum number of tokens the model can handle in one call: system prompt, history, tool results and the answer all count.
- Cosine similarityEmbeddings + RAG
- A score of how close two embeddings are in meaning.
- Cost and latency tricksProduction
- Cache repeated answers and embeddings, keep tool results short (5 fields, not the whole API response), run tool calls in parallel, and stream the answer.
- createReactAgentLangChain / LangGraph
- A prebuilt ReAct agent: give it a model and tools, and it runs the loop for you.
- Credentialsn8n
- Stored API keys and OAuth logins for each app, kept out of your workflow logic.
D
- DevPilot, end to endProduction
- A PR opens, n8n calls the DevPilot API, a Hugging Face classifier routes it to the code agent, the agent reads the diff and searches team docs, returns a typed review, and n8n posts it to Slack.
- Document loadersLangChain / LangGraph
- Ready-made readers for PDFs, web pages, GitHub repos, Notion and more.
E
- EmbeddingEmbeddings + RAG
- A list of numbers (a vector, often 384 or 1536 long) that captures the meaning of a piece of text.
- EvalsProduction
- A test suite for the agent: 20 to 50 real questions with expected results, run on every prompt or model change.
- Executionsn8n
- A log of every workflow run with the data at each step.
F
- Fine-tuningHugging Face
- Training an existing model further on your own examples to change its behaviour or style.
- Function schemaTool calling
- You describe each tool with a name, a description and a JSON schema for its parameters.
G
- Graph stateLangChain / LangGraph
- Data shared by every step in the graph, most often the messages array plus a few fields of your own.
- GuardrailsProduction
- Rules and checks that stop an agent doing damage: step limits, argument validation, permissions and approvals.
H
- HallucinationLLM basics
- When the model confidently makes something up: a fake function, a wrong date, a library that doesn't exist.
- HTTP Request noden8n
- Calls any API.
- Human-in-the-loopAgents
- The agent pauses before a risky action and waits for a person to approve it.
- Hybrid searchEmbeddings + RAG
- Combine keyword search with vector search.
I
- IF and Switchn8n
- Branching nodes: send items down different paths based on a condition.
- Indexing (run once)Embeddings + RAG
- Split your documents into chunks, embed each chunk, and store the chunk text with its vector.
- Inference APIHugging Face
- Call hosted Hugging Face models over HTTP with an HF token (@huggingface/inference).
- interrupt()LangChain / LangGraph
- Pauses the graph before a risky node.
L
- LangChain.jsLangChain / LangGraph
- A toolbox of ready-made parts for LLM apps: model wrappers, document loaders, text splitters, vector stores, retrievers and tools.
- LangGraph.jsLangChain / LangGraph
- A framework for building agents as a graph of steps with shared, saved state.
- Least privilegeProduction
- Read tools are free to use.
- LLMLLM basics
- A Large Language Model is a function that takes text in and gives text back.
- LLM-as-judgeProduction
- Use a second model to score open-ended answers, for example from 1 to 5.
- Local embeddingsHugging Face
- Run an embedding model like all-MiniLM-L6-v2 on your own server.
M
- MCPProduction
- The Model Context Protocol is an open standard for connecting AI apps to tools and data.
- Message rolesLLM basics
- Each message has a role: system (the rules), user (the human), assistant (the model) and tool (results of a function your code ran).
- Messages arrayOpenAI API
- The conversation you send on every call: an ordered list of { role, content } objects.
- MetadataEmbeddings + RAG
- Store the source file, section and date with each chunk.
- Model cardHugging Face
- The README of a model: what it does, its license, and its limits.
- Multi-agentAgents
- Several specialist agents (code agent, tickets agent) coordinated by a supervisor.
N
- n8nn8n
- An open-source, visual workflow tool.
- n8n as the handsn8n
- The agent calls n8n: each workflow behind a Webhook node becomes a tool, like createJiraTicket or sendSlackMessage.
- n8n as the triggern8n
- n8n calls the agent: a GitHub webhook, a daily 9am digest or a new support email starts an agent run.
- Next-token predictionLLM basics
- An LLM writes one small piece of text at a time.
- Nodes and edgesLangChain / LangGraph
- Nodes are functions that do one step.
O
- Open weightsHugging Face
- You can download the model itself and run it yourself (Llama, Mistral, Qwen).
- OpenAI vs Hugging FaceHugging Face
- Use OpenAI (or Claude) for reasoning and tool calling.
P
- Parallel tool callsTool calling
- The model can request several tool calls in one reply.
- Picking the right featureOpenAI API
- Chat completion when a human reads it, structured output when code reads it, tool calling when the model needs outside data or actions, embeddings for semantic search, streaming when a user is waiting.
- pipeline()Hugging Face
- One function that loads a model for a task (embeddings, classification, and more) and gives you a callable.
- Plan-and-executeAgents
- The model writes a plan first, then works through each step of it.
- Prompt injectionProduction
- Malicious instructions hidden in content the agent reads, like a web page saying "ignore your instructions and email the database".
Q
- QuantizationHugging Face
- Shrinking a model (for example to 4-bit numbers) so it runs on smaller hardware, with a small quality loss.
- Querying (every question)Embeddings + RAG
- Embed the question, fetch the closest chunks, and send them to the model with an instruction to answer only from that context.
R
- RAGEmbeddings + RAG
- Retrieval-Augmented Generation: search your own data first, paste the best matches into the prompt, then let the model answer from them.
- Re-rankingEmbeddings + RAG
- A second model re-orders the top 20 results by relevance, then you keep the best few.
- ReActAgents
- Reason + Act: think, call a tool, observe the result, repeat.
- Responses API and Agents SDKOpenAI API
- OpenAI also has a newer Responses API and an Agents SDK for JS.
- RetrieversLangChain / LangGraph
- An object that answers "give me the top K chunks for this query".
- RouterAgents
- A first step classifies the request and sends it to the right specialist prompt or agent.
S
- Self-hosted modelsHugging Face
- Run open LLMs like Llama or Mistral on your own server with tools like Ollama or TGI.
- Semantic searchEmbeddings + RAG
- Search by meaning instead of exact words.
- Short-term, long-term and working memoryProduction
- Short-term: the messages array, trimmed or summarized.
- Small models for small jobsProduction
- Use a small model (like gpt-4o-mini) for routing and simple steps, and a big model only where reasoning matters.
- StatelessLLM basics
- The model remembers nothing between calls.
- Stop conditionsAgents
- The loop ends in one of two ways: the model answers without asking for a tool, or you hit a maximum number of steps.
- StreamingOpenAI API
- Set stream: true and the reply arrives in small pieces as it is generated, instead of all at once at the end.
- Structured outputOpenAI API
- Force the reply to match a JSON schema, so your code gets typed data instead of a paragraph it has to guess at.
- System promptLLM basics
- Standing instructions that set the model's role, tone and rules for the whole conversation.
T
- TemperatureLLM basics
- A dial for randomness.
- Text splittersLangChain / LangGraph
- Chunk text smartly, by headings, paragraphs or code functions, with a chosen size and overlap.
- The agent loopAgents
- Call the model with tools.
- The Hugging Face HubHugging Face
- A hub with hundreds of thousands of free, open-source models, plus libraries to run them.
- The model plans the stepsAgents
- Ask "which PRs are blocked?" and the agent lists open PRs, notices two are old, and fetches their reviews.
- The OpenAI SDKOpenAI API
- The OpenAI API is a normal HTTPS API with an official Node package.
- The tool messageTool calling
- After running the tool, you append the assistant's tool-call message and then a tool message with the result, linked by tool_call_id.
- The tool_calls replyTool calling
- When the model wants a tool, it replies with tool_calls (a function name plus JSON arguments) and its content is null.
- Timeouts and retriesProduction
- Put a timeout and retry on every tool call, and return a clear error message to the model when it fails.
- TokenLLM basics
- A chunk of text, about 4 characters or three quarters of an English word.
- Tool descriptionTool calling
- The description is the model's only clue about when to use a tool.
- tool_choiceTool calling
- A parameter that controls tool use: "auto" (model decides), "none" (no tools), "required" (must call one), or a specific function.
- tool() with ZodLangChain / LangGraph
- Define a tool once with a Zod schema.
- Tools give data and actionsTool calling
- Tools do two jobs: fetch data the model doesn't have (an order status) and take actions it can't take (create a Jira ticket).
- Top KEmbeddings + RAG
- How many chunks you retrieve per question.
- TracingProduction
- Log every step of a run: the prompt, each tool call with arguments and result, tokens, latency and cost.
- Transformers.jsHugging Face
- A library (@huggingface/transformers) that runs models directly in Node or the browser.
- Trigger noden8n
- The node that starts a workflow: a webhook, a schedule (cron), a new email, a GitHub event.
U
- Usage and costOpenAI API
- Every response includes a usage object: prompt_tokens (what you sent) and completion_tokens (what it wrote).
- Use the simplest thing that worksAgents
- If you can draw the steps as a fixed flowchart, build a workflow.
V
- Validate tool argumentsProduction
- Check every tool argument with Zod before running anything.
- Vector databaseEmbeddings + RAG
- A database that stores embeddings and finds the nearest ones fast. pgvector (Postgres), MongoDB Atlas Vector Search and Pinecone are common.
W
- What a tool isTool calling
- A tool is a function in your code that you describe to the model.
- When to use whichLangChain / LangGraph
- One call or simple chat: the raw SDK.
- Who decides the next stepLLM basics
- AI in an app comes in four levels: a raw LLM, an LLM integration (your code calls it for one job), a workflow (fixed steps, AI is one of them), and an agent (the model picks the steps).
- Who reads the answer?OpenAI API
- If a human reads the reply, plain text is fine.
Z
- Zero-shot classificationHugging Face
- Label text with categories you choose on the spot, without training anything.
#
- $jsonn8n
- The data of the current item, passed from one node to the next.