Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

Building a RAG application in Go (Golang)

Name: Building a RAG application in Go (Golang)
Rating: 4.7 (42 reviews)

Learn Retrieval-Augmented Generation by building one in plain Go, against any OpenAI-compatible model — local or hosted

Bestseller

Highest Rated

Created byTrevor Sawler

Last updated 5/2026

English

English [Auto],

What you'll learn

How a RAG pipeline actually works end-to-end: chunking, embedding, vector search, query rewriting, context injection, and streaming generation
How to design Go interfaces so the LLM, the embedder, and the vector store are swappable without touching the rest of the codebase
How to stream LLM tokens to a terminal AND to a browser with Server-Sent Events
How to run everything against OpenAI, Ollama, LM Studio, or Groq — and how to mix and match (e.g. hosted chat with local embeddings)
How to use Postgres + pgvector for production-grade vector search, including HNSW indexes and embedding-dimension migrations
How to ingest documents reactively with fsnotify, debouncing half-written files, and idempotent re-ingest
How to handle multimodal content: image upload, vision-model captioning, and image rendering in chat

Course content

7 sections • 45 lectures • 8h 33m total length

Introduction5:21
Explore retrieval augmented generation with embeddings, vector stores, retrievers, and rewriters to empower LLMs and reduce hallucinations, then build a console and web chat app using your chosen model.
Installing Go1:46
download the appropriate go binary from go.dev for windows, mac (apple silicon or intel), or linux, run the installer, follow platform instructions, verify with go version, and update if needed.
Setting up an IDE2:47
Asking for help1:14
Seek help by first searching online, then compare your code to the lecture's source, check the Q&A, and finally share runnable code or a Git link for tailored assistance.

Setting up a basic Go application21:59
Set up a basic Go web app that connects to an LLM using the official OpenAI Go SDK, with modular folders for app, config, LLM, and chat.
Finishing up the llm package13:44
Finish wiring the llm package to enable streaming chat completion in the Go RAG app, implement chat stream, message formatting, delta handling, and resource safeguards.
Setting up the chat package25:14
Set up the chat package to manage a chat session, seed history from a system prompt file, and stream responses via the LLM client in a repl-driven flow.
A note about Cloud models2:08
Setting up our model with Ollama9:03

Getting started by enabling a system prompt5:02
Enable a system prompt to guide the LLM in your Go-based RAG app by creating prompts/system-custom.md, loading the system_prompt_file, and seeding chat history.
Setting up the database Vector Store in Postgres3:15
Set up a Postgres 18 vector store for a RAG system in Docker, enabling pgvector and creating a documents table with an embedding vector.
Defining a Vector Store interface9:29
Define a vector store interface in Go to index high-dimensional embeddings for documents and support upsert, query, delete, and close for scalable similarity search.
Implement the interface for Postgres & pgvector: Part I24:16
Implement the interface for Postgres & pgvector: Part II15:54
Implement upsert and query operations for Postgres pgvector store in Go, handling metadata marshaling to JSONB, embedding storage, and top-k retrieval with distance-to-score conversion.
Implement the interface for Postgres & pgvector: Part III4:34
Enabling the vector back end: Part I8:47
Add database URL and embedding dim to the config, default embedding dim to 768 for nomic embed text, and open a pgVector vector store from the DSN with readiness logs.
Enabling the vector back end: Part II5:31
Enable the vector back end by configuring the Postgres connection and initializing the pgvector store, then test the run and verify the documents table migration for the RAG server.

