Remember When ETL Became dbt?

Someone on a sales call tells you their platform runs an agentic RAG pipeline with MCP integrations and a large context window. You nod. You write it down to look up later. You never look it up, and six months on you're still nodding at the same six words.

Remember when ETL became ELT, and then the T got its own tool and everyone started saying dbt? AI's doing the same thing right now — a familiar idea with new branding.

The job was always three steps, and they're what the letters stand for:

• Extract — pull the data out of wherever it lives.
• Transform — clean it up, reshape it, make it agree with itself.
• Load — put it somewhere you can query.

Those three never changed. The order did, one step at a time:

1. Storage was expensive, so you transformed before loading. On an on-prem warehouse you paid for every gigabyte you kept. You cleaned and aggregated on a separate server and loaded only the result — and that logic lived inside a GUI tool nobody could diff, test, or put in version control.
2. Cloud warehouses removed the constraint. Redshift, BigQuery and Snowflake made storage cheap and let compute scale on its own, so shrinking the data before keeping it stopped paying for itself. Load it raw, sort it out after. The L and the T swapped places, and ELT is just those letters in their new order.
3. Once the T ran inside the warehouse, it was only SQL. SQL in files is code, and code wants version control, tests, dependencies and review. That's the gap dbt filled when Fishtown Analytics released it in 2016, right as Snowflake and BigQuery were taking off.
4. The job title followed the tool. "Analytics engineer" exists because that middle step had turned into its own craft, done by people who write SQL rather than pipelines.

AI had nothing to do with any of it. That whole arc ran years before the current wave. I'm holding the two up next to each other because new tools reshuffled the vocabulary both times.

That's what happens whenever tooling moves: for a couple of years, everyone sounds like they're describing something that never existed before.

So here are the six words.

1. Agentic AI

Translation: it decides the steps, not you. It plans, acts, looks at what came back, and adjusts. The older cousin is Zapier (a workflow automation tool), Make, or n8n, where every branch is one you drew by hand.

Example: Claude Code, Devin, AutoGPT. The formal version, from MIT Sloan citing research by John Horton and co-authors:

autonomous software systems that perceive, reason, and act in digital environments to achieve goals on behalf of human principals, with capabilities for tool use, economic transactions, and strategic interaction.

How it runs. Ask Claude Code to fix a failing test. You don't get an answer — it searches the repo, opens the file, edits it, runs the suite, reads the failure, and goes again. Nobody scripted that order. Each step was chosen from what the last one returned.

The limit worth knowing: anything that can loop can loop forever. Harnesses cap the rounds for exactly that reason.

If you want the small version of this before the big one, I wrote a guide on it: how to set up an AI agent to watch your store.

2. RAG

Translation: it checks your real documents before answering. It searches a knowledge base first and answers from what it finds, instead of answering from memory. A chatbot bolted onto a search engine — the older cousin is the FAQ bot wired to your help docs, same promise with far better reading comprehension.

Example: Notion AI. You ask a question, it reads your own workspace pages, and the answer comes back with links to the pages it used. Perplexity does this against the open web. Microsoft Copilot does it against your company's files.

Two ways to give an AI a document, and only one is RAG. Say you have a company handbook you want an assistant to know:

	Pasting it in	Searching it
What the model gets	The whole document, every run	The two or three closest passages
Matched on	Identical bytes	Meaning of the question
Who decides	Nobody — it's always there	The agent, per question
What it changes	Your bill	The answer
Is it RAG?	No	Yes

Both save work, which is why they get conflated. They are not the same mechanism.

Pasting it in

The whole document goes into every prompt on every run, so the model never looks anything up. You pay to process that text once rather than once per call, because of prompt caching.

You mark a chunk of the prompt as cacheable, the provider stores the processed version, and any later request beginning with those same exact bytes reads the stored copy. Roughly a tenth of the normal input price, for one extra field:

system = [{
    "type": "text",
    "text": handbook + role_instructions,
    "cache_control": {"type": "ephemeral"},
}]

Three things decide whether it saves you anything.

It matches from the very start of the prompt. Your marker sets where the cached chunk ends. Matching always begins at byte one, so anything that shifts ahead of your marker breaks everything below it. Keep the stable parts first and the changing parts last.

