598: I Turned My Course, Blog, And Podcast Into An AI Bot – Here’s The Tech Behind It

Podcast: Download (Duration: 41:49 — 48.1MB)

The fastest way to build a custom AI chatbot trained on your own course, blog, and podcast is to use retrieval-augmented generation (RAG), and it is dramatically simpler than most people assume. In this episode, I walk co-host Toni Herrbach through Stevebot, the assistant I just built for my 14-year-old e-commerce course, which now has more than 450 active video lessons. The build took roughly three days end to end and combines OpenAI’s Whisper for transcription, a chunk-and-tag pipeline for prep, an embedding-based vector search for retrieval, and GPT for the final answer.

The point of this post is to demystify the stack. What most people picture when they say “train an AI on my content” is a giant upload to ChatGPT. That is not how it works and would not work at scale. What actually works is RAG: you break your content into small chunks, turn each chunk into math, and when a student asks a question, you find the closest-matching chunks and only feed those to the language model to summarize an answer.

Below is the exact workflow I used, the mistakes I made, the anti-hallucination guardrail I set, and how a non-coder can build a small version of this for a store or a course.

Get My Free Mini Course On How To Start A Successful Ecommerce Store

If you are interested in starting an ecommerce business, I put together a comprehensive package of resources that will help you launch your own online store from complete scratch. Be sure to grab it before you leave!

Click Here To Download

Key takeaways

• The right architecture for a content-trained AI chatbot is RAG (retrieval-augmented generation), not “upload everything to ChatGPT.” Context windows and cost make the naive approach impossible.
• Use OpenAI’s Whisper model to generate transcripts. It is open-sourced and free to run locally on a decent GPU, or roughly $0.006 per minute of audio via OpenAI’s API.
• Chunk transcripts into ~500-word blocks, then tag each chunk with a topic label, video title, and URL. That metadata is what lets the bot link students to the source video.
• Course lessons are the easiest content to train on because each lesson covers one topic. Podcasts are the hardest because guests jump between 10 topics per episode.
• Non-coders can build a version with Make.com: watch a Dropbox folder, send audio to OpenAI Whisper, save transcript, embed, and query. Whisper API cost is fractions of a cent per token.
• The anti-hallucination guardrail is a strict system prompt: “If the answer is not in the retrieved chunks, say I don’t know.” This is the single most important line in the whole system.
• Best use cases beyond a course: product-recommendation bots for e-commerce stores, blog and podcast search that returns exact-timestamp answers, and internal knowledge bots that log every question so you can build content around real gaps.

What is RAG and why is it the right architecture for a content-trained chatbot?

RAG (retrieval-augmented generation) is the standard architecture for training an AI on your own content because it sidesteps the context-window limit that makes a straight upload impossible. Every LLM has a maximum amount of text it can consider at once. A 450-video course is millions of tokens of transcripts, orders of magnitude more than any current context window.

The RAG workflow works in three steps at query time. The user’s question is converted into a numeric vector (an embedding), that vector is compared to every chunk of your content to find the closest matches, and only those matching chunks (usually five to ten) are sent to the LLM along with the question. The model summarizes an answer using just those chunks.

The elegant part is that the LLM does not “know” your content in any trained sense. It reads only the small slice retrieved for each question. That is what keeps cost low, keeps answers accurate, and lets you cite the source video every time.

The full stack behind Stevebot, step by step

The stack has six moving parts and each one solves a specific problem in the pipeline. Here they are in order.

Step 1: Isolate the active source content

The first move is separating what to train on from what to ignore. My course has close to 800 videos including obsolete and pruned ones, but only about 450 are currently active. I wrote a short WordPress routine to pull only the active posts and download those video files into a single directory.

Do this filter step up front. Feeding stale content into a RAG system will make the bot confidently answer questions with instructions you retired two years ago.

Step 2: Generate transcripts with OpenAI Whisper

OpenAI open-sourced its Whisper speech-to-text model, and it is the best free option for bulk transcription. You can run it locally if you have a reasonable GPU (mine is finishing at roughly three minutes per video, so with a better card it would be an overnight job for 450 videos). Or you can hit the Whisper API for about $0.006 per minute of audio.

For non-coders, the cleanest no-code path is Make.com. Point a Make scenario at a Dropbox folder, have it send new audio files to the OpenAI Whisper endpoint, and drop the transcripts back into a second Dropbox folder. That is the workflow I recommend to anyone facing Facebook’s new 30-day live-video retention limit who needs to grab transcripts from downloaded live videos in bulk.