Setting up our embedder12:09
Setting up a client for our embedding model7:40
Define two Go clients, one for the LLM and one for the embedding model, enabling cloud or local models with separate base URLs and API keys loaded from config.
Setting up a chunker13:07
Set up a chunker to split ingested documents into chunks stored in a Postgres vector database, and configure ingest and processed directories plus an embedding model with sensible defaults.
Setting up an ingestor25:11
Set up an ingestion pipeline that reads documents, chunks text into overlapping windows, embeds chunks into vectors, deletes prior chunks, and upserts new chunks into the vector store with metadata.
Loading documents into the ingestor27:33
Wiring the ingestor into the app6:24
Wiring the ingestor into the app, this lecture shows creating a cancelable context and an embedder, plus wiring a directory watcher with a wait group and logging for clean shutdown.
Trying things out7:31
Explore building a go-based rag application by loading a nomic embed text model, configuring embedding settings, ingesting documents, and instructing the llm to use the relevant vector store chunks.

How RAG works4:03
Trace how RAG handles a user question through embedding, vector-store retrieval, and a rewriter that shapes the LLM prompt with retrieved chunks and sources.
Getting started with our RAG package9:07
Setting up our retriever and rewriter28:14
Adding the retriever/rewriter into the Read-Evaluate-Print-Loop code11:24
Integrate the retriever and rewriter into the repl loop by inline-context rewriting the latest user message and passing a turn with embedded excerpts to the LLM via chatStream.
Wiring our changes into app.go4:11
Wire a retriever and a rewriter into app.go to fix the runrepl call, using rag.new and rag.newRewriter with the client, an embedder, and a store.
Trying things out6:38
Set up a local rag app in go by moving the spinner before llm queries, loading documents, and testing a vector store with cosine similarity.
Verifying the modified user prompt2:34

Setting up the web server I14:23
Develop a web version of the chat in Go, enabling document uploads and future image additions to a vector store, using embedded Go templates and HTTP routes.
Setting up the web server II: the chat page12:11
Displaying the chat page8:30
Wire the chat page into the go web app by configuring http addr, images dir, and vision model, then start the web server to display the chat at localhost:8080/chat.
Enabling web chat21:18
Implement a streaming chat with a new http route /api/chat/stream, render the chat history, use server-sent events for live updates, and integrate a retriever to enrich user prompts.
Trying out web chat2:30
Wire up app.go, run the web server on port 8080, test chat interactions with a markdown-rendered LLM response, and preview enabling file uploads to the document and vector stores.
Uploading files to the vector store from the web interface15:55
Enable users to upload files through the web interface, ingesting content into the vector store for the RAG system by chunking, embedding, and returning a JSON summary.
Adding images to the vector store36:26
Trying out image upload14:36
Upload an image to the vector store, verify it in Postgres, fix formatting, and update prompts to render images in RAG results with markdown.
Getting a vision model and setting it up11:40
Setting up the route and handler for the vision model8:51
Set up a vision route and caption handler in go, posting to /api/caption, parsing multipart form data, validating the image, and returning a json caption with a description.
Trying out image captioning2:47
Explore image captioning in a go-based rag application by configuring the vision model, uploading images, and generating auto captions through the chat interface.

Requirements

A basic understanding of the Go programming language
Comfortable reading and writing basic Go (functions, structs, interfaces, goroutines)
Docker installed locally (for Postgres + pgvector)
An OpenAI API key or a local model runner like Ollama — the course works with either, and shows you how to switch
No prior RAG, ML, or vector database experience required

Description

Build a Production-Style RAG System in Go — From Zero to Streaming Chat

Learn Retrieval-Augmented Generation by building one yourself, in plain Go, against any OpenAI-compatible model — local or hosted.

Stop reading about RAG and start shipping it. In this hands-on course you will build a complete, end-to-end Retrieval-Augmented Generation system from the ground up using the Go programming language. No Python. No LangChain. No magical abstractions. Just clear, idiomatic Go code that you can read, modify, and own.

By the end of the course, you will have a working application featuring a streaming terminal chat REPL, a browser-based chat UI with token-by-token Server-Sent Events, file and image uploads, a background filesystem watcher that ingests documents automatically, an evaluation harness that scores retrieval quality, and a Postgres + pgvector backend running in Docker.

Why this course?

Most RAG tutorials hide the interesting parts behind a framework. You wire three lines of someone else's library together, it works, and you have no idea what just happened. When something breaks in production — and it will — you are stuck.