The usual culprits: a datetime.now() in the system prompt, a session ID, a tool list built per user. Each one switches caching off silently.

There's a minimum size. Below it nothing caches and no error tells you. The threshold is per model and moves between releases, so look it up for the one you're running.

Trust but verify. Every response reports usage.cache_read_input_tokens — the number of tokens served from cache. Send the same request twice. If it's still zero the second time, something in your prefix is changing between calls.

Searching it

The same handbook gets chopped into pieces and stored so it can be found by meaning. Ask a question and you get back the few passages nearest to it, not the whole file. Here's the path, with the error handling stripped out:

vector = (await provider.embed([query]))[0]        # 1. question -> numbers
hits = await store.search_chunks(vector, limit=5)  # 2. nearest neighbours
return "\n".join(                                  # 3. text + how close it landed
    f"- ({h['similarity']:.2f}) {h['content'][:300]}" for h in hits
) or "No matches."                                 # 4. say so when there is nothing

Three details in there are worth copying.

Keep the score. similarity is how close the passage sat to the question, from 0 to 1. Pass it to the model along with the text. Without it, a 0.9 match and a 0.2 match look the same, and the agent treats a weak guess as something the company wrote down.

Say so when you find nothing. That trailing or "No matches." carries more weight than its length suggests. Return an empty string and the model fills the silence from its own memory, which is the failure retrieval was there to prevent.

Tell the model when to call it. A tool description that only says what the tool does gets reached for less often than one naming the moment to reach for it — "use this before answering anything about pricing" beats "searches the pricing docs."

Then count how often it fires. Ask a vendor selling you "RAG-powered" for that number: the phrase covers both a system that checks on every answer and one that checked once, at install.

How the searching-by-meaning part works is term 4.

3. Context window

Translation: how much it can hold in its head at once, measured in tokens. The bigger the window, the more it holds before the beginning starts falling off the back.

The older cousin is the character limit on a form field — except here your instructions, your documents, the conversation so far and the answer it's about to write all share the one limit.

Example: you've met it if a long chat has ever started forgetting what you told it at the top. That's the beginning of the conversation falling out the back of the window.

No numbers here on purpose. Model windows change on a release cycle measured in months, so a figure printed in a guide is wrong by the time you read it — ask for the current one when it matters.

Where it bites. Something upstream trims your input to fit, and neither of the two failure modes raises an error:

• The tail disappears. A naive cut takes whatever is past the limit, so the model answers confidently on a document it only half received.
• Nothing says so. No warning, no marker. Every run looks fine.

If you're building the thing doing the trimming, cut deliberately and say what you cut — a note at the bottom naming what was dropped turns a silent wrong answer into a visible gap.

4. Vector database and embeddings

Translation: a search index for meaning instead of keywords. Text gets turned into numbers, and similar ideas land close together, so a search for one finds the others. Elasticsearch's cooler cousin.

Example: Pinecone is the hosted one people name. pgvector is the free extension that turns Postgres into one.

How it works. An embedding model turns each chunk of text into a list of numbers — a few hundred to a few thousand of them. Similar meanings land near each other in that space, so "how do I cancel" and "I want a refund" sit close together even though they share no words.

Searching means embedding the question the same way and asking for its nearest neighbours.

One setup decision matters more than the rest: the column has to match the model. An embedder producing 1,024 numbers needs a vector(1024) column, and changing embedders later means re-embedding everything you stored.

5. MCP

Translation: it plugs an AI agent into your tools without a custom build for each one. One open standard, published by Anthropic, in place of one-off integration code. A port converter for AI tools.

Example: every connector you've added to Claude is one. Notion, Gmail, a database, your own files — each of those connections is an MCP server sitting between the model and the app.

How you'd add one. Take that last one. The filesystem server lets Claude read and write files on your machine, and adding it is a few lines of JSON in your client's config:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/you/Desktop",
        "/Users/you/Downloads"
      ]
    }
  }
}

Three things in there are the whole idea.

Those trailing paths are the permission model. Desktop and Downloads are the only folders that server can touch. There's no separate settings screen and no scopes to tick — the reach is whatever you typed into args.

