The AI Add-On Map: LLM, RAG, MCP, Agent, and Skill, All Plotted on One Diagram

The Whole String of AI Terms You'll Run Into: From LLM to Agent, RAG, MCP, Skill, All Untangled in One Go

In meetings or while scrolling through tech groups, someone always drops a pile of terms: Agent, RAG, MCP, Skill, Embedding, hallucination... Many people nod along, but few can actually say what each is responsible for. They sound like the same thing, but they each cover a different stage.

Most of them are not "an even smarter AI". They're add-on parts for the same model that can already talk: one helps it look things up, one lends it hands, one teaches it to follow your rules and take a few more steps.

Treat this as an assembly diagram. It sticks to one concrete task:

You tell the assistant: "Based on the company's newest login rules, update the API documentation in the repo, self-test after the change, then show me."

Every term below answers the same question — at this step, what is AI missing, and what does this term fill?

1. Start with a picture: the layers of an AI assistant's abilities

Think of the assistant as a machine you can assemble: the core is an LLM, and around it are layers of add-ons.

Assembling an AI assistant: from parts to getting work done

From inside out (if you're reading the diagram, go bottom to top):

LLM — the speaking core
Prompt / Context / Token — how you talk to it, how much it can see at once
Embedding + Vector DB — turn text into searchable "meaning fingerprints"
RAG — open-book exam before answering
Tool calling + MCP — borrow hands, unified plugs
Agent + Skill — self-scheduling plus the standard operating card on the wall

The entries below are broken down in this order; by the end, the whole chain snaps back together.

2. LLM / LLM: AI's mouth and brain

What AI lacks: an engine that, given text already fed in, can keep writing "like a human" continuation.
What it fills: language ability itself — explanation, drafting, rewriting, summarizing.
Metaphor: A chef is great at cooking, but the fridge doesn't have your company's login rules that were just changed today.
What it is not: not an auto-connected encyclopedia, and not "once put in a chat box, it becomes a programmer that edits the repo."
Back to the story: without it, nothing else works; with it, it's only "able to talk" — it won't automatically edit the doc per the rules.

One sentence: The LLM is responsible for making the text read smoothly; whether it's correct or current is another question.

3. Prompt, Context, Token: how you talk to the AI

Prompt (the prompt)

What AI lacks: it doesn't know what you want in this particular round.
What it fills: your instruction manual + question + constraints (tone, format, forbidden items).
Metaphor: When ordering food, if you say clearly "less spicy, no cilantro", the chef won't improvise.
What it is not: not a mystical incantation; writing clearly beats piling on adjectives.

Context window (context)

What AI lacks: limited space for what it can "see" at once in a conversation.
What it fills: the system instructions, history, retrieved fragments, and tool results that fit in the current round.
Metaphor: A lazy Susan at the dinner table — too many dishes, and the one from earlier gets rotated out.
What it is not: not permanent memory; content outside the window is invisible this round.

Token

What AI lacks: a ruler to measure how long the "input / output" is.
What it fills: a unit for billing and length limits (roughly broken-up word chunks; Chinese and English are cut differently).
Metaphor: not paying by "character", but by "chopped pieces".
What it is not: not an intelligence score; more tokens just mean the text is longer or more fragmented.

Back to the story: your request itself is a prompt; if the full rules are too long to fit in the window, you'll need the retrieval later, not pasting the whole book.

4. Hallucination: a smooth-sounding answer doesn't mean something happened

What AI lacks: it optimizes "which next word looks more likely", not "which fact has been verified".
What the hallucination concept teaches: it makes you aware that fluency != correctness.
Metaphor: Some people are eloquent enough to describe things that never happened as if they were there.
What it is not: not "hallucination only happens in broken models"; when there's no external grounding, covering up is a normal risk.
Back to the story: if you only ask "what's our login lockout rule?", it might confidently answer "lock for 24 hours after 3 wrong attempts" — sounds professional, but has nothing to do with your rules.

That's why the RAG and human review come later, rather than treating "the model is absolutely honest" as a myth.

5. Embedding and vector DB: give sentences a "meaning fingerprint"

Embedding (embedding / vector)

What AI lacks: pure keyword search often fails when the wording differs.
What it fills: converts a piece of text into a string of numbers (vector), where similar meanings are close together.
Metaphor: Give each rule a fingerprint based on its "scent" — "password error lockout" and "how many wrong attempts before lock duration" share a similar scent.
What it is not: not another chat model; it's a representation used for retrieval.

Vector DB

What AI lacks: you need to store the fingerprints and query them quickly.
What it fills: a cabinet that stores vectors and recalls by similarity (can also mix with keyword retrieval).
Metaphor: In a library you can find a shelf by "similar scent", not just exact match on the title's four characters.
What it is not: not an Agent that auto-writes docs.

In teaching, keyword search can demonstrate "search first then answer"; in production, Embedding + vector DB holds up better against rephrasing. The local demo deliberately uses keyword search to keep zero dependencies and make it obvious at a glance.

6. RAG: give the AI an open-book exam

RAG = Retrieval-Augmented Generation.

What AI lacks: its training data doesn't contain today's rules; memorizing by rote also tends to hallucinate.
What it fills: first retrieve relevant material → stuff it into the context → then let the model answer.
Metaphor: an open-book exam — you're allowed to flip through the book, but the book is the few pages you just inserted.
What it is not: not an "Agent that automatically does work"; RAG solves answering with a basis, not going off to edit the repo.

Back to the story: the assistant should first pull out the relevant rules about "login failure lockout" and "password storage", then talk about how to change the API documentation.

The minimal intuition looks like this (pseudo-code):

// Teaching illustration: retrieve → stuff into prompt → then call the model
function answerWithRag(question, docs) {
  const hits = retrieve(question, docs); // keyword or vector retrieval
  const context = hits.map((d) => d.body).join("\n---\n");
  const prompt = `
You must answer only based on the company rules below; for anything not in the rules, say "unknown", don't fabricate.

【Rules】
${context}

【Question】
${question}
`;
  return callLLM(prompt);
}

The demo at the end lets you click through it yourself: fabricated answer without retrieval vs excerpt after retrieval.

7. Tool calling / Function calling: lend the AI a pair of hands

What AI lacks: a pure text model can't change files on your disk or run tests.
What it fills: the model can propose "please execute such-and-such action" (read file, write file, run command); the actual hand is your program.
Metaphor: The chef says "go get eggs from the fridge" — the mouth belongs to the model, the hands to the waiter.
What it is not: not that the model grew hands; not "magic happens when you say it once".

Illustration: the model returns a structured call, and the runtime executes it.

// The model might return this kind of "proposal" (illustration)
const toolCall = {
  name: "read_repo_file",
  arguments: { path: "docs/login-api.md" },
};

// Your runtime executes, then feeds the result back into the conversation
const fileText = await readRepoFile(toolCall.arguments.path);

Back to the story: editing the API doc and running self-tests both need tools, not just generating "a piece of text that looks like a diff".

8. Agent: from "answer one sentence" to "take steps toward a goal"

What AI lacks: single-turn Q&A won't look at the result and decide the next step by itself.
What it fills: a loop — think one step → call tool/retrieve → observe result → think again, until the goal is done, failed, or you interrupt.
Metaphor: not an order-taker who only recites the menu, but an assistant who schedules the steps: read the rules, open the file, make the change, test.
What it is not: putting a ChatGPT skin on something doesn't make it an Agent; the key is a multi-step decision loop, not the look of a chat bubble.

Minimal skeleton:

async function runAgent(goal, { tools, maxSteps = 8 }) {
  let messages = [{ role: "user", content: goal }];
  for (let i = 0; i < maxSteps; i++) {
    const decision = await callLLM(messages); // may contain tool_calls
    if (!decision.tool_calls?.length) {
      return decision.content; // thinks it's done, shows you
    }
    for (const call of decision.tool_calls) {
      const result = await tools[call.name](call.arguments);
      messages.push({ role: "tool", name: call.name, content: result });
    }
  }
  return "Reached step limit, bring in a human.";
}

Back to the story: your sentence is the goal; the middle steps "check rules → read doc → edit → test" are chained by the Agent, not by you manually copy-pasting for a dozen rounds.

9. MCP: the standard plug for the outside world

MCP = Model Context Protocol, an open protocol from Anthropic that connects data sources and tools to AI apps in a standard way.

What AI lacks: every client and every tool uses private integration; when you switch to a different assistant you have to rewrite "read email / read repo / open browser" every time.
What it fills: a unified connector convention — a server exposes capabilities, a client discovers and calls them following the protocol.
Metaphor: USB: thumb drive, keyboard, card reader — only when the plug shape is agreed upon do you not have to solder a custom wire for every computer.
What it is not: not a smarter LLM, not a nickname for some chat product; it's a connection protocol.

Back to the story: reading repo files and listing directories can be exposed as standard tools through an MCP server; the Agent calls the "plugged-in capability" rather than a private function name hard-coded in some SDK (though in practice you'll still handle auth, audit, and least privilege).

10. Skill: the standard operating card on the wall

Skill (skill) has slightly different names across products; here it uses the common meaning: a reusable "how we do this thing according to our rules" — steps, constraints, common tools, output format.

What AI lacks: every time it has to guess the process from scratch, it easily misses "must reference rule numbers" or "no direct push".
What it fills: turning the process into a card, so the assistant improvises less and follows the script more.
Metaphor: the standard operating card at a bubble-tea shop: wash the cup first then scoop the ice, not letting a new hire invent the process on the spot.
What it is not: not fine-tuning model parameters; not retraining the weights. Skill changes the operating instructions, the behavior script.

Back to the story: a Skill can be written that says — first use RAG to get the login rules → then read docs/login-api.md → only change the docs, not the business code → run a doc-link check → finally hand it to a human for review.

11. Multi-Agent: multiple specialized assistants (just a touch)

What AI lacks: cramming "retrieval expert + writing expert + testing expert" into one loop makes the context crowded and responsibilities blurry.
What it fills: splitting into multiple roles that collaborate (some products call it Multi-Agent or Crew).
Metaphor: front-of-house takes orders, kitchen cooks, food runner checks — not one person doing three jobs and pretending it's fine.
What it is not: the myth that more people must be stronger; the cost of orchestration, handoff, and arguing will come back to you.

Back to the story: you can split a "rule retrieval Agent" and a "doc modification Agent", but for a personal project, one Agent with a good Skill is often enough.

12. Fine-tuning & workflow: two signposts to avoid confusion

Concept	What it does	Don't confuse it with
Fine-tune	Use your data to change the model's disposition/tone/domain format	Not RAG; also not the same as adding an Agent
Workflow	A fixed pipeline written by a human: after A, B must happen	Different temperament from Agent, which "decides the next step itself"

Fine-tuning is expensive, slow, needs data and evaluation; when rules change often, prioritize RAG + Skill rather than fine-tuning on a whim. Workflows fit fixed, compliance-heavy steps; exploratory tasks are more Agent-like.

13. Full chain: from one sentence to an edited doc

From one sentence to an edited doc

Replay the whole task:

Skill sets the rules: must cite rule numbers; only touch docs; self-test after change; human review at the end.
Agent breaks down steps: check rules → read file → edit → test → summarize.
Embedding / vector DB + RAG pull out the login-related clauses (open-book material).
MCP / tools read the API documentation in the repo.
Tools write the edits and run checks.
You make the call — no matter how capable the AI is, the responsibility for going live still falls on a human.

Through all this, the main character is still "you collaborating with the AI"; the add-ons each do their own job.

14. Comparison table: what each term adds to the AI

What these terms add to AI

Concept	What it adds to AI	Without it	Common misunderstanding
LLM	Can talk and write	No "mouth and brain"	Thinking it automatically knows the company's new policy
Prompt / Context / Token	Describes the task, limits view and length	Off-target answers or mid-conversation amnesia	Treating it as a mystical incantation
Hallucination (awareness)	Reminds you fluency ≠ correctness	Fooled by a smooth cover-up	Thinking only low-quality models hallucinate
Embedding / vector DB	Retrieve by meaning	Change the wording and you can't find it	Treating it as a chat model
RAG	Open-book, grounded answers	Making up rules	Treating it as an Agent
Tool calling	Borrow hands to execute actions	Can only output text	Thinking the model grew its own hands
Agent	Multi-step decision loop	You hand-write a dozen rounds	Chat bubble = Agent
MCP	Unified plug for external capabilities	Every vendor has private integration	Treating it as a model
Skill	Reusable operating card	Guess the process from scratch every time	Treating it as fine-tuning
Multi-Agent	Specialized division of labor	Single role is crowded and blurry	More people must be stronger

15. Hands-on: a mini demo (with retrieval vs without)

In the directory is a zero-dependency little page (with 3 fake login rules):

demo/index.html
demo/app.js
demo/README.md

Run it locally:

cd demo
python3 -m http.server 8765
# open http://127.0.0.1:8765 in a browser

Click the two buttons:

"Fake answer" without retrieval — you'll see "lock for 24 hours after 3 wrong attempts / use MD5", a smooth-sounding but rule-irrelevant cover-up.
"Answer after retrieval" — it first lists the matched R-01 / R-02 snippets, then excerpts "lock for 15 minutes after 5 wrong attempts / Argon2id".

The core retrieval logic is that short (not the same scale as production vector retrieval, but structurally isomorphic):

function retrieve(question, docs, topK = 2) {
  const qTokens = tokenize(question);
  return docs
    .map((doc) => {
      const hay = (doc.title + " " + doc.body).toLowerCase();
      let score = 0;
      for (const t of qTokens) if (hay.includes(t)) score += 1;
      return { doc, score };
    })
    .filter((x) => x.score > 0)
    .sort((a, b) => b.score - a.score)
    .slice(0, topK);
}

If you replace the "fake answer" in the demo with a real callLLM(prompt), you get a minimal usable RAG prototype. It's best to hard-code in the prompt: say "unknown" for anything not in the rules; don't fabricate.

16. Wrap-up

To work with AI, distinguishing these two things will serve you for a while:

Model: the core that can write;
Add-ons: RAG handles grounding, tools handle action, Agent handles multi-steps, MCP handles how to plug in, Skill handles following the store rules.

Next time you hear a new term, ask yourself: is it giving AI eyes, hands, steps, or just a new coat?

If you can tell the difference, you won't be scared by nouns, and you won't mistake a chat box for a universal toolbox.