The free-tier alternative for small volumes (under 50 videos) is Riverside.fm, which offers free transcription with a manual drag-and-drop upload.

Step 3: Chunk each transcript into ~500-word blocks

A 20-minute video transcript is too long to embed as one unit. You need to break it into chunks of roughly 500 words each. That size is a widely used starting point because it stays well inside the context window at query time while keeping enough surrounding text for the meaning to survive.

Course videos are easy to chunk because each lesson already covers one topic for 10 to 15 minutes. Podcasts are the hardest content type in a RAG system precisely because the topic drifts every few minutes. A guest interview with 10 topics can produce chunks that mix two half-thoughts, and the retrieval quality suffers.

For podcast-style content, use AI to preprocess. Ask the LLM to segment the transcript by topic before you chunk, and you get much cleaner blocks.

Step 4: Tag each chunk with topic, title, and URL

Every chunk needs three pieces of metadata attached: a short topic label, the original video title, and the video URL. The metadata rides along with the chunk into the vector database.

This is what makes the bot useful for a course. When a matching chunk is retrieved to answer a question, the URL and title come with it, and the bot can tell the student “here is the answer, and here is the specific lesson to watch for the full context.”

Without metadata, you just have a fancy search that returns text with no way for a student to go deeper.

Step 5: Embed the chunks and store them in a vector database

Each chunk gets converted into a vector (a long list of numbers that represents its meaning) using an embedding model. OpenAI’s text-embedding-3-small is the current default: cheap, fast, and accurate for most use cases.

Store the embeddings in a vector database. For small projects, a local file or a lightweight option like Chroma or SQLite with a vector extension works. For production, hosted options like Pinecone or Supabase’s vector extension scale further.

Step 6: Wire up the query flow with an anti-hallucination guardrail

At query time, the user’s question gets embedded the same way, the vector database returns the top-N most similar chunks, and those chunks plus the question get sent to GPT with a strict system prompt.

The single most important line in that system prompt is the anti-hallucination guardrail: “If the answer is not in the retrieved chunks, say ‘I don’t know the answer to that question.'” Without that instruction, the model will fill gaps with plausible-sounding fiction, which is a nightmare for a course meant to teach real strategies.

I also log every question, every answer, and the user’s ID. That log is going to tell me exactly which lessons I need to create next.

Comparison: RAG chatbot build options

How much does a RAG chatbot actually cost to run?

A RAG chatbot costs a few cents to a few dollars per month at hobby scale, and $50 to a few hundred dollars per month at real-course or storefront scale. The heavy cost is one-time setup work, not ongoing usage.

Here is the rough per-query math. Embedding the user’s question with text-embedding-3-small runs about $0.00002 per query. Sending 5 retrieved chunks (~2,500 tokens) plus the question through GPT-4o mini costs roughly $0.001 to $0.003 per answer. For 10,000 queries per month, that is somewhere between $10 and $30 in raw model spend.

The one-time cost is the transcription. Whisper API is about $0.006 per minute of audio, so 450 videos averaging 12 minutes each is roughly $32 total. Running Whisper locally on your own GPU is free.

What is the biggest mistake when building a RAG chatbot?

The biggest mistake is skipping the chunking and tagging step and dumping raw transcripts straight into a vector database. You get retrievals that pull the wrong slice of text, answers that miss the point, and no way to link users to the source lesson.

The second biggest mistake is skipping the anti-hallucination guardrail in the system prompt. Without an explicit “if you do not know, say so” instruction, models will invent shipping policies, promise features that do not exist, or misquote your course. That kills trust.

The third mistake is choosing podcasts as your first content type to train on. Multi-topic conversational content is the worst starting point for RAG. Start with course lessons, blog posts, or product descriptions where each unit already covers one topic.

Using RAG for e-commerce: a product recommendation bot for a Shopify store

The same RAG pattern makes a strong product-recommendation bot for a Shopify store. Feed in every product description, all your policy pages, and (this is the key move) a generated list of use cases and occasions for each product.

For Bumblebee Linens, my e-commerce store, I am doing exactly this for our nearly 1,000 handkerchiefs. AI generates the occasions each style fits (wedding, Valentine’s Day, baby shower, baptism, corporate gift, and so on), and those tagged use cases get embedded alongside the product data. When a customer asks “I need something for a baby shower,” the bot pulls the exact styles tagged for that occasion.