The server runs as you. It can do anything you could do from a terminal in those folders, so give it the narrowest path that still lets the job work. A server pointed at your home directory has your whole home directory.

The client asks before it acts. Claude Desktop raises an approval for each file operation, which is the difference between a misfire you catch and one you find later.

6. Hallucination

Translation: the model makes something up. It predicts likely words rather than looking up facts, so a wrong answer arrives in the same confident voice as a right one. The older cousin is a colleague confidently misremembering a number in a meeting. What's changed is the speed and the volume.

Example: the one everybody cites is Mata v. Avianca. A brief went in citing six court decisions that did not exist — names, citations, quoted passages, all invented. Steven Schwartz had done the research with ChatGPT. When the citations were challenged he went back and asked ChatGPT whether the cases were real, and it said yes. Peter LoDuca signed and filed.

On June 22, 2023, Judge P. Kevin Castel of the Southern District of New York fined both attorneys and their firm $5,000, and ordered letters sent to their client and to every real judge whose name had been attached to a fabricated opinion.

Two things there apply well beyond a courtroom.

The check has to come from outside the model. When the citations were challenged, Schwartz went back and asked ChatGPT whether the cases were real, and it told him they were. A model asked to grade its own work will usually agree with itself.

Fluency is not a confidence signal. The fake opinions had names, docket numbers and quoted passages. Nothing in the writing marked them as invented, because nothing in how the text is produced distinguishes a remembered fact from a plausible-sounding one.

So the practical version: for anything that would matter if it were wrong, ask for the source and open it. Retrieval (term 2) narrows the gap by putting real documents in front of the model, and it narrows it rather than closing it — a passage can be retrieved correctly and still be summarized wrong.

What to Ask a Vendor

Three uncomfortable questions get you most of the way, and none of them require you to have built any of this.

Which of these do you run, and how often? "RAG-powered" covers both a system that reads your files on every answer and one that read them at setup. Fourteen lookups in a week is a real answer.

What happens when the lookup comes back empty or cut off? Listen for a refusal. My duplicate check treats "I couldn't read the queue" as a stop sign now, because for two runs it treated the same silence as a green light.

Show me a time it was confidently wrong, and what you changed. Anyone running this stuff for more than a month has a story. If they say it hasn't happened, either you're their first customer or nobody is checking.

Quick Recap

• Agentic means it picks the steps. Claude Code and Devin are the famous ones; mine routed a question to an engineer I never named, in four minutes.
• RAG means it reads your files before answering — Perplexity, Notion AI, Copilot. Ask how often the reading happens.
• Context window is how much fits at once. Ask what gets dropped when something doesn't fit, and how you'd find out. Mine dropped the section called "Needs Daisy."
• Embeddings and vector databases search by meaning. Pinecone and pgvector. The database is the easy part.
• MCP is an open standard for connecting AI to your tools. Narrow what it can reach, and force what it must not guess.
• Hallucination is confident invention, and it fined a law firm $5,000. Assume it will happen to you, and build the sweep that catches the copies.

Start Here

If you can follow the vocabulary now but still can't tell which of it your business needs, that's the real gap, and it's a normal place to be.

At daisyguti.ai/work-with-me there's an AI intake assessment that maps where your business stands before any call. It takes a few minutes and gives you a clear read on what to hand off first. Daisy is a 20+ year engineer who builds these systems for small business owners, so the assessment reflects how real businesses run.

Sources

1. MIT Sloan, "Agentic AI, explained" - https://mitsloan.mit.edu/ideas-made-to-matter/agentic-ai-explained
2. Mata v. Avianca, Inc., No. 1:22-cv-01461, Opinion and Order on Sanctions (S.D.N.Y., June 22, 2023) - https://law.justia.com/cases/federal/district-courts/new-york/nysdce/1:2022cv01461/575368/54/
3. Model Context Protocol, official documentation - https://modelcontextprotocol.io
4. pgvector, open-source vector search for Postgres - https://github.com/pgvector/pgvector
5. Anthropic, prompt caching documentation - https://platform.claude.com/docs/en/build-with-claude/prompt-caching
6. dbt Labs company history (founded as Fishtown Analytics, dbt released 2016) - https://research.contrary.com/company/dbt-labs