Nothing matches those filters.

Newsletter

1
15:01

Build Production-Ready Agentic-RAG Applications From Scratch Course: What we are going to build

A newsletter announces a course starting September 27th that builds a production-ready agentic RAG application from scratch. The project takes a GitHub repository URL, crawls and indexes the files, then lets users chat with the code through a React frontend, FastAPI backend, and LangGraph orchestration, with Pinecone for storage. Sessions are live hands-on coding covering indexing, basic RAG, making it agentic, and horizontal scaling. Another promo for the same course.

Notes
Build Production-Ready Agentic-RAG Applications From Scratch — course announcement

Launch date: Saturday, September 27, 2025 (per source date). Fully hands-on, "live, hands-on coding session" per component, taught from scratch as on-the-job build.

The app: a web app that takes a GitHub repo URL, scrapes/indexes its files into a vector DB, then answers questions about that code.

Stack:

  • React (frontend)
  • FastAPI (backend)
  • LangGraph (agentic orchestration)
  • Pinecone (vector DB)
  • Langsmith (observability)
  • Deployed to Google Cloud (GCP)

Backend endpoints: (1) indexing endpoint — takes repo URL + "crawl" action to start crawl/index; (2) chat endpoint — responds to chatbot messages. Frontend has two pages: an indexing page (URL input + crawl trigger) and a chatbot page.

Course structure (project-based):

  • Introduction — what we build, environment setup
  • The RAG Application — data parsing pipeline → indexing pipeline → basic RAG pipeline → add Langsmith observability → going agentic
  • The Backend Application — indexing API endpoint, adding memory, administering DB data
  • The Frontend Application — indexing page, chatbot page
  • Deploying to GCP

"Going agentic" definition (quoted): "we are going to use an LLM as a decision engine to enhance the quality of our pipeline." Deliberate trade-off: improves accuracy "at the cost of latency and cost," with discussion of offsetting those with small language models and fine-tuning. Three subagents, one per component: intent router (entry point, decides if RAG is needed), retriever (extracts the right data), generator (produces the response).

Scaling up: target is deploying to 1M users — all endpoints designed asynchronous, indexing requests queued, elastic load balancing for horizontal scaling.

Caveat/limitation stated: none given beyond the latency/cost trade-off; no pricing or prerequisites mentioned in the announcement.

Full text · 3,188 chars
On Saturday, September 27th, I am launching a new course: Build Production-Ready Agentic-RAG Applications From Scratch! This is a fully hands-on course where we are going to deploy a production-ready Agentic-RAG application with LangGraph, FastAPI, and React! Here is what we are going to build. What we are going to build We are going to build a fun web application where we can demonstrate how to orchestrate a robust RAG application using LangGraph, FastAPI, and React. Here is what we are going to build: - A user can pass a GitHub repository URL - The files of the related repository are scraped and indexed in a vector database - Now the code is available for the user to ask questions about. On the frontend, we will need two main functionalities: - A page where we can input the repository URL and start the crawling and indexing processes: - And a chatbot interface to ask questions about the code in the repository: On the backend, we will need the related endpoints: - The indexing endpoint will respond to the provided GitHub repository URL and the “crawl“ action to start the crawling and indexing processes. - The chat endpoint that will respond to messages sent by the user from the chatbot interface. We are going to use the following tools: - React for the frontend - FastAPI for the backend - LangGraph for the agentic orchestration - Pinecone for the vector database - Langsmith for observability - Deploy everything on Google Cloud! Project-based course We will focus on building the project from the ground up, as we would on the job. Here is how we are going to structure the project development: - Introduction - What we want to build - Setting up the environment - The RAG Application - The Data Parsing Pipeline - The Indexing Pipeline - The Basic RAG Pipeline - Adding Observability to the Pipeline with Langsmith - Going Agentic - The Backend Application - The Indexing API Endpoint - Adding Memory - Administering the Database Data - The Frontend Application - The Indexing Page - The Chatbot Page - Deploying to GCP Each session will be a live, hands-on coding session where we are going to implement every component from scratch Going Agentic “Agentic” means that we are going to use an LLM as a decision engine to enhance the quality of our pipeline. We will focus on improving the accuracy of the pipeline at the cost of latency and cost, and discuss the opportunities to reduce those induced negative points with small language models and fine-tuning. In the RAG pipeline, we are going to build a subagent for each of the main components: - Intent router: the entry point of the pipeline that will decide if a RAG pipeline is required. - The retriever: The sub-agent that will extract the right data - The generator: The sub-agent that will generate the response to the user Scaling up With this course, I want to focus on what we would need to do to deploy the application to 1M users. We will make sure to design every endpoint to be asynchronous, queue the indexing requests, and deploy the application with elastic load balancing to scale the application horizontally. This is going to be a fun ride! Make sure to join us!