Two guardrails matter here. First, make it obvious the customer is talking to a bot, not a human. Second, sandbox the answers: never let the bot quote prices, shipping fees, or policies unless they come directly from a retrieved chunk. A hallucinated “shipping is always free” costs real money.

Can I build this without knowing how to code?

You can build a small RAG chatbot without writing code by using Make.com plus a hosted vector database. The tradeoff is that no-code builds run out of runway at scale (a few thousand chunks) and give you less control over prompt tuning.

The realistic path for most non-coders is a hosted service like Chatbase, Fini, or Kommunicate. Point the tool at your website or upload your files, pick a plan, and you have a working bot in an hour. Costs range from about $20 a month for a starter to $500 a month for higher-traffic tiers.

The value of building it yourself is control and cost. Once the pipeline is wired up, ongoing model spend is pennies. A hosted service marks up that cost significantly.

How do I keep a RAG chatbot current as I add new content?

You retrain a RAG bot by rerunning the chunk-embed-store pipeline on any new content and appending the new vectors to your database. There is no full-model retraining involved. The database gets updated, not the LLM itself.

In the current version of Stevebot, this is a manual step that takes about 10 minutes per new lesson (transcribe, chunk, tag, embed, upload). The goal is to automate it: drop a video into a folder, and a workflow triggers transcription, chunking, and vector upload with no human touch.

Automating retraining is worth the extra day of setup if you publish weekly. If you publish monthly, running it by hand is fine.

Frequently asked questions

What is a RAG chatbot?

A RAG (retrieval-augmented generation) chatbot is an AI assistant that answers questions using a small, relevant slice of your own content rather than the LLM’s general training data. At query time, the system retrieves the most relevant chunks of your knowledge base and passes them to the model, which composes an answer citing those sources.

How much does it cost to build a custom AI chatbot from my content?

Building a custom RAG chatbot costs roughly $10 to $50 in one-time transcription and setup if you have a few hundred videos, and $10 to $200 per month in ongoing model and hosting costs depending on traffic. Non-coders using a hosted service like Chatbase pay $20 to $500 per month with no setup work.

What is the best way to transcribe hundreds of videos for AI training?

The best way to bulk-transcribe videos is OpenAI’s Whisper model, either self-hosted for free on a machine with a decent GPU or via the Whisper API at about $0.006 per minute. For no-code workflows, use Make.com to send Dropbox files to the Whisper API and save the transcripts back to Dropbox.

Why can’t I just upload my whole course to ChatGPT?

You cannot upload a whole course to ChatGPT because every LLM has a context-window limit measured in tokens, and a 450-video course is millions of tokens (orders of magnitude larger than any current context window). Even if you could, the cost of resending all that content on every query would be prohibitive. RAG solves both problems by sending only the ~2,500 most relevant tokens per query.

How do I stop a RAG chatbot from hallucinating?

Add a strict instruction in the system prompt telling the model to say “I don’t know” if the answer is not in the retrieved chunks, and make the model quote or cite the retrieved chunk when answering. Combine that with strong retrieval (well-chunked, well-tagged content) and hallucinations drop dramatically. The system prompt is the single most important defense.

How do I chunk transcripts for a RAG chatbot?

Chunk transcripts into blocks of roughly 500 words with a short overlap between adjacent chunks so no sentence gets cut in half. For content that stays on one topic per block (course lessons, product pages), simple length-based chunking works well. For multi-topic content like podcasts, use AI to preprocess and segment the transcript by topic before chunking.

Can a RAG chatbot work for an e-commerce store?

A RAG chatbot works well for an e-commerce store as a product-recommendation and support tool. Feed in product descriptions, policy pages, and AI-generated occasion tags for each product, then let customers ask questions like “what should I get for a baby shower.” The main guardrail is preventing the bot from inventing shipping or pricing information.

What are the best off-the-shelf tools if I do not want to build my own?

The most common hosted RAG chatbot tools are Chatbase, Fini, Kommunicate, and Voiceflow, all of which let you upload files or point at a website and get a working bot in about an hour. Pricing ranges from $20 to $500 per month depending on message volume and features. These trade cost for convenience compared to a custom Python build.

Ready To Get Serious About Starting An Online Business?

If you are really considering starting your own online business, then you have to check out my free mini course on How To Create A Niche Online Store In 5 Easy Steps.

In this 6 day mini course, I reveal the steps that my wife and I took to earn 100 thousand dollars in the span of just a year. Best of all, it's absolutely free!