🌱 New here?
This module is a reference: you don’t need to memorize everything at once. Each term comes with a short definition e a concrete example, because definitions stick less without an example. Use the index on the right to jump to the cluster you need—and come back whenever you encounter a new word in the other tracks.
The seven clusters follow the path for someone just getting started: first AI ideas, then how to talk to the assistant (modes), then the files where everything is configured, then how to connect tools (MCP), and finally n8n—from the basics to AI—and the data blocks that power responses.
Illustrative diagram — glossary clusters in learning order. Each box is a topic below, with its terms defined.
🧠 AI Concepts
What it is
This cluster is the alphabet of AI. First of all: LLM (large language model) is the type of AI that understands and generates text—it's the "engine" behind the assistant. You talk to it through an prompt: the message you write. Above every conversation is the system prompt, a background instruction (role, context, rules) that applies to the entire session.
Everything the LLM "sees" at that moment is the context (or context window, “context window”) — the conversation’s memory space. This space is measured in tokens: pieces of words that the AI counts. And there’s an effect to watch out for: the context rot ("context rot"), the drop in quality when the window fills with history and the model starts making more mistakes.
GlossaryAI concepts
- LLM
- AI that understands and generates text. E.g., you write "summarize this email" and it returns the summary.
- Prompt
- The message you send. E.g.: "create a workflow that checks email every 10 min".
- System prompt
- Session background instructions (role, rules). E.g.: "you're my n8n workflow assistant".
- Context / context window
- Everything the AI sees now (the conversation memory). E.g., the files and messages already exchanged.
- Token
- A piece of a word that AI counts; longer conversations use more. E.g.: "automation" ≈ a few tokens.
- Context rot
- Quality drops when the window fills up. E.g.: after a lot of history, the AI forgets an initial rule.
Why learn
These six terms explain why the assistant sometimes "forgets" or gets things wrong: the conversation grew, the window filled up, the context went stale. Knowing this gives you the right reflex — start focused sessions and clear the context before quality drops (you’ll learn how in the modes below).
Key concepts
The engine that generates text.
Your message.
The conversation memory.
The unit of what it reads.
🎛️ Assistant modes
What it is
The assistant has permission modes that control how much it acts on its own. The plan mode (plan mode) is where it researches, asks questions, and proposes a plan before of changing anything—you approve first. At the other end, the bypass permissions ("skip permissions") lets it act without asking for approval at every step — fast, but you stop seeing what it does, so use it carefully.
To manage the context (which you saw get stale), there are two commands: /clear resets the entire conversation — use it when switching tasks or when quality drops; /compact creates an intelligent summary, keeping the essentials and compressing the rest — use it in the middle of a task when the context gets large.
GlossaryModes & commands
- Plan mode (planning mode)
- Research + questions + plan before executing. E.g., you describe the goal and review its plan.
- Permission modes
- How much the assistant acts on its own: ask first, edit automatically, plan, auto. E.g.: "ask before editing".
- Bypass permissions
- Skips approval at every step; fast, but you lose visibility. E.g.: enabled for a long, approved build.
/clear- Resets the conversation from scratch. E.g.: when switching projects or when it starts making mistakes.
/compact- Smart summary: keeps what matters. E.g.: in the middle of a long task, near ~70% context.
Why learn
These commands are your "clutch." Starting in plan mode prevents the AI from building the wrong thing; /compact e /clear keep quality high and token costs low. A practical rule: consider compacting when context is near 70%, and clearing it above 85% or when switching tasks.
✓ Good use of modes
- ✓Start in plan mode for non-trivial tasks.
- ✓
/compactin the middle;/clearwhen switching tasks. - ✓Bypass only after approving the plan.
✗ Avoid
- ✗Bypass from the start, without seeing what it does.
- ✗Reuse an bloated conversation for something new.
- ✗Keep insisting with degraded context instead of clearing it.
Key concepts
Plans before acting.
Fast, but blind.
Full reset.
Smart summary.
🗂️ Key files
What it is
A vibe coding project revolves around a few files. The most important is the CLAUDE.md: a system prompt persistent, written in markdown, that defines who the assistant is, what you're building, and your preferences—it's read every session. The .env stores the secrets (API keys), and the .gitignore lists what never should go to the cloud — and the .env is always on this list.
To connect tools, there’s .mcp.json: the file that records the project’s MCP servers (but the key itself stays in the .env, never here). And when you package a reusable instruction, it becomes a SKILL.md inside the skills folder—the "manual" for that skill.
GlossaryProject files
- CLAUDE.md
- Persistent system prompt in Markdown (role, context, rules, style). E.g.: "you're my n8n assistant; be concise".
.env- Secrets file (API keys), outside the code. E.g.: the n8n key and instance URL go here.
.gitignore- List of what doesn't get pushed to GitHub. E.g.: the
.envgoes here so the key never leaks. .mcp.json- Project MCP servers registry (without the key). E.g.: the server entry + a key placeholder.
- SKILL.md
- The "manual" for a skill (name, description, arguments, steps). E.g.: the skill
/rascunhar-email.
Why learn
Knowing these files means knowing where each thing lives: session rules in CLAUDE.md, secrets in the .env, tools in the .mcp.json, skills in SKILL.md. This avoids the most dangerous beginner mistake—pasting an API key in the wrong place (in the chat or in the .mcp.json) and expose it.
🎯 Practical tip
Golden rule for secrets: the API key only goes in the .env — never in chat, never in the .mcp.json, never committed. The .gitignore ensures that the .env don’t upload it. Treat a key like access to a credit card.
Key concepts
Rules for every session.
Only secrets go here.
What doesn’t go live.
Registers tools.
🔌 MCP
What it is
MCP (Model Context Protocol) is the protocol that connects the assistant to external tools. The provider of these tools is an MCP server — a small program that exposes a set of actions. Each action is a tool (tool): send email, scrape a site, read a database. Once connected, the assistant knows all the tools on that server and decides which one to call.
You don’t need to invent servers from scratch: there’s the server discovery — MCP directories and public repositories with ready-made servers by category (web scraping, databases, documents, communication). Installation usually means asking the assistant to configure it and pasting the key into the .env and restart.
GlossaryMCP & tools
- MCP (Model Context Protocol)
- The standard that connects the assistant to external tools. E.g.: connect the assistant to your n8n.
- MCP server
- The program that exposes a service’s actions. E.g., a web scraping server; an n8n server.
- Tool (utility)
- Every action the server offers. E.g.: "send email," "search messages," "create workflow".
- Server discovery
- Find ready-made servers in directories/repositories. E.g., search for "MCP server" + the service name.
- Project-level vs global
- Where the server is configured. Per project is recommended (safer).
Why learn
MCP is what turns the assistant from a “text writer” into a “doer in the world.” Without it, there's no sending email, scraping the web, or building in n8n. Understanding server × tool helps you ask for the right tool — and remember that each connected server uses context, so turn off the ones you don't use.
Key concepts
The common language.
Exposes the actions.
An action.
Safer than global.
🔗 Basic n8n
What it is
In n8n, the basic building block is the node (node): a little box that does a job. Every flow starts with a trigger (trigger): the node that starts the flow—by schedule, when an email arrives, or when an event occurs. The full sequence of nodes, from trigger to final action, is the workflow.
For a node to access an app (Gmail, Sheets…), it needs a credential (credential): the authorization stored in n8n. The most common way to authorize is OAuth2 — a “delegated login” where you sign in to your Google account and grant access without giving n8n your password.
Illustrative diagram — the trigger starts, the nodes execute, and the credential (authorized via OAuth2) gives the node access to the external app.
Glossaryn8n blocks
- Node (node)
- A little box that does one job. E.g., one node reads Gmail; another writes to a spreadsheet.
- Trigger (event)
- The node that triggers the flow. E.g.: "every 15 min" or "when an email arrives".
- Workflow
- The entire sequence of nodes. E.g.: trigger → filter → action → save.
- Credential (credential)
- The authorization stored to access an app. E.g.: the Gmail credential.
- OAuth2
- Delegated login: you authorize without giving your password. E.g.: "sign in with Google" and grant access.
Why learn
These five terms are the minimum vocabulary for understanding (and requesting) any automation. Here's one detail that saves headaches: the assistant builds the nodes, but credentials (OAuth2) you need to configure it manually — that’s the part it doesn’t do for you.
Key concepts
Do a piece of work.
Triggers the workflow.
You configure it manually.
Log in without giving your password.
🤖 n8n with AI
What it is
n8n has nodes that put AI into the flow. The AI agent node is the node that becomes a mini-agent: it receives an instruction (system prompt), can use tools, and responds with reasoning. The text classifier ("text classifier") labels an input with categories — useful for route before spending on the expensive agent (e.g., "is this technical support or not?").
For custom logic, there’s code node ("code node"): a node that runs a small piece of code (written by the assistant) to transform data — extract a name, assemble text, set a flag. And for simple yes/no decisions, there is the IF node, which branches the flow: if the condition is true, it takes one path; otherwise, it takes another.
GlossaryAI & logic nodes
- AI agent node
- A node that reasons, uses tools, and responds. E.g.: reads the question, queries the knowledge base, and drafts the answer.
- Text classifier
- Labels the input with categories to route it. E.g.: "support" vs. "not relevant" — skip anything that isn't support.
- Code node
- Runs a code snippet (written by the assistant) to transform data. E.g.: extract the name from a subscription.
- IF node
- Branches the flow based on a yes/no condition. E.g.: "did you find the policy?" → if yes, draft; if no, request research.
Why learn
Combining these nodes is at the heart of a useful agent: the classifier filters early (saving resources), the IF node chooses the paths, the code node adjusts the data, and the AI agent does the thinking. Knowing each one’s role helps you understand what the assistant built — and ask for specific improvements.
✓ Good design with these nodes
- ✓Classify early so you don't trigger the agent unnecessarily.
- ✓Use IF to handle paths (found / not found).
- ✓Code node for extracting/transforming specific data.
✗ Signs of trouble
- ✗Send everything straight to the agent (expensive and slow).
- ✗Forgetting the "no" path of the IF (the flow dies silently).
- ✗Trusting the “green” status without checking the actual output.
Key concepts
Thinks and uses tools.
Labels and routes.
Transforms data.
Branches the flow.
📊 Data
What it is
For the AI to respond based on the your documents, they need to become searchable data. The vector store ("vector store") is a special database that stores the meaning of text so you can search by meaning, not just by exact word. This "meaning in numbers" is called embeddings: the numerical representation of a piece of text.
Before storing, two steps prepare the documents. The document loader ("document loader") reads the file and extracts the text. The text splitter ("text splitter") breaks that text into chunks of the right size — because search and retrieval work better with passages than with one giant document.
GlossaryData blocks
- Vector store
- Database that searches by meaning, not exact words. E.g.: find the warranty policy even without the word "warranty".
- Embeddings
- The meaning of text turned into numbers. E.g., similar passages are "close" together in this numeric space.
- Document loader
- Reads the file and extracts the text. E.g.: open a policy PDF and retrieve its contents.
- Text splitter
- Break the text into searchable chunks. E.g., split the PDF into sections.
Why learn
These four blocks are the foundation of RAG (which you'll see in module 1.4): instead of the AI "guessing," it consults your documents and answers based on them—and refuses to make things up when the data isn't there. That's what separates a reliable agent from one that hallucinates.
The context window filled up with history, and the AI started making more mistakes. What is this effect called?
Key concepts
Search by meaning.
Meaning in numbers.
Read the document.
Break it into sections.
📌 Module Summary
/clear, /compact..env, .gitignore, .mcp.json, SKILL.md.Next Module:
1.4 — Essential Glossary (Part 2: Agentic, RAG, Deploy, Security)