DEV Community: Suraj Bera

# Day 5 of learning AI Engineering: built a small RAG app over a PDF

Suraj Bera — Tue, 19 May 2026 18:47:31 +0000

I built a small RAG (Retrieval Augmented Generation) project where a user can ask questions from a PDF, and the LLM answers from that PDF along with the page number to look at. The stack is LangChain, OpenAI embeddings, and Qdrant running in Docker.

A small note before we start: this exact same pipeline is what powers web-apps like an "AI Tutor in Educative", an "AI web page builder". The only thing that changes between those products and my PDF Q&A is the data source. That is the key idea to take away.

What RAG is, in one line

Take a document → break it into small chunks → turn each chunk into a vector (a list of numbers) → store those vectors in a database. Later, when the user asks a question, turn the question into a vector too, find the closest chunks, and feed them to an LLM as context.

INDEXING (run once)
───────────────────

   PDF file
      │
      ▼
   PyPDFLoader
      │  one Document per page (text + metadata)
      ▼
   RecursiveCharacterTextSplitter
      │  chunk_size = 1000, overlap = 200
      ▼
   ~200 small text chunks
      │
      ▼
   OpenAIEmbeddings (text-embedding-3-small)
      │  each chunk becomes a 1536-dim vector
      ▼
   Qdrant (running in Docker)
      │  vector + chunk text + page metadata stored


QUERY (every user question)
───────────────────────────

   "explain me about variables"
      │
      ▼
   OpenAIEmbeddings
      │  same model, same vector space
      ▼
   Query vector (1536-dim)
      │
      ▼
   Qdrant similarity_search (cosine, top k = 4)
      │  closest 4 chunks come back
      ▼
   Build a prompt with those chunks as context
      │
      ▼
   OpenAI Chat Completion (gpt-5-nano)
      │
      ▼
   Final answer + page citations

The stack and why I picked it

LangChain is the glue. It gives me one interface to talk to many providers. If I want to swap OpenAI for Cohere, or Qdrant for Pinecone, I change one line. It also has loaders for PDFs, websites, Notion, Google Docs, CSVs, image files, and a lot more. Plus tools for chains, agents, memory, prompts, and output parsing.
Qdrant is the vector database. I ran it locally in Docker so I don't have to pay for a managed service while learning.
OpenAI text-embedding-3-small is the embedding model. More on why this one and not the large one further down.
uv instead of pip. Faster, lockfile-based, and the modern Python experience.

Some things worth pointing out:

The embedding model is just a client — no API call happens when you create it. The actual call to OpenAI happens inside from_documents.
from_documents is the convenience method. It connects to Qdrant, creates the collection, embeds every chunk, and inserts it. One call, three jobs.

Now the real question — how big a PDF can I actually ingest?

This is the part I couldn't find a straight answer to in any tutorial. The pipeline above worked beautifully for my 123 KB, 71-page PDF. But what about a 100 MB book? A 1 GB legal document dump?

The answer has many layers. There is no single PDF size limit.

Layer	Hard limit?	What actually matters
PyPDFLoader	No	RAM. The whole PDF gets loaded into memory before chunking.
RecursiveCharacterTextSplitter	No	None. It just splits whatever you give it.
OpenAI embeddings API	Yes	Tokens per input + rate limits per minute + your wallet.
Qdrant	Practically no	Designed for millions of vectors.
Your laptop	Yes	RAM, disk, and patience.

The actual bottleneck is almost always OpenAI, not Python or Qdrant.

What OpenAI actually limits

There are three things to watch on the embeddings API.

1. Max tokens per single input — 8,191

Each chunk you send to be embedded can be at most 8,191 tokens, which is roughly 32,000 characters. My chunk_size=1000 is way below that, so this is never hit in normal RAG. Official source: https://platform.openai.com/docs/guides/embeddings

2. Rate limits — RPM (requests per minute) and TPM (tokens per minute)

These depend on your account tier. Tier 1, where most new accounts start, looks like this:

Tier	RPM	TPM	Batch queue limit
Free	100	40,000	—
Tier 1	3,000	1,000,000	3,000,000
Tier 2	5,000	1,000,000	20,000,000
Tier 3	5,000	5,000,000	100,000,000
Tier 4	10,000	5,000,000	500,000,000
Tier 5	10,000	10,000,000	4,000,000,000

Your tier moves up automatically as you spend more on the platform.

Official rate limit docs: https://platform.openai.com/docs/guides/rate-limits/usage-tiers
Your own account's limits: https://platform.openai.com/account/limits

When you hit the TPM, LangChain backs off and retries automatically. So your script doesn't crash — it just takes longer.

3. The cost — $0.02 per 1M tokens for text-embedding-3-small

This is the most underrated number. A 100 MB text PDF is roughly 20–50 million tokens. That works out to about $0.40 to $1.00 in embedding cost. Real-world cheap. Pricing page: https://platform.openai.com/docs/pricing

Day 3: Prompting Techniques in AI

Suraj Bera — Tue, 19 May 2026 18:25:53 +0000

AI Prompting techniques: Zero-shot, One-shot, Few-shot

After using the ChatGPT and other AI tools, I used to think prompts were just simple text inputs that AI models magically processed. But as mentioned in my Day 1 post: AI models are just next-word predictors, not thinkers. They predict based on training data (though modern ones now use real-time search and tool calling for better results).

The Basics
Simplest python code snippet for getting response from AI

response = client.responses.create(
    model="gpt-5-nano",
    input=[
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": "How do I reverse a list in Python?"},
    ]
)

The most important point to note: role key has 3 values: system, user, assistant. The system prompt sets the behaviour.