This course takes the opposite approach. Every component is built explicitly, with clean seams between concepts so you can see exactly where the LLM client ends and the vector store begins. The package layout maps directly to lecture chapters. The interfaces between the LLM, the embedder, the vector store, the retriever, the chat loop, and the web server are deliberately exposed so you can swap pieces in and out as exercises.

This is the course I wish existed when I was learning RAG.

What you will build

A small but real RAG application with all the moving parts of a production system:

A streaming chat REPL (Read-Eval-Print Loop) in the terminal with a "thinking" spinner and proper history management
A web chat UI built with chi, Go templates, and Tailwind, streaming tokens to the browser over SSE with in-browser markdown rendering
A background filesystem watcher that detects new documents, chunks them, embeds them, and upserts them into pgvector — then moves the originals out of the way
A synchronous file upload path on the web UI for drag-and-drop ingest with chunk-count feedback
An image upload pipeline with optional auto-captioning by a vision-capable model, served back to the browser and rendered inline in chat
A paragraph-aware chunker with configurable size and overlap
A query rewriter that turns multi-turn conversation into a standalone search query before retrieval
A retriever with cosine-similarity filtering, top-K hit selection, and pluggable backends
A pgvector + Postgres 18 vector store with idempotent migrations, HNSW indexing, and a delete-by-source path that keeps re-ingest clean

What you will learn

How a RAG pipeline actually works end-to-end: chunking, embedding, vector search, query rewriting, context injection, and streaming generation
How to design Go interfaces so the LLM, the embedder, and the vector store are swappable without touching the rest of the codebase
How to stream LLM tokens to a terminal AND to a browser with Server-Sent Events
How to run everything against **OpenAI, Ollama, LM Studio, or Groq** — and how to mix and match (e.g. hosted chat with local embeddings)
How to use Postgres + pgvector for production-grade vector search, including HNSW indexes and embedding-dimension migrations
How to ingest documents reactively with `fsnotify`, debouncing half-written files, and idempotent re-ingest
How to handle multimodal content: image upload, vision-model captioning, and image rendering in chat
How to debug "why didn't the model use my docs?"

What makes this course different

Real code, not pseudo-code. Every example in the course is from a working, runnable project.
Local-first. You can complete the entire course with Ollama on your laptop. No API bills required.
Honest about tradeoffs. The course covers known limitations (chunker is token-blind, delete-then-upsert is not transactional, image retrieval is description-based) so you understand the design space, not just one fixed answer.

Tech stack you will use

Go, Postgres 18, pgvector, Docker Compose, chi router, Go templates, Tailwind, Server-Sent Events, fsnotify, OpenAI-compatible APIs (works with OpenAI, Ollama, LM Studio, Groq, and others).

Course outcome

When you finish this course, you will have a portfolio-quality RAG application running on your machine, a deep understanding of how every layer works, and the confidence to drop the same architecture into a real product at work. You will know what to measure, what to swap, and what to leave alone.

Enrol now and start building your own RAG system today.

Who this course is for:

Go developers who want to understand AI applications without leaving their language of choice
Python AI engineers who want to see what RAG looks like without a framework hiding the mechanics
Backend Engineers considering RAG for a real product and wanting a clear mental model of the moving parts
Students and self-learners who learn best by building rather than reading
nyone tired of "pip install langchain" tutorials and wanting code they can actually read

Building a RAG application in Go (Golang)

What you'll learn

Explore related topics

Course content

Introduction4 lectures • 11min

Getting started5 lectures • 1hr 12min

Setting up our Vector Store8 lectures • 1hr 17min

Adding Documents to the Vector Store7 lectures • 1hr 40min

Implementing Retrieval Augmented Generation (RAG)7 lectures • 1hr 6min

Setting up a Web App11 lectures • 2hr 29min

Considerations for deployment3 lectures • 38min

Requirements

Description

Who this course is for: