What happens if the answer isn't in the source documents?

The model is grounded in retrieved context — if nothing relevant comes back from retrieval, it says so instead of inventing an answer. That's the whole point of RAG over a plain chatbot.

Why Pinecone instead of a simpler vector store?

Pinecone handles similarity search reliably at scale without managing infrastructure yourself — a better fit for something meant to run in production than a local-only solution.

Can I adapt this to my own documents?

Yes — the code's on GitHub. Swap in your own source documents and re-index.

Building a Production-Ready RAG Chatbot with Next.js, LangChain, and Pinecone

"Just call the OpenAI API" gets you a chatbot that can hallucinate confidently about things it knows nothing about — like your actual resume, projects, and skills. RAG Chat Bot is my implementation of Retrieval-Augmented Generation done properly: a chatbot that answers questions grounded in real source documents instead of guessing.

What RAG actually solves

An LLM on its own has no idea what's in your resume or your GitHub. RAG fixes that by retrieving the actual relevant text from your documents before generating an answer, and feeding that text to the model as context. The model isn't asked to "know" your background — it's asked to summarize and reason over text it's handed at query time.

The pipeline

Chunking — source documents (resume, project descriptions, skills) get split into smart, sized chunks. Chunk too big and retrieval gets imprecise; chunk too small and you lose context — getting this balance right is most of the tuning work in a RAG system.
Embeddings — each chunk is embedded into vector space and stored in Pinecone, a vector database built for fast similarity search at scale.
Retrieval — when a question comes in, it's embedded the same way, and Pinecone returns the chunks most semantically similar to the question — not just keyword matches.
Generation — OpenAI generates the answer using only the retrieved chunks as grounding context, with the response streamed back token by token so the UI feels responsive instead of making the user stare at a spinner.

Why streaming matters more than it seems

A RAG pipeline with retrieval + generation can take a few seconds end to end. Waiting silently for three seconds feels broken; watching the answer type itself out in real time over the same three seconds feels fast. It's the same latency, but a completely different user experience — and it's a detail a lot of RAG demos skip.

Stack

The RAG pipeline

Stage	Tool	Purpose
Chunking	Custom document splitter	Breaks source docs into retrievable pieces
Embeddings & storage	Pinecone	Vector similarity search at query time
Orchestration	LangChain	Wires retrieval into the generation call
Generation	OpenAI (streamed)	Produces the grounded, streamed answer

RAG doesn't make a model smarter — it makes a model's answers grounded in text it was actually handed, instead of text it's guessing at.

Next.js 14 for the frontend, LangChain to orchestrate the retrieval + generation flow, Pinecone for vector storage, and OpenAI for embeddings and generation, styled with Tailwind CSS. Source on GitHub.