1. Zero-shot prompting
No examples -- just instructions in the system prompt

SYSTEM_PROMPT = """
You are a helpful assistant that only answers Python programming questions.
If the user asks about anything else, politely decline.
"""

2. One-shot prompting
Provide one example how model should respond.

input=[
    {"role": "system", "content": SYSTEM_PROMPT},
    {"role": "user", "content": "What is the capital of France?"},
    {"role": "assistant", "content": "I'm sorry, I can only help with Python programming questions."},
    {"role": "user", "content": "How do I reverse a list in Python?"},
]

3. Few-shot prompting
Provide multiple examples so the model responds more precisely:

input=[
    {"role": "system", "content": SYSTEM_PROMPT},
    {"role": "user", "content": "How to code a binary tree in Python?"},
    {"role": "assistant", "content": "Sure, here's an implementation..."},
    {"role": "user", "content": "What is the weather today?"},
    {"role": "assistant", "content": "I'm sorry, I can only help with Python programming questions."},
    {"role": "user", "content": "What is the capital of France?"},
    {"role": "assistant", "content": "I'm sorry, I can only help with Python programming questions."},
    {"role": "user", "content": "Why is 75% attendance required for the exam?"},
]

So as a beginner trying to get into AI engineering, you need to shift your mindset from just chatting with AI mindlessly to designing system prompt for your own AI product.

Complete code for few-shot-prompting

Links to day 1 and day 2

Part 1: Learning Docker for beginners

Suraj Bera — Mon, 11 May 2026 11:11:11 +0000

What is a Dockerfile?

It contains instruction that docker uses to package up an application into an image.

Containers and Images, What are these?

Images: An image includes everything an application needs to run. It includes application files, environment variables and so on.
Container: Once we have an image, we can start a container from it. A container is like a VM in a sense that it provides an isolated environment for executing an application. Similar to VM we can stop and restart a container.

Simplified Analogy: Think of images as a class(blueprint) and containers as running instance(objects) for that blueprint.

Steps to create a Dockerfile:

Choose a correct base image
Setup the working directory
Copy application files into the image. Example: COPY <source> <destination>
Exclude files & folders(node_modules, venv, etc)
Adding environment variables
Exposing ports

By default docker runs an application with the root user that has the highest privileges.

Diff. between CMD and RUN instructions:

With both these we can execute instructions. The RUN instruction is a build time instruction. This is executed at the time of building an image. Example: npm install
The CMD instruction is a runtime instruction, it's executed when starting a container.

Day 4: ReAct - Reasoning + Acting upon(Prompting Technique)

Suraj Bera — Mon, 04 May 2026 15:04:12 +0000

Big picture of ReAct:

AI doesn't just answer immediately, it goes through stages.
think -> plan -> action -> observe -> output(total 5 steps)

ReAct = Forcing the AI to show its work step by step before arriving at a conclusion, just like how a student arrives to the solution of a math problem step by step.

Here is the simplest mental model for ReAct:


┌──────────────────────────────┐   ┌──────────────────────────────┐   ┌──────────────────────────────┐
│ Current State / User Question│ → │ Reason about current state   │ → │ Need more action?            │
└──────────────────────────────┘   └──────────────────────────────┘   └──────────────┬───────────────┘
                                                                                       │
                                                                           ┌───────────┴───────────┐
                                                                           │                       │
                                                                          Yes                      No
                                                                           │                       │
                                                                           v                       v
                                                ┌──────────────────────────────┐   ┌──────────────────────────────┐
                                                │ Choose tool / perform action │   │ Return final answer          │
                                                └──────────────┬───────────────┘   └──────────────────────────────┘
                                                               │
                                                               v
                                                ┌──────────────────────────────┐
                                                │ Observe result               │
                                                └──────────────┬───────────────┘
                                                               │
                                                               └──── back to "Reason about current state"

Comparing Chain of Thought(another prompting technique) vs ReAct:
CoT - In this technique, the LLM is instructed to generate its intermediate reasoning steps as part of the output, instead of jumping straight to the final answer.
ReAct - CoT only thinks, ReAct thinks and does stuffs.

Here is the code

Links to Day 3 and Day 2

Day 2: Vector Embeddings in simplest terms

Suraj Bera — Sun, 03 May 2026 05:03:53 +0000

This is my Day 2 of learning AI fundamentals where I will be covering the following concepts:

Vector Embeddings
How Tokenisation and Vector Embeddings relate to each other

Vector embeddings:

Vector embeddings is the process of turning each token id(generated during tokenisation) into high dimensional vector where semantic similarity results into geometric closeness. Think of it like this: dog is closer to puppy, also closer to dog food. But dog is not closer to car or petrol.

When we use embeddings?

Recommendations: Suggest similar songs, videos, movies, products
Search: Get search results when keywords don't match
Cluster: Grouping related concepts together.

A beginner might be confused in terms like: Vector, High Dimensional.

This is an example of a vector: [0.9, 0.8, 0.1]. Array/List/Vector all mean the same thing. 'List' is just a plain english, 'array' is the programming term, vector is the math/ml term.
High Dimensional: Multi-dimensional just means more than 1 - could be 2D, 3D, 10D,... too vague. But high dimensional specifically means hundreds of thousands of dimensions(Open AI's text-embedding-3-small = 1536 dimensions)

There are 2 types of Search:

Lexical Search: Exact words/characters search
Semantic Search: Meaning/Intent search

Vector embedding enables semantic search

How tokenisation & vector embeddings are connected together?

text-tokenisation --> token Ids-embedding lookup --> vectors --> transformers
"hello" --> [221728] --> [0.21,-0.44,...]

Vector Embedding Visualizer

Here is the link to